Conservative garbage collection and access protection

Abstract

A method of memory management can include creating an initial root set of pointers for a program during execution of the program and performing a marking process by iteratively marking referred objects of each pointer of the root set and expanding the root set with filtered, encoded pointers. The method also can include identifying each non-live object for any marked object as red-marked and performing, using a processor, a re-marking process on the root set in which red-marked objects are excluded. Each object of the root set not marked can be designated as including a memory leak.

1 - 20 . (canceled) 
     
     
         21 . A computer-implemented method, comprising:
 creating, during execution of a program, an initial root set of pointers for the program;   iteratively marking referred objects of each pointer of the root set and expanding the root set;   identifying, with a particular marking, each non-live object for any marked object;   performing a re-marking on the root set in which objects with the particular marking are excluded; and   designating, as a memory leak, each object of the root set not marked during the re-marking.   
     
     
         22 . The method of  claim 21 , wherein
 the marking is performed until no changes are made to the root set.   
     
     
         23 . The method of  claim 21 , wherein
 the identifying identifies objects marked during the marking,   the identifying subtracts objects on an allocated objects list from the objects that are marked,   
     
     
         24 . The method of  claim 21 , wherein
 the root set is expanded with filtered, encoded pointers, and   each pointer generated by the program are live and inbound to a referent object.   
     
     
         25 . The method of  claim 21 , wherein
 the re-marking includes filtering pointer and object pairs according to
 a version number included within each pointer and 
 a version number included within each object. 
   
     
     
         26 . The method of  claim 25 , wherein
 version numbers determined to be out of use are recycled.   
     
     
         27 . The method of  claim 21 , further comprising:
 partitioning objects identified on a list of candidate objects into contiguous object sets, and each candidate object is not specified by a pointer;   replacing each set of contiguous objects sets with a starting position and an ending position; and   reclaiming each set of contiguous objects as a memory gap that is available as specified by the starting position and the ending position.   
     
     
         28 . A computer hardware system, comprising:
 a hardware processor configured to initiate the following operations:
 creating, during execution of a program, an initial root set of pointers for the program; 
 iteratively marking referred objects of each pointer of the root set and expanding the root set; 
 identifying, with a particular marking, each non-live object for any marked object; 
 performing a re-marking on the root set in which objects with the particular marking are excluded; and 
 designating, as a memory leak, each object of the root set not marked during the re-marking. 
   
     
     
         29 . The system of  claim 28 , wherein
 the marking is performed until no changes are made to the root set.   
     
     
         30 . The system of  claim 28 , wherein
 the identifying identifies objects marked during the marking,   the identifying subtracts objects on an allocated objects list from the objects that are marked,   
     
     
         31 . The system of  claim 28 , wherein
 the root set is expanded with filtered, encoded pointers, and   each pointer generated by the program are live and inbound to a referent object.   
     
     
         32 . The system of  claim 28 , wherein
 the re-marking includes filtering pointer and object pairs according to
 a version number included within each pointer and 
 a version number included within each object. 
   
     
     
         33 . The system of  claim 32 , wherein
 version numbers determined to be out of use are recycled.   
     
     
         34 . The system of  claim 28 , wherein the hardware processor is further configured to initiate the following operations:
 partitioning objects identified on a list of candidate objects into contiguous object sets, and each candidate object is not specified by a pointer;   replacing each set of contiguous objects sets with a starting position and an ending position; and   reclaiming each set of contiguous objects as a memory gap that is available as specified by the starting position and the ending position.   
     
     
         35 . A computer program product, comprising:
 a computer readable hardware storage device having computer readable program code stored therein,   the computer readable program code, which when executed by a computer hardware system, cause the computer hardware system to perform:
 creating, during execution of a program, an initial root set of pointers for the program; 
 iteratively marking referred objects of each pointer of the root set and expanding the root set; 
 identifying, with a particular marking, each non-live object for any marked object; 
 performing a re-marking on the root set in which objects with the particular marking are excluded; and 
 designating, as a memory leak, each object of the root set not marked during the re-marking. 
   
     
     
         36 . The computer program product of  claim 35 , wherein
 the marking is performed until no changes are made to the root set.   
     
     
         37 . The computer program product of  claim 35 , wherein
 the identifying identifies objects marked during the marking,   the identifying subtracts objects on an allocated objects list from the objects that are marked,   
     
     
         38 . The computer program product of  claim 35 , wherein
 the root set is expanded with filtered, encoded pointers, and   each pointer generated by the program are live and inbound to a referent object.   
     
     
         39 . The computer program product of  claim 35 , wherein
 the re-marking includes filtering pointer and object pairs according to
 a version number included within each pointer and 
 a version number included within each object. 
   
     
     
         40 . The computer program product of  claim 35 , wherein the computer readable program code further causes the computer hardware system to perform:
 partitioning objects identified on a list of candidate objects into contiguous object sets, and each candidate object is not specified by a pointer;   replacing each set of contiguous objects sets with a starting position and an ending position; and   reclaiming each set of contiguous objects as a memory gap that is available as specified by the starting position and the ending position.