《Hot Code Reloading in Cloud Haskell》

【实例截图】

【核心代码】

Contents
List of Figures viii
1 Introduction 1
1.1 Challenges in a distributed system . . . . . . . . . . . . . . . . . . . 2
1.2 Hot Code Reloading . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.2.1 The Problem . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.2.2 Why Hot Code Reloading . . . . . . . . . . . . . . . . . . . . 3
1.2.3 Example of Hot Code Reloading in Erlang . . . . . . . . . . . 4
1.3 Contributions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2 A brief tour of Cloud Haskell 7
2.1 The Design Decisions . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.1.1 Implementing Erlang in Haskell . . . . . . . . . . . . . . . . . 7
2.1.2 Library vs Run Time System . . . . . . . . . . . . . . . . . . 8
2.1.3 Modular Architecture . . . . . . . . . . . . . . . . . . . . . . 9
2.1.4 The Actor Model and Cloud Haskell . . . . . . . . . . . . . . 10
2.1.5 Actor vs Thread . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.2 The Core API . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.3 Ping Pong in Cloud Haskell . . . . . . . . . . . . . . . . . . . . . . . 12
3 Related work 15
3.1 Formal specification of DSU . . . . . . . . . . . . . . . . . . . . . . . 15
3.2 Related ideas and techniques . . . . . . . . . . . . . . . . . . . . . . 16
vi
3.2.1 Quiescence . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
3.2.2 Binary Code Rewriting . . . . . . . . . . . . . . . . . . . . . . 17
3.2.3 Proxies, Intermediaries and Indirection Levels . . . . . . . . . 17
3.2.4 State Transfer and Transformation Functions . . . . . . . . . 18
3.2.5 Source code static analysis . . . . . . . . . . . . . . . . . . . . 18
3.2.6 Using underlying facilities . . . . . . . . . . . . . . . . . . . . 18
3.2.7 Version Coexistence . . . . . . . . . . . . . . . . . . . . . . . 19
3.3 DSU and Functional Programming . . . . . . . . . . . . . . . . . . . 20
3.3.1 Haskell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
3.3.2 Erlang . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
4 An Attempt at Hot Code Reloading 22
4.1 Understanding Erlang’s Behaviour . . . . . . . . . . . . . . . . . . . 23
4.1.1 Message loss during updates . . . . . . . . . . . . . . . . . . . 24
4.1.2 Quiescence and Version Coexistence . . . . . . . . . . . . . . 24
4.2 An approach using plugins . . . . . . . . . . . . . . . . . . . . . . . . 26
4.2.1 The Plugins Way . . . . . . . . . . . . . . . . . . . . . . . . . 26
4.2.2 A minimal plugins example . . . . . . . . . . . . . . . . . . . 27
4.2.3 DSU in Ping Pong . . . . . . . . . . . . . . . . . . . . . . . . 29
4.2.4 Unresolved Problems . . . . . . . . . . . . . . . . . . . . . . . 30
4.3 The Proxy Approach . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
4.3.1 Cloning a Process . . . . . . . . . . . . . . . . . . . . . . . . . 36
4.3.2 Relocating a process . . . . . . . . . . . . . . . . . . . . . . . 36
4.3.3 Addressability and Roaming . . . . . . . . . . . . . . . . . . . 36
4.3.4 Other Problems . . . . . . . . . . . . . . . . . . . . . . . . . . 38
4.3.5 Evaluation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
5 Conclusions 40
5.1 Implementation Challenges . . . . . . . . . . . . . . . . . . . . . . . 40
5.2 Future work . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
vii
References 43
List of Figures
1.1 An example of hot code loading . . . . . . . . . . . . . . . . . . . . . 4
1.2 An example of hot code loading . . . . . . . . . . . . . . . . . . . . . 5
2.1 Cloud Haskell API . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.2 Ping Pong in Cloud Haskell . . . . . . . . . . . . . . . . . . . . . . . 13
4.1 Program to check message loss in Erlang . . . . . . . . . . . . . . . . 25
4.2 A minimal plugins example . . . . . . . . . . . . . . . . . . . . . . . 28
4.3 DSU in Ping Pong - PingPong.hs . . . . . . . . . . . . . . . . . . . . 31
4.4 DSU in Ping Pong - Main.hs . . . . . . . . . . . . . . . . . . . . . . . 32