2006 Scheme and Functional Programming Papers, University of

More documents

Recommendations

Info

Erlang Termite List length (µs) (µs) 0 53 145 10 52 153 20 52 167 50 54 203 100 55 286 200 62 403 500 104 993 1000 177 2364 Figure 5. Inter-node ping-pong: Measure of time necessary to send and receive a message of variable length between two processes running on two different nodes on the same computer. The inter-node ping-pong benchmark exercises particularly the serialization code, and the results in Figure 5 show clearly that Erlang’s serialization is significantly more efficient than Termite’s. This is expected since serialization is a relatively new feature in Gambit-C that has not yet been optimized. Future work should improve this aspect. Erlang Termite List length (µs) (µs) 0 501 317 10 602 337 20 123 364 50 102 437 100 126 612 200 176 939 500 471 1992 1000 698 3623 Figure 6. Remote ping-pong: Measure of time necessary to send and receive a message of variable length between two processes running on two different computers communicating through the network. Finally, the remote ping-pong benchmark additionally exercises the performance of the network communication code. The results are given in Figure 6. The difference with the previous program shows that Erlang’s networking code is also more efficient than Termite’s by a factor of about 2.5 for large messages. This appears to be due to more optimized networking code as well as a more efficient representation on the wire, which comes back to the relative youth of the serialization code. The measurements with Erlang show an anomalous slowdown for small messages which we have not been able to explain. Our best guess is that Nagle’s algorithm gets in the way, whereas Termite does not suffer from it because it explicitly disables it. 7.3.2 Process migration We only executed this benchmark with Termite, since Erlang does not support the required functionality. This program was run in three different configurations: when the process migrates on the same node, when the process migrates between two nodes running on the same computer, and when the process migrates between two nodes running on two different computers communicating through a network. The results are given in Figure 7. Performance is given in number of microseconds necessary for the migration. A lower value means better performance. The results show that the main cost of a migration is in the serialization and transmission of the continuation. Comparatively, Termite Migration (µs) Within a node 4 Between two local nodes 560 Between two remote nodes 1000 Figure 7. Time required to migrate a process. capturing a continuation and spawning a new process to invoke it is almost free. 8. Related Work The Actors model is a general model of concurrency that has been developed by Hewitt, Baker and Agha [13, 12, 1]. It specifies a concurrency model where independent actors concurrently execute code and exchange messages. Message delivery is guaranteed in the model. Termite might be considered as an “impure” actor language, because it does not adhere to the strict “everything is an actor” model since only processes are actors. It also diverges from that model by the unreliability of the message transmission operation. Erlang [3, 2] is a distributed programming system that has had a significant influence on this work. Erlang was developed in the context of building telephony applications, which are inherently concurrent. The idea of multiple lightweight isolated processes with unreliable asynchronous message transmission and controlled error propagation has been demonstrated in the context of Erlang to be useful and efficient. Erlang is a dynamically-typed semi-functional language similar to Scheme in many regards. Those characteristics have motivated the idea of integrating Erlang’s concurrency ideas to a Lisp-like language. Termite notably adds to Erlang first class continuations and macros. It also features directed links between processes, while Erlang’s links are always bidirectionals. Kali [4] is a distributed implementation of Scheme. It allows the migration of higher-order objects between computers in a distributed setting. It uses a shared-memory model and requires a distributed garbage collector. It works using a centralized model where a node is supervising the others, while Termite has a peer-to-peer model. Kali does not feature a way to deal with network failure, while that is a fundamental aspect of Termite. It implements efficient communication by keeping a cache of objects and lazily transmitting closure code, which are techniques a Termite implementation might benefit from. The Tube [11] demonstrates a technique to build a distributed programming system on top of an existing Scheme implementation. The goal is to have a way to build a distributed programming environment without changing the underlying system. It relies on the “code as data” property of Scheme and on a custom interpreter able to save state to code represented as S-expressions in order to implement code migration. It is intended to be a minimal addition to Scheme that enables distributed programming. Unlike Termite, it neither features lightweight isolated process nor considers the problems associated with failures. Dreme [10] is a distributed programming system intended for open distributed systems. Objects are mobile in the network. It uses a shared memory model and implements a fault-tolerant distributed garbage collector. It differs from Termite in that it sends objects to remote processes by reference unless they are explicitly migrated. Those references are resolved transparently across the network, but the cost of operations can be hidden, while in Termite costly operations are explicit. The system also features a User Interface toolkit that helps the programmer to visualize distributed computation. 134 Scheme and Functional Programming, 2006
9. Conclusion Termite has shown to be an appropriate and interesting language and system to implement distributed applications. Its core model is simple yet allows for the abstraction of patterns of distributed computation. We built the current implementation on top of the Gambit-C Scheme system. While this has the benefit of giving a lot of freedom and flexibility during the exploration phase, it would be interesting to build from scratch a system with the features described in this paper. Such a system would have to take into consideration the frequent need for serialization, try to have processes as lightweight and efficient as possible, look into optimizations at the level of what needs to be transferred between nodes, etc. Apart from the optimizations it would also benefit from an environment where a more direct user interaction with the system would be possible. We intend to take on those problems in future research while pursuing the ideas laid in this paper. 10. Acknowledgments This work was supported in part by the Natural Sciences and Engineering Research Council of Canada. References [1] Gul Agha. Actors: a model of concurrent computation in distributed systems. MIT Press, Cambridge, MA, USA, 1986. [2] Joe Armstrong. Making reliable distributed systems in the presence of software errors. PhD thesis, The Royal Institute of Technology, Department of Microelectronics and Information Technology, Stockholm, Sweden, December 2003. [3] Joe Armstrong, Robert Virding, Claes Wikström, and Mike Williams. Concurrent Programming in Erlang. Prentice-Hall, second edition, 1996. [4] H. Cejtin, S. Jagannathan, and R. Kelsey. Higher-Order Distributed Objects. ACM Transactions on Programming Languages and Systems, 17(5):704–739, 1995. [5] Ray Dillinger. SRFI 38: External representation for data with shared structure. http://srfi.schemers.org/srfi-38/srfi-38. html. [6] Marc Feeley. Gambit-C version 4. http://www.iro.umontreal. ca/ ∼ gambit. [7] Marc Feeley. SRFI 18: Multithreading support. http://srfi. schemers.org/srfi-18/srfi-18.html. [8] Marc Feeley. SRFI 21: Real-time multithreading support. http: //srfi.schemers.org/srfi-21/srfi-21.html. [9] Marc Feeley. A case for the unified heap approach to erlang memory management. Proceedings of the PLI’01 Erlang Workshop, September 2001. [10] Matthew Fuchs. Dreme: for Life in the Net. PhD thesis, New York University, Computer Science Department, New York, NY, United States, July 2000. [11] David A. Halls. Applying mobile code to distributed systems. PhD thesis, University of Cambridge, Computer Laboratory, Cambridge, United Kingdom, December 1997. [12] C. E. Hewitt and H. G. Baker. Actors and continuous functionals. In E. J. Neuhold, editor, Formal Descriptions of Programming Concepts. North Holland, Amsterdam, NL, 1978. [13] Carl E. Hewitt. Viewing control structures as patterns of passing messages. Journal of Artificial Intelligence, 8(3):323–364, 1977. [14] Richard Kelsey, William Clinger, and Jonathan Rees (Editors). Revised 5 report on the algorithmic language Scheme. ACM SIGPLAN Notices, 33(9):26–76, 1998. Scheme and Functional Programming, 2006 135
Page 1:
Scheme and Functional Programming 2
Page 4 and 5:
4 Scheme and Functional Programming
Page 6 and 7:
6 Scheme and Functional Programming
Page 8 and 9:
• A web browser that plays the ro
Page 10 and 11:
and requests. When a client request
Page 12 and 13:
above prevents pages from these dom
Page 14 and 15:
14 Scheme and Functional Programmin
Page 16 and 17:
2. Explaining Macros Macro expansio
Page 18 and 19:
For completeness, here is the macro
Page 20 and 21:
onment is extended in the original
Page 22 and 23:
expand-term(term, env, phase) = emi
Page 24 and 25:
Derivation ::= (make-mrule Syntax S
Page 26 and 27:
True derivation (before macro hidin
Page 28 and 29:
We assume that the reader has basic
Page 30 and 31:
the value of the %eax register by 4
Page 32 and 33:
Code generation for the new forms i
Page 34 and 35:
we introduced in 3.11. The only dif
Page 36 and 37:
the user code from interfering with
Page 38 and 39:
Page 40 and 41:
mization and on creating efficient
Page 42 and 43:
(a) stage (b) fifo (c) split (d) me
Page 44 and 45:
This tagging is used later in the c
Page 46 and 47:
(let ((clo_25 (%closure (lambda (y)
Page 48 and 49:
nb. cycles per element 1400 1200 10
Page 50 and 51:
Page 52 and 53:
a ∗ ❅ left right · b ❅ a S
Page 54 and 55:
T ([spec], w) = { {w}, if w ∈ L([
Page 56 and 57:
A([spec]): ✓✏ (where L([spec])
Page 58 and 59:
construction commands. It is possib
Page 60 and 61:
; Regular expression for Scheme num
Page 62 and 63:
References [1] A. V. Aho, R. Sethi,
Page 64 and 65:
(let ((n (cond ((char? var0) ) ((sy
Page 66 and 67:
3. Survey An incomplete survey of a
Page 68 and 69:
case monster 10 literals 100 litera
Page 70 and 71:
Page 72 and 73:
modest programming requirements, an
Page 74 and 75:
development of incomplete subsystem
Page 76 and 77:
the previous request. This method a
Page 78 and 79:
could be run indefinitely. This fun
Page 80 and 81:
programmers reject Scheme without r
Page 82 and 83:
(define interp (λ (env e) (case e
Page 84 and 85: Before describing the run-time sema
Page 86 and 87: Figure 5. Cast Insertion Figure 6.
Page 88 and 89: Figure 7. Evaluation Figure 8. Eval
Page 90 and 91: catching type errors, as we do here
Page 92 and 93: [34] J. C. Reynolds. Types, abstrac
Page 94 and 95: let id (T:*) (x:T) : T = x; The tra
Page 96 and 97: Figure 3: Regular Expressions and N
Page 98 and 99: Figure 5: Evaluation Rules Evaluati
Page 100 and 101: 5. Exact Substitution: E, (x = v :
Page 102 and 103: Figure 9: Subtyping Algorithm Algor
Page 104 and 105: for most type variables, and that m
Page 106 and 107: 2. miniKanren Overview This section
Page 108 and 109: 3. Pseudo-Variadic Relations Just a
Page 110 and 111: Replacing run 10 with run ∗ cause
Page 112 and 113: As might be expected, we could use
Page 114 and 115: Of course there are still infinitel
Page 116 and 117: To ensure that streams produced by
Page 118 and 119: 118 Scheme and Functional Programmi
Page 120 and 121: On the other hand, we can use a hig
Page 122 and 123: (ev* (Q (lambda (x) (+ x 1)))) # >
Page 124 and 125: (term ’lam (lambda (x) (if (equal
Page 126 and 127: a message: there is no guarantee th
Page 128 and 129: (! (self) 3) (?) =⇒ 1 (?? odd?) =
Page 130 and 131: (define new-server (spawn (lambda (
Page 132 and 133: The abstraction shown in this secti
Page 138 and 139: page of j contains the URL of the p
Page 140 and 141: 4. Solution The failed attempts abo
Page 142 and 143: · ; · ; · :: Store × Frame Stac
Page 144 and 145: logically creates a sub-session of
Page 146 and 147: on this work, including Ryan Culpep
Page 148 and 149: ing application operation. 1 As a r
Page 150 and 151: such as image glyphs corresponding
Page 152 and 153: Phone For clarity, this code pr
Page 154 and 155: A. Porting TinyScheme to Qualcomm B
Page 158 and 159: ware installers have to install any
Page 160 and 161: defines a module named circle-lib i
Page 162 and 163: Figure 2. Sometimes special cases a
Page 164 and 165: Considering all of these issues tog
show all

2006 Scheme and Functional Programming Papers, University of

Create successful ePaper yourself

Delete template?

Save as template?