Memory management

GUM needs to manage the virtual shared memory in which the graph to be reduced resides taking into account,

• Local addresses: Refer to addresses in a PE's local heap. New heap objects formed from the local free heap space in the PE. Local addresses are pointers to local heap objects. Local garbage collection affects only local addresses of a PE without affecting Local addresses of other PEs. A heap object moved from one PE to another (due to FISH message) will have its original thunk overwritten by a FetchMe object, containing the global address of the new copy of the thunk on the receiving PE, to ensure that the thunk gets evaluated only by the receiving PE.
• Global address: Points between local heaps of different PEs. In order to allow local garbage collection, the global address consists of a pair (PE address, local identifier), where each globally visible object is given an immutable local identifier. Each PE maintains a Global Indirection Table (GIT): maps local identifiers to the local address of the corresponding heap object. GIT source of roots for local garbage collection. Updated after garbage collection. A heap object is globalised by allocating an unused local identifier and augmenting the GIT to map the local identifier to the object's address. If the object already has a global address no globalising is required. In order to allow this a LA$\rightarrow$GA table is maintained for each table that matches local address to a global address. This table is referred to before a heap object is globalised. The LA$\rightarrow$GA table has to be reconstructed following a garbage collection. as the local addresses alter during garbage collection. A PE may hold copies of gloabally-visible heap objects owned by another PE. To save having to fetch again, such copies are given the same Global Addresses as the original ones, so that they can be shared. A GA$\rightarrow$LA table (that maps foreign global addresses to their local counterparts) is maintained for each PE, a new GA fetched to a local copy LA is added to the table. The three tables: GIT, GA$\rightarrow$LA and LA$\rightarrow$GA are implemented as a single data structure (Hash).
• Garbage collection: Local address garbage collection need not be synchronised with other PEs; A heap closure with an entry in GIT cannot be garbage collected, also its local identifier cannot be re-used. Weighted reference count garbage collection is used to recover the identifiers and corresponding heap closures. This requires the GIT table and the GA$\rightarrow$LA table to deliver a weight along with the local address.
• Lazy thread distribution: Threads exported from one PE to another only when the latter is idle; Sending PE retains a copy (to maintain locality).
• Eager data distribution: ``Neighbouring'' data packed along with requested data being sent (for locality).
• Asynchronous message passing between PEs: No waiting for replies to messages sent.