1. Emerald - et OO-språk for distribuerte applikasjoner Review – Concurrency - Mobility Eric Jul OMS Professor II

2. Emerald Review We’ll start with a review of Emerald from the first two lecture series (F1, F2): Everything is an object Algol-60/Simula/Smalltalk heritage Object constructors Conformity based type system – think interfaces

3. Main Contributions Distribution: Mobile objects (Eric/Hank) Any object can move at any time. Full on-the-fly object mobility thread mobility heterogeneous mobility Conformity based type system (Norm/Andrew) Type system based on conformity principle Well-defined semantics (e.g., NIL makes sense!) Clean OO language (better than succesors?) including uniform object model

4. Class done by Syntatic Sugaring The following turns into the previous double object constructor: class seqno var prev: Integer = 0 Integer operation getSeqNo[] prev <- prev +1 return prev end getSeqno end seqno

5. Types Types are abstract descriptions of the operations required of an object (think: Java Interfaces – they are close to identical to types in Emerald). Collection of operation signatures. Signature is name & types of each parameter

6. Conformity informally (substitution) A type A conforms to another type B when any object that conforms to A can be used anywhere something of type B is required. Substitution principle. Means A is as larger or larger than B.

7. What is conformity? type BankAccount operation deposit[Integer] operation withdraw[Integer] ->[Integer] function fetchBalance[] -> [Integer] end BankAccount type DepositOnlyBankAccount function fetchBalance[] -> [Integer] operation deposit[Integer] end DepositOnlyBankAccount Conformity object-to- type and type-to-type BankAccount conforms to DepositOnlyBankAcc ount because it support all the require operations – and the parameters also conform

8. Conformity details Conformity is implicit. It is a mathematical relation No ”implements” as in Java Operation names important Parameter names do not matter, just their types matters. (Parameter name for documentation only.) Arity matters: foo(char) different from foo(char, float)

9. Conformity more formally NOT IMPORTANT HERE

10. Lattice of types Types form a lattice Top is type Any end Any Bottom is Noone (it has ALL operations”) NIL conforms to Noone NIL can thus be assigned to any variable! (Read ”Much Ado About NIL.)

11. Array Just an object Supports “ of ” which returns an object Array.of[Integer] This is a type (!) But it is also an object – that supports create (!) Creates an EMPTY array. Addupper, addlower

12. Process Concept A process is a thread of execution. Every object can have ONE process. (Or none, but can also be modelled as a process that is “empty”.) Process section in object constructor

13. Synchronization Required Classic Monitors as described by Tony Hoare Example: hi – ho program (synch.m)

14. Distribution Sea of objects (draw) Sea is divided into disjunct parts called Nodes An object is on one and only one Node at a time Each node is represented by a Node object Locate X returns the node where X is (was!)

15. Immutable Objects Immutable objects cannot change state Examples: The integer 17 User-defined immutable objects: for example complex numbers Immutable objects are omnipresent Types must be immutable to allow static type checking

16. Types are Immutable Objects Example: arrays var ai: Array.of[Integer] ai <- Array.of[Integer].create[] var aai: Array.of[Array.of[Integer]]

17. Why Mobility? Local calls are typically 1,000 – 10,000 times faster than remote calls Mobility for: –performance –availability

18. Mobility and Location Concepts locate X returns (one of) the object X’s locations move X to Y move the object X to the node where Y is (or rather was) fix X at Y as move but disregard subsequent moves refix X at Y as fix but for fixed objects unfix X allow normal moves

19. Call-by-move var B: some data object … X.F[move B] … X.F[visit B] … object X operation F[arg:T] loop arg.g[…] exit after many loops end loop end X

20. How Many Calls of B? Questions: given a normal PC enviroment, say 2 GHz CPU, 10 Mbit/s Ethernet, how many calls of a small (say 100 bytes) argument B before breakeven? 1 10 100 1,000 10,000 100,000

21. Killroy object Killroy process var myNode <- locate self var up: array.of[Nodes] up <- myNode.getNodes[] foreach n in up move self to n end foreach end process end Killroy Object moves itself to all available nodes On the original MicroVAX implementation: 20 moves/second Note: the thread (called a process in Emerald) moves along

22. Attachment Tree example TreeNode left, right Mail message To From Subject Body

23. Grundliggende Distribution Remote References: Local &Global Objects RPC – remote procedure call Implementation of RPC Location concept Simple mobility Asynchronous operations in Emerald Immutability and its uses