void CrossDelegate::run(int width, int height, int aaSamples, int depthBits)
{
initInfo.windowInfo = WindowInfo(width, height, aaSamples, depthBits);
performInit(); // TODO: HANDLE FAILURES
performSetup();
performResize(setupInfo.windowInfo.size);
sketch->performStart(CrossSketch::START_REASON_VIEW_SHOWN);
while (!glfwWindowShouldClose(window))
{
intern::instance->processMouseEvents();
intern::instance->processKeyEvents();
intern::instance->processWheelEvents();
performUpdate();
performDraw();
glfwSwapBuffers(window);
intern::instance->clearMouseEvents();
intern::instance->clearKeyEvents();
intern::instance->clearWheelEvents();
glfwPollEvents();
}
sketch->performStop(CrossSketch::STOP_REASON_VIEW_HIDDEN);
performShutdown();
performUninit();
}
//------------------------------------------------------------------------------
//!
void
CoreXGL::resize
( int w, int h )
{
DBG_BLOCK( os_xgl, "CoreXGL::resize" );
_size.x = w;
_size.y = h;
performResize( w, h );
}
void *
MM_MemorySubSpaceGenerational::allocationRequestFailed(MM_EnvironmentBase *env, MM_AllocateDescription *allocateDescription, AllocationType allocationType, MM_ObjectAllocationInterface *objectAllocationInterface, MM_MemorySubSpace *baseSubSpace, MM_MemorySubSpace *previousSubSpace)
{
/* TODO: This code is nearly the same as Flat and Concurrent - all three should be merged into a common superclass */
void *addr = NULL;
if (previousSubSpace == _memorySubSpaceNew) {
/* Handle a failure coming from new space - attempt the old area before doing any collection work */
addr = _memorySubSpaceOld->allocationRequestFailed(env, allocateDescription, allocationType, objectAllocationInterface, baseSubSpace, this);
if(NULL != addr) {
return addr;
}
}
allocateDescription->saveObjects(env);
if (!env->acquireExclusiveVMAccessForGC(_collector, true, true)) {
allocateDescription->restoreObjects(env);
addr = allocateGeneric(env, allocateDescription, allocationType, objectAllocationInterface, baseSubSpace);
if(NULL != addr) {
return addr;
}
if (!env->acquireExclusiveVMAccessForGC(_collector)) {
allocateDescription->restoreObjects(env);
addr = allocateGeneric(env, allocateDescription, allocationType, objectAllocationInterface, baseSubSpace);
if(NULL != addr) {
/* Satisfied the allocate after having grabbed exclusive access to perform a GC (without actually performing the GC). Raise
* an event for tracing / verbose to report the occurrence.
*/
reportAcquiredExclusiveToSatisfyAllocate(env, allocateDescription);
return addr;
}
reportAllocationFailureStart(env, allocateDescription);
performResize(env, allocateDescription);
addr = allocateGeneric(env, allocateDescription, allocationType, objectAllocationInterface, baseSubSpace);
if(NULL != addr) {
/* Satisfied the allocate after having grabbed exclusive access to perform a GC (without actually performing the GC). Raise
* an event for tracing / verbose to report the occurrence.
*/
reportAcquiredExclusiveToSatisfyAllocate(env, allocateDescription);
reportAllocationFailureEnd(env);
return addr;
}
allocateDescription->saveObjects(env);
} else {
reportAllocationFailureStart(env, allocateDescription);
}
} else {
reportAllocationFailureStart(env, allocateDescription);
}
Assert_MM_mustHaveExclusiveVMAccess(env->getOmrVMThread());
allocateDescription->setAllocationType(allocationType);
addr = _collector->garbageCollect(env, this, allocateDescription, J9MMCONSTANT_IMPLICIT_GC_DEFAULT, objectAllocationInterface, baseSubSpace, NULL);
allocateDescription->restoreObjects(env);
if(NULL != addr) {
reportAllocationFailureEnd(env);
return addr;
}
/* A more aggressive collect here on failure */
allocateDescription->saveObjects(env);
addr = _collector->garbageCollect(env, this, allocateDescription, J9MMCONSTANT_IMPLICIT_GC_AGGRESSIVE, objectAllocationInterface, baseSubSpace, NULL);
allocateDescription->restoreObjects(env);
reportAllocationFailureEnd(env);
return addr;
}
void*
MM_MemorySubSpaceFlat::allocationRequestFailed(MM_EnvironmentBase* env, MM_AllocateDescription* allocateDescription, AllocationType allocationType, MM_ObjectAllocationInterface* objectAllocationInterface, MM_MemorySubSpace* baseSubSpace, MM_MemorySubSpace* previousSubSpace)
{
void* addr = NULL;
/* If the request came from the parent, forward the failure handling to the child first */
if (previousSubSpace == _parent) {
addr = _memorySubSpace->allocationRequestFailed(env, allocateDescription, allocationType, objectAllocationInterface, baseSubSpace, this);
if (NULL != addr) {
return addr;
}
}
/* If there is a collector present, execute and retry the failure on the child */
if (_collector) {
allocateDescription->saveObjects(env);
/* acquire exclusive access and, after we get it, see if we need to perform a collect or if someone else beat us to it */
if (!env->acquireExclusiveVMAccessForGC(_collector, true, true)) {
allocateDescription->restoreObjects(env);
/* Beaten to exclusive access for our collector by another thread - a GC must have occurred. This thread
* does NOT have exclusive access at this point. Try and satisfy the allocate based on a GC having occurred.
*/
addr = allocateGeneric(env, allocateDescription, allocationType, objectAllocationInterface, _memorySubSpace);
if (NULL != addr) {
return addr;
}
/* Failed to satisfy allocate - now really go for a GC */
allocateDescription->saveObjects(env);
/* acquire exclusive access and, after we get it, see if we need to perform a collect or if someone else beat us to it */
if (!env->acquireExclusiveVMAccessForGC(_collector)) {
/* we have exclusive access but another thread beat us to the GC so see if they collected enough to satisfy our request */
allocateDescription->restoreObjects(env);
addr = allocateGeneric(env, allocateDescription, allocationType, objectAllocationInterface, _memorySubSpace);
if (NULL != addr) {
/* Satisfied the allocate after having grabbed exclusive access to perform a GC (without actually performing the GC). Raise
* an event for tracing / verbose to report the occurrence.
*/
reportAcquiredExclusiveToSatisfyAllocate(env, allocateDescription);
return addr;
}
/* we still failed the allocate so try a resize to get more space */
reportAllocationFailureStart(env, allocateDescription);
performResize(env, allocateDescription);
addr = allocateGeneric(env, allocateDescription, allocationType, objectAllocationInterface, baseSubSpace);
if (addr) {
/* Satisfied the allocate after having grabbed exclusive access to perform a GC (without actually performing the GC). Raise
* an event for tracing / verbose to report the occurrence.
*/
reportAcquiredExclusiveToSatisfyAllocate(env, allocateDescription);
reportAllocationFailureEnd(env);
return addr;
}
allocateDescription->saveObjects(env);
/* we still failed so we will need to run a GC */
} else {
/* we have exclusive and no other thread beat us to it so we can now collect */
reportAllocationFailureStart(env, allocateDescription);
}
} else {
/* we have exclusive and no other thread beat us to it so we can now collect */
reportAllocationFailureStart(env, allocateDescription);
}
Assert_MM_mustHaveExclusiveVMAccess(env->getOmrVMThread());
/* run the collector in the default mode (ie: not explicitly aggressive) */
allocateDescription->setAllocationType(allocationType);
addr = _collector->garbageCollect(env, this, allocateDescription, J9MMCONSTANT_IMPLICIT_GC_DEFAULT, objectAllocationInterface, baseSubSpace, NULL);
allocateDescription->restoreObjects(env);
if (addr) {
reportAllocationFailureEnd(env);
return addr;
}
allocateDescription->saveObjects(env);
/* The collect wasn't good enough to satisfy the allocate so attempt an aggressive collection */
addr = _collector->garbageCollect(env, this, allocateDescription, J9MMCONSTANT_IMPLICIT_GC_AGGRESSIVE, objectAllocationInterface, baseSubSpace, NULL);
allocateDescription->restoreObjects(env);
reportAllocationFailureEnd(env);
if (addr) {
return addr;
}
/* there was nothing we could do to satisfy the allocate at this level (we will either OOM or attempt a collect at the higher level in our parent) */
}
/* If the caller was the child, forward the failure notification to the parent for handling */
if ((NULL != _parent) && (previousSubSpace != _parent)) {
/* see if the parent can find us some space */
return _parent->allocationRequestFailed(env, allocateDescription, allocationType, objectAllocationInterface, baseSubSpace, this);
}
/* Nothing else to try - fail */
return NULL;
}
