VMS/VMS_Implementations/VMS_impls/VMS__MC_shared_impl: AnimationMaster.c comparison

comparison AnimationMaster.c @ 232:421bde2a07d7

REMOVED work-stealing, and all references to gates

author	Some Random Person <seanhalle@yahoo.com>
date	Thu, 15 Mar 2012 20:47:54 -0700
parents	88fd85921d7f
children	a0ac58d8201c

comparison

equal deleted inserted replaced

-:606fc80bca3b
+:816ba50f18a8
 numSlotsFilled               += 1;
 }
 }
 }
-#ifdef SYS__TURN_ON_WORK_STEALING
-/*If no slots filled, means no more work, look for work to steal. */
-if( numSlotsFilled == 0 )
-{ gateProtected_stealWorkInto( currSlot, readyToAnimateQ, masterVP );
-}
-#endif
 MEAS__Capture_Post_Master_Point;
 masterSwitchToCoreCtlr( masterVP );
 flushRegisters();
-}//MasterLoop
+}//while(1)
 }
-//===========================  Work Stealing  ==============================
-/*This is first of two work-stealing approaches.  It's not used, but left
-* in the code as a simple illustration of the principle.  This version
-* has a race condition -- the core controllers are accessing their own
-* animation slots at the same time that this work-stealer on a different
-* core is..
-*Because the core controllers run outside the master lock, this interaction
-* is not protected.
-*/
-void inline
-stealWorkInto( SchedSlot *currSlot, VMSQueueStruc *readyToAnimateQ,
-SlaveVP *masterVP )
-{
-SlaveVP   *stolenSlv;
-int32        coreIdx, i;
-VMSQueueStruc *currQ;
-stolenSlv = NULL;
-coreIdx = masterVP->coreAnimatedBy;
-for( i = 0; i < NUM_CORES -1; i++ )
-{
-if( coreIdx >= NUM_CORES -1 )
-{ coreIdx = 0;
-}
-else
-{ coreIdx++;
-}
-//TODO: fix this for coreCtlr scans slots
-//      currQ = _VMSMasterEnv->readyToAnimateQs[coreIdx];
-if( numInVMSQ( currQ ) > 0 )
-{ stolenSlv = readVMSQ (currQ );
-break;
-}
-}
-if( stolenSlv != NULL )
-{ currSlot->slaveAssignedToSlot = stolenSlv;
-stolenSlv->schedSlot           = currSlot;
-currSlot->needsSlaveAssigned  = FALSE;
-writeVMSQ( stolenSlv, readyToAnimateQ );
-}
-}
-/*This algorithm makes the common case fast.  Make the coreloop passive,
-* and show its progress.  Make the stealer control a gate that coreloop
-* has to pass.
-*To avoid interference, only one stealer at a time.  Use a global
-* stealer-lock, so only the stealer is slowed.
-*
-*The pattern is based on a gate -- stealer shuts the gate, then monitors
-* to be sure any already past make it all the way out, before starting.
-*So, have a "progress" measure just before the gate, then have two after it,
-* one is in a "waiting room" outside the gate, the other is at the exit.
-*Then, the stealer first shuts the gate, then checks the progress measure
-* outside it, then looks to see if the progress measure at the exit is the
-* same.  If yes, it knows the protected area is empty 'cause no other way
-* to get in and the last to get in also exited.
-*If the progress measure at the exit is not the same, then the stealer goes
-* into a loop checking both the waiting-area and the exit progress-measures
-* until one of them shows the same as the measure outside the gate.  Might
-* as well re-read the measure outside the gate each go around, just to be
-* sure.  It is guaranteed that one of the two will eventually match the one
-* outside the gate.
-*
-*Here's an informal proof of correctness:
-*The gate can be closed at any point, and have only four cases:
-*  1) coreloop made it past the gate-closing but not yet past the exit
-*  2) coreloop made it past the pre-gate progress update but not yet past
-*     the gate,
-*  3) coreloop is right before the pre-gate update
-*  4) coreloop is past the exit and far from the pre-gate update.
-*
-* Covering the cases in reverse order,
-*  4) is not a problem -- stealer will read pre-gate progress, see that it
-*     matches exit progress, and the gate is closed, so stealer can proceed.
-*  3) stealer will read pre-gate progress just after coreloop updates it..
-*     so stealer goes into a loop until the coreloop causes wait-progress
-*     to match pre-gate progress, so then stealer can proceed
-*  2) same as 3..
-*  1) stealer reads pre-gate progress, sees that it's different than exit,
-*     so goes into loop until exit matches pre-gate, now it knows coreloop
-*     is not in protected and cannot get back in, so can proceed.
-*
-*Implementation for the stealer:
-*
-*First, acquire the stealer lock -- only cores with no work to do will
-* compete to steal, so not a big performance penalty having only one --
-* will rarely have multiple stealers in a system with plenty of work -- and
-* in a system with little work, it doesn't matter.
-*
-*Note, have single-reader, single-writer pattern for all variables used to
-* communicate between stealer and victims
-*
-*So, scan the queues of the core controllers, until find non-empty.  Each core
-* has its own list that it scans.  The list goes in order from closest to
-* furthest core, so it steals first from close cores.  Later can add
-* taking info from the app about overlapping footprints, and scan all the
-* others then choose work with the most footprint overlap with the contents
-* of this core's cache.
-*
-*Now, have a victim want to take work from.  So, shut the gate in that
-* coreloop, by setting the "gate closed" var on its stack to TRUE.
-*Then, read the core's pre-gate progress and compare to the core's exit
-* progress.
-*If same, can proceed to take work from the coreloop's queue.  When done,
-* write FALSE to gate closed var.
-*If different, then enter a loop that reads the pre-gate progress, then
-* compares to exit progress then to wait progress.  When one of two
-* matches, proceed.  Take work from the coreloop's queue.  When done,
-* write FALSE to the gate closed var.
-*
-*/
-void inline
-gateProtected_stealWorkInto( SchedSlot *currSlot,
-VMSQueueStruc *myReadyToAnimateQ,
-SlaveVP *masterVP )
-{
-SlaveVP     *stolenSlv;
-int32          coreIdx, i, haveAVictim, gotLock;
-VMSQueueStruc *victimsQ;
-volatile GateStruc *vicGate;
-int32               coreMightBeInProtected;
-//see if any other cores have work available to steal
-haveAVictim = FALSE;
-coreIdx = masterVP->coreAnimatedBy;
-for( i = 0; i < NUM_CORES -1; i++ )
-{
-if( coreIdx >= NUM_CORES -1 )
-{ coreIdx = 0;
-}
-else
-{ coreIdx++;
-}
-//TODO: fix this for coreCtlr scans slots
-//      victimsQ = _VMSMasterEnv->readyToAnimateQs[coreIdx];
-if( numInVMSQ( victimsQ ) > 0 )
-{ haveAVictim = TRUE;
-vicGate = _VMSMasterEnv->workStealingGates[ coreIdx ];
-break;
-}
-}
-if( !haveAVictim ) return;  //no work to steal, exit
-//have a victim core, now get the stealer-lock
-gotLock =__sync_bool_compare_and_swap( &(_VMSMasterEnv->workStealingLock),
-UNLOCKED, LOCKED );
-if( !gotLock ) return; //go back to core controller, which will re-start master
-//====== Start Gate-protection =======
-vicGate->gateClosed = TRUE;
-coreMightBeInProtected= vicGate->preGateProgress != vicGate->exitProgress;
-while( coreMightBeInProtected )
-{    //wait until sure
-if( vicGate->preGateProgress == vicGate->waitProgress )
-coreMightBeInProtected = FALSE;
-if( vicGate->preGateProgress == vicGate->exitProgress )
-coreMightBeInProtected = FALSE;
-}
-stolenSlv = readVMSQ ( victimsQ );
-vicGate->gateClosed = FALSE;
-//======= End Gate-protection  =======
-if( stolenSlv != NULL )  //victim could have been in protected and taken
-{ currSlot->slaveAssignedToSlot = stolenSlv;
-stolenSlv->schedSlot           = currSlot;
-currSlot->needsSlaveAssigned  = FALSE;
-writeVMSQ( stolenSlv, myReadyToAnimateQ );
-}
-//unlock the work stealing lock
-_VMSMasterEnv->workStealingLock = UNLOCKED;
-}

Mercurial > cgi-bin > hgwebdir.cgi > VMS > VMS_Implementations > VMS_impls > VMS__MC_shared_impl

comparison AnimationMaster.c @ 232:421bde2a07d7