void ParCompactionManager::initialize(ParMarkBitMap* mbm) {
assert(PSParallelCompact::gc_task_manager() != NULL,
"Needed for initialization");
_mark_bitmap = mbm;
uint parallel_gc_threads = PSParallelCompact::gc_task_manager()->workers();
assert(_manager_array == NULL, "Attempt to initialize twice");
_manager_array = NEW_C_HEAP_ARRAY(ParCompactionManager*, parallel_gc_threads+1, mtGC);
guarantee(_manager_array != NULL, "Could not allocate manager_array");
_region_list = NEW_C_HEAP_ARRAY(RegionTaskQueue*,
parallel_gc_threads+1, mtGC);
guarantee(_region_list != NULL, "Could not initialize promotion manager");
_recycled_stack_index = NEW_C_HEAP_ARRAY(uint, parallel_gc_threads, mtGC);
// parallel_gc-threads + 1 to be consistent with the number of
// compaction managers.
for(uint i=0; i<parallel_gc_threads + 1; i++) {
_region_list[i] = new RegionTaskQueue();
region_list(i)->initialize();
}
_stack_array = new OopTaskQueueSet(parallel_gc_threads);
guarantee(_stack_array != NULL, "Could not allocate stack_array");
_objarray_queues = new ObjArrayTaskQueueSet(parallel_gc_threads);
guarantee(_objarray_queues != NULL, "Could not allocate objarray_queues");
_region_array = new RegionTaskQueueSet(parallel_gc_threads);
guarantee(_region_array != NULL, "Could not allocate region_array");
// Create and register the ParCompactionManager(s) for the worker threads.
for(uint i=0; i<parallel_gc_threads; i++) {
_manager_array[i] = new ParCompactionManager();
guarantee(_manager_array[i] != NULL, "Could not create ParCompactionManager");
stack_array()->register_queue(i, _manager_array[i]->marking_stack());
_objarray_queues->register_queue(i, &_manager_array[i]->_objarray_stack);
region_array()->register_queue(i, region_list(i));
}
// The VMThread gets its own ParCompactionManager, which is not available
// for work stealing.
_manager_array[parallel_gc_threads] = new ParCompactionManager();
guarantee(_manager_array[parallel_gc_threads] != NULL,
"Could not create ParCompactionManager");
assert(PSParallelCompact::gc_task_manager()->workers() != 0,
"Not initialized?");
}
static bool steal(int queue_num, int* seed, Task& t) {
return stack_array()->steal(queue_num, seed, t);
}
inline bool ParCompactionManager::steal(int queue_num, int* seed, oop& t) {
return stack_array()->steal(queue_num, seed, t);
}
int main(void) {
stack_array();
heap_array();
return 0;
}
/**
* @param classRecord Record for method class.
* @param methodRecord Calle's method record.
* @param retAddr What the PC should be upon return.
* @return true iff the stack frame was pushed.
*/
boolean dispatch_special (MethodRecord *methodRecord, byte *retAddr)
{
#if DEBUG_METHODS
int debug_ctr;
#endif
StackFrame *stackFrame;
byte newStackFrameIndex;
#if DEBUG_BYTECODE
printf ("\n------ dispatch special - %d ------------------\n\n",
methodRecord->signatureId);
#endif
#if DEBUG_METHODS
printf ("dispatch_special: %d, %d\n",
(int) methodRecord, (int) retAddr);
printf ("-- signature id = %d\n", methodRecord->signatureId);
printf ("-- code offset = %d\n", methodRecord->codeOffset);
printf ("-- flags = %d\n", methodRecord->mflags);
printf ("-- num params = %d\n", methodRecord->numParameters);
printf ("-- stack ptr = %d\n", (int) get_stack_ptr());
printf ("-- max stack ptr= %d\n", (int) (currentThread->stackArray + (get_array_size(currentThread->stackArray))*2));
#endif
pop_words (methodRecord->numParameters);
pc = retAddr;
if (is_native (methodRecord))
{
#if DEBUG_METHODS
printf ("-- native\n");
#endif
dispatch_native (methodRecord->signatureId, get_stack_ptr() + 1);
// Stack frame not pushed
return false;
}
newStackFrameIndex = currentThread->stackFrameArraySize;
if (newStackFrameIndex >= get_array_length((Object *) word2ptr (currentThread->stackFrameArray)))
{
#if !FIXED_STACK_SIZE
// int len = get_array_length((Object *) word2ptr (currentThread->stackFrameArray));
int newlen = get_array_length((Object *) word2ptr (currentThread->stackFrameArray)) * 3 / 2;
JINT newStackFrameArray = JNULL;
// Stack frames are indexed by a byte value so limit the size.
if (newlen <= 255)
{
// increase the stack frame size
newStackFrameArray = ptr2word(reallocate_array(word2ptr(currentThread->stackFrameArray), newlen));
}
// If can't allocate new stack, give in!
if (newStackFrameArray == JNULL)
{
#endif
throw_exception (stackOverflowError);
return false;
#if !FIXED_STACK_SIZE
}
// Assign new array
currentThread->stackFrameArray = newStackFrameArray;
#endif
}
if (newStackFrameIndex == 0)
{
// Assign NEW stack frame
stackFrame = stackframe_array();
}
else
{
#if DEBUG_METHODS
for (debug_ctr = 0; debug_ctr < methodRecord->numParameters; debug_ctr++)
printf ("-- param[%d] = %ld\n", debug_ctr, (long) get_stack_ptr()[debug_ctr+1]);
#endif
// Save OLD stackFrame state
stackFrame = stackframe_array() + (newStackFrameIndex - 1);
update_stack_frame (stackFrame);
// Push NEW stack frame
stackFrame++;
}
// Increment size of stack frame array
currentThread->stackFrameArraySize++;
// Initialize rest of new stack frame
stackFrame->methodRecord = methodRecord;
stackFrame->monitor = null;
stackFrame->localsBase = get_stack_ptr() + 1;
// Initialize auxiliary global variables (registers)
pc = get_code_ptr(methodRecord);
#if DEBUG_METHODS
printf ("pc set to 0x%X\n", (int) pc);
#endif
init_sp (stackFrame, methodRecord);
update_constant_registers (stackFrame);
//printf ("m %d stack = %d\n", (int) methodRecord->signatureId, (int) (localsBase - stack_array()));
// Check for stack overflow
// (stackTop + methodRecord->maxOperands) >= (stack_array() + STACK_SIZE);
if (is_stack_overflow (methodRecord))
{
#if !FIXED_STACK_SIZE
StackFrame *stackBase;
int i;
// Need at least this many bytes
// int len = (int)(stackTop + methodRecord->maxOperands) - (int)(stack_array()) - HEADER_SIZE;
// Need to compute new array size (as distinct from number of bytes in array).
int newlen = (((int)(stackTop + methodRecord->maxOperands) - (int)(stack_array()) - HEADER_SIZE + 1) / 4) * 3 / 2;
JINT newStackArray = ptr2word(reallocate_array(word2ptr(currentThread->stackArray), newlen));
// If can't allocate new stack, give in!
if (newStackArray == JNULL)
{
#endif
throw_exception (stackOverflowError);
return false;
#if !FIXED_STACK_SIZE
}
// Adjust pointers.
newlen = newStackArray - currentThread->stackArray;
stackBase = stackframe_array();
stackTop = word2ptr(ptr2word(stackTop) + newlen);
localsBase = word2ptr(ptr2word(localsBase) + newlen);
#if DEBUG_MEMORY
printf("thread=%d, stackTop(%d), localsBase(%d)=%d\n", currentThread->threadId, (int)stackTop, (int)localsBase, (int)(*localsBase));
#endif
for (i=currentThread->stackFrameArraySize-1;
i >= 0;
i--)
{
stackBase[i].localsBase = word2ptr(ptr2word(stackBase[i].localsBase) + newlen);
stackBase[i].stackTop = word2ptr(ptr2word(stackBase[i].stackTop) + newlen);
#if DEBUG_MEMORY
printf("stackBase[%d].localsBase(%d) = %d\n", i, (int)stackBase[i].localsBase, (int)(*stackBase[i].localsBase));
#endif
}
// Assign new array
currentThread->stackArray = newStackArray;
#endif
}
return true;
}
