Dynamic measurement and adaptation of a copying garbage collector

1. A computer-implemented process for dynamic measurement and adaptation of a parallel copying garbage collector, the computer-implemented process comprising:

initializing values and data structures;

receiving an evacuate set;

determining whether a new copy block is required;

responsive to a determination that a new copy block is required, calculating a size of the new copy block;

selecting a survivor region from a list of survivor regions to form a selected survivor region;

placing a lock on the selected survivor region;

identifying a number of threads enqueued on the selected survivor region;

determining whether a contention value exceeds a predetermined value;

responsive to a determination that a contention value exceeds a predetermined value, increasing a size of the list of survivor regions;

evacuating blocks to the selected survivor region;

determining whether more evacuate blocks exist; and

responsive to a determination that more evacuate blocks do not exist, terminating.

2. The computer-implemented process of claim 1 wherein initializing values and data structures further comprises:

initializing values including a target fragmentation, number of bytes copied, minimum size of copy block, maximum size of copy block, initial size of copy block, survivor set, list of survivor regions, maximum contention value; and

initializing a shared resource pool.

3. The computer-implemented process of claim 1 wherein initializing values and data structures further comprises:

determining whether a process is at a start of a new generation;

responsive to a determination that a process is at a start of a new generation, receiving historical data for copy block sizing;

calculating a size of a new copy block using the historical data for copy block sizing to form a calculated size of copy block; and

initializing values and data structures using the calculated size of copy block.

4. The computer-implemented process of claim 1 wherein selecting a survivor region from a list of survivor regions further comprises:

using a thread identifier.

5. The computer-implemented process of claim 1 wherein determining whether a contention value exceeds a predetermined value further comprises:

calculating the predetermined value using a number of threads as a function of log 2 numThreads.

6. The computer-implemented process of claim 1 wherein initializing values and data structures further comprises:

calculating a minimum copy-block size for each generation at a beginning of a collection using data from previous collections using an expression (bytesToEvacuate×historicSurvivalRate×fragmentationTarget)/threadCount.

7. The computer-implemented process of claim 3 wherein calculating a size of a new copy block using the historical data for copy block sizing to form a calculated size of copy block further comprises:

a number of bytes copied multiplied by twice a fragmentation goal.

8. A computer program product for dynamic measurement and adaptation of a parallel copying garbage collector, the computer program product comprising:

a computer recordable-type media containing computer executable program code stored thereon, the computer executable program code comprising:

computer executable program code for initializing values and data structures;

computer executable program code for receiving an evacuate set;

computer executable program code for determining whether a new copy block is required;

computer executable program code responsive to a determination that a new copy block is required, for calculating a size of the new copy block;

computer executable program code for selecting a survivor region from a list of survivor regions to form a selected survivor region;

computer executable program code for placing a lock on the selected survivor region;

computer executable program code for identifying a number of threads enqueued on the selected survivor region;

computer executable program code for determining whether a contention value exceeds a predetermined value;

computer executable program code responsive to a determination that a contention value exceeds a predetermined value, for increasing a size of the list of survivor regions;

computer executable program code for evacuating blocks to the selected survivor region;

computer executable program code for determining whether more evacuate blocks exist; and

computer executable program code responsive to a determination that more evacuate blocks do not exist, for terminating.

9. The computer program product of claim 8 wherein computer executable program code for initializing values and data structures further comprises:

computer executable program code for initializing values including a target fragmentation, number of bytes copied, minimum size of copy block, maximum size of copy block, initial size of copy block, survivor set, list of survivor regions, maximum contention value; and

computer executable program code for initializing a shared resource pool.

10. The computer program product of claim 8 wherein computer executable program code for initializing values and data structures further comprises:

computer executable program code for determining whether a process is at a start of a new generation;

computer executable program code responsive to a determination that a process is at a start of a new generation, for receiving historical data for copy block sizing;

computer executable program code for calculating a size of a new copy block using the historical data for copy block sizing to form a calculated size of copy block; and

computer executable program code for initializing values and data structures using the calculated size of copy block.

11. The computer program product of claim 8 wherein computer executable program code for selecting a survivor region from a list of survivor regions further comprises:

computer executable program code for using a thread identifier.

12. The computer program product of claim 8 wherein computer executable program code for determining whether a contention value exceeds a predetermined value further comprises:

computer executable program code for calculating the predetermined value using a number of threads as a function of log 2 numThreads.

13. The computer program product of claim 8 wherein computer executable program code for initializing values and data structures further comprises:

computer executable program code for calculating a minimum copy-block size for each generation at a beginning of a collection using data from previous collections using an expression of (bytesToEvacuate×historicSurvivalRate×fragmentationTarget)/threadCount.

14. The computer program product of claim 10 wherein computer executable program code for calculating a size of a new copy block using the historical data for copy block sizing to form a calculated size of copy block further comprises:

computer executable program code for calculating a size of a new copy block using a number of bytes copied multiplied by twice a fragmentation goal.

15. An apparatus for dynamic measurement and adaptation of a parallel copying garbage collector, the apparatus comprising:

a communications fabric;

a memory connected to the communications fabric, wherein the memory contains computer executable program code;

a communications unit connected to the communications fabric;

an input/output unit connected to the communications fabric;

a display connected to the communications fabric; and

a processor unit connected to the communications fabric, wherein the processor unit executes the computer executable program code to direct the apparatus to:

initialize values and data structures;

receive an evacuate set;

determine whether a new copy block is required;

responsive to a determination that a new copy block is required, calculate a size of the new copy block;

select a survivor region to form a selected survivor region;

place a lock on the selected survivor region;

identify a number of threads enqueued on the selected survivor region;

determine whether a contention value exceeds a predetermined value;

responsive to a determination that a contention value exceeds a predetermined value, increase a size of the list of survivor regions;

evacuate blocks to the selected survivor region;

determine whether more evacuate blocks exist; and

responsive to a determination that more evacuate blocks do not exist, terminate.

16. The apparatus of claim 15 wherein the processor unit executes the computer executable program code to initialize values and data structures further directs the apparatus to:

initialize values including a target fragmentation, number of bytes copied, minimum size of copy block, maximum size of copy block, initial size of copy block, survivor set, list of survivor regions, maximum contention value; and

initialize a shared resource pool.

17. The apparatus of claim 15 wherein the processor unit executes the computer executable program code to initialize values and data structures further directs the apparatus to:

determine whether a process is at a start of a new generation;

responsive to a determination that a process is at a start of a new generation, receive historical data for copy block sizing;

calculate a size of a new copy block using the historical data for copy block sizing to form a calculated size of copy block; and

initialize values and data structures using the calculated size of copy block.

18. The apparatus of claim 15 wherein the processor unit executes the computer executable program code to select a survivor region from a list of survivor regions further directs the apparatus to:

use a thread identifier.

19. The apparatus of claim 15 wherein the processor unit executes the computer executable program code to determine whether a contention value exceeds a predetermined value further directs the apparatus to:

calculate the predetermined value using a number of threads as a function of log 2 numThreads.

20. The apparatus of claim 15 wherein the processor unit executes the computer executable program code to initialize values and data structures further directs the apparatus to:

calculate a minimum copy-block size for each generation at a beginning of a collection using data from previous collections using an expression of (bytesToEvacuate×historicSurvivalRate×fragmentationTarget)/threadCount.