Wand: Concurrent Boxing System For All Pointers With Or Without Garbage Collection

• US 20170031815A1
• Filed: 10/30/2015
• Published: 02/02/2017
• Est. Priority Date: 07/29/2015
• Status: Abandoned Application

• Current Assignee: Pradeep Varma
• Original Assignee: Pradeep Varma
• Inventors: Varma, Pradeep
• Application Number:
  US14/928,790
• Publication Number:
  US 20170031815A1
• Time in Patent Office: Days
• US Class Current: 1/1
• CPC Class Codes: G06F 12/023 Free address space management
• CPC Class Codes: G06F 12/0253 Garbage collection, i.e. reclamation of unreferenced memory
• CPC Class Codes: G06F 12/0261 using reference counting
• CPC Class Codes: G06F 12/0269 Incremental or concurrent garbage collection, e.g. in real-time systems G06F12/0261 takes precedence
• CPC Class Codes: G06F 12/0891 using clearing, invalidating or resetting means
• CPC Class Codes: G06F 12/12 Replacement control
• CPC Class Codes: G06F 2212/1024 Latency reduction
• CPC Class Codes: G06F 2212/1044 Space efficiency improvement
• CPC Class Codes: G06F 2212/1048 Scalability
• CPC Class Codes: G06F 2212/60 Details of cache memory

Abstract

Boxed pointers are disclosed, for all pointers, for safe and sequential or parallel use. Since a pointer box can be arbitrarily large, it supports any fat pointer encoding possible. The boxed pointers are managed out of the same heap or stack space as ordinary objects, providing scalability by a shared use of the entire program memory. The boxed pointers and objects are managed together by the same parallel, safe, memory management system including an optional precise, parallel garbage collector. To manage boxes independently of the garbage collector, explicit allocation and de-allocation means are provided including explicit killing of boxes using immediate or deferred frees. The entire system is constructed out of atomic registers as the sole shared memory primitive, avoiding all synchronization primitives and related expenses. Atomic pointer operations including pointer creation or deletion (malloc or free) are provided.

Claims

1. A boxing system for any pointer in a program such that a pointer box accessed by one or more threads or processes can be recycled with no intervening garbage collection.

2. The box of claim 1 such that a new or unique box is used for each non-NULL pointer stored in a variable or location.

3. The unique box of claim 2 such that it is obtained by a sequence of box-reusing, content overwrites of a new box used for the variable or location.

4. The system of claim 1, comprising an object layout or type means for identifying a pointer containing variable or location.

5. The system of claim 1, comprising a means for identifying stack and register allocated pointers by re-using an allocated box collection.

6. The system of claim 5, comprising a precise garbage collector, using the identified stack and register pointers as a part of a root set.

7. The precise garbage collector of claim 6, reclaiming unfreed dead boxes, arising from racing pointer overwrites.

8. The system of claim 1, comprising a box freeing means of explicitly killing a box for freeing using an immediate free or a deferred free.

9. The system of claim 8, comprising a means for reconciling concurrent kills of a box into one kill or free of the box.

10. The system of claim 1, comprising a means of allocating or de-allocating boxes in bulk for sequential or concurrent use.

11. The system of claim 1, comprising a means for creating or destroying a box branchlessly, the means comprising allocation, initialization, or de-allocation, or the use of multiword reads and writes.

12. The system of claim 1, comprising a source-to-source transformation means for complete implementation, with enhanced portability and integrated performance as a result.

13. The system of claim 1, consisting of atomic registers or sequential registers as the sole shared memory or sequential memory primitive, ruling out any synchronization primitives.

14. A parallel, safe, memory management system comprising a heap partitioned among threads, boxed pointers, and deferred frees for providing safe manual memory management integrated with an optional precise garbage collector.

15. The system of claim 14, consisting of atomic registers or sequential registers as the sole shared memory or sequential memory primitive, ruling out any synchronization primitives.

16. The system of claim 14, that collects in parallel, with each thread collecting its own heap partition, clearing marking work sent to the thread on bounded buffers instantly using a deferred tag, thereby keeping all buffers readily available to work producers so that garbage collection progresses monotonically without deadlock, the handling of all such work transpiring in constant space by the reuse of object meta-data structures effectively.

17. The system of claim 16, wherein completion consensus for works like marking transpires by baton passing among threads.

18. The system of claim 14, supporting atomic pointer operations comprising pointer creation or pointer deletion including any needed malloc or free.

19. The system of claim 14, comprising pointer boxes that are unshared, or shared with reference counting, or shared with an implicit infinite count.

20. The system of claim 14, comprising a barrier prior to which accesses to all objects must complete, the barrier purpose comprising deferred freeing of objects or boxes, carrying out of garbage collection, modifying object layouts, creation of threads, or deletion of threads, the barrier itself being implementable using atomic registers only.

21. The system of claim 14, automatically translating a read or write operation on an object by encoding or decoding pointers transferred by the operation, according to the layout of the object.

22. The system of claim 21, using the read-only property of a layout between epochs to be able to carry out reads and writes of scalars in an object atomically, despite the layout and the object occupying and being accessed from separate storages.

23. A parallel, work completion consensus system comprising a means for passing a baton round robin among threads till a complete round is made in which no fresh work is recorded by any thread in the baton.

24. The system of claim 23, consisting of atomic registers or sequential registers as the sole shared memory or sequential memory primitive, ruling out any synchronization primitives.

25. A tagged union system comprising an object layout or type means for identifying a union containing variable or location, and a boxed means for implementing the union that substitutes the union with a pointer to a box wherein the box specifies the tag of the union and its contents, the contents thereby getting a fully unconstrained storage, despite being placed in a union that occupies the same space as the contents.

26. A parallel garbage collection system, that collects in parallel, with each thread collecting its own heap partition, clearing marking work sent to the thread on bounded buffers instantly using a deferred tag, thereby keeping all buffers readily available to work producers so that garbage collection progresses monotonically without deadlock, with completion consensus for works like marking transpiring by baton passing among threads.

27. The system of claim 26, consisting of atomic registers or sequential registers as the sole shared memory or sequential memory primitive, ruling out any synchronization primitives.

28. A parallel deferred freeing system comprising a barrier means using which all threads free cached objects in parallel and completion consensus is arrived at by baton passing.

29. The system of claim 28, freeing pointer boxes in an object while freeing the object, the non-local boxes being collected in constant space by re-using object metadata of the boxes effectively.

30. The system of claim 28, consisting of atomic registers or sequential registers as the sole shared memory or sequential memory primitive, ruling out any synchronization primitives.

31. A boxing method for any pointer in a program such that a pointer box accessed by one or more threads or processes can be recycled with no intervening garbage collection.

32. A parallel, safe, memory management method for providing safe manual memory management operations integrated with an optional precise garbage collector, comprising the steps of partitioning heap among threads, boxing pointers, and deferred freeing.

33. A parallel, work completion consensus method comprising a step for passing a baton round robin among threads till a complete round is made in which no fresh work is recorded by any thread in the baton.

34. A tagged union method comprising an object layout or type step for identifying a union containing variable or location, and a boxing step for implementing the union by substituting the union with a pointer to a box wherein the box specifies the tag of the union and its contents, the contents thereby getting a fully unconstrained storage, despite being placed in a union that occupies the same space as the contents.

35. A parallel garbage collection method, that collects in parallel, with each thread collecting its own heap partition, clearing marking work sent to the thread on bounded buffers instantly using a deferred tag, thereby keeping all buffers readily available to work producers so that garbage collection progresses monotonically without deadlock, with completion consensus for works like marking transpiring by baton passing among threads.

36. A parallel deferred freeing method comprising a barrier step using which all threads free cached objects in parallel and completion consensus is arrived at by baton passing.