VMS/VMS_Implementations/VMS_impls/VMS__MC_shared

comparison VMS.c @ 31:e69579a0e797

Works multi-core.. pinned VP to a core loop

author	Me
date	Wed, 01 Sep 2010 08:23:39 -0700
parents	c8823e0bb2b4
children	17d20e5cf924

comparison

equal deleted inserted replaced

-:e65c232fa04b
+:9b4e00ead10c
 //===========================================================================
 void
 shutdownFn( void *dummy, VirtProcr *dummy2 );
-void
+SchedSlot **
-create_sched_slots( MasterEnv *masterEnv );
+create_sched_slots();
 void
 create_masterEnv();
 void
 *The semantic layer is isolated from the VMS internals by making the
 * semantic layer do setup to a state that it's ready with its
 * initial virt procrs, ready to schedule them to slots when the masterLoop
 * asks.  Without this pattern, the semantic layer's setup would
 * have to modify slots directly to assign the initial virt-procrs, and put
-* them into the workQ itself, breaking the isolation completely.
+* them into the readyToAnimateQ itself, breaking the isolation completely.
 *
 *
 *The semantic layer creates the initial virt procr(s), and adds its
 * own environment to masterEnv, and fills in the pointers to
 * the requestHandler and slaveScheduler plug-in functions
 create_masterEnv();
 }
 void
 create_masterEnv()
-{ MasterEnv  *masterEnv;
+{ MasterEnv       *masterEnv;
-VMSQueueStruc *workQ;
+SRSWQueueStruc **readyToAnimateQs;
+int              coreIdx;
-//Make the central work-queue
+VirtProcr      **masterVPs;
-_VMSWorkQ = makeVMSQ();
+SchedSlot     ***allSchedSlots; //ptr to array of ptrs
-workQ     = _VMSWorkQ;
+//Make the master env, which holds everything else
 _VMSMasterEnv = malloc( sizeof(MasterEnv) );
 masterEnv     = _VMSMasterEnv;
+//Need to set start pt here 'cause used by seed procr, which is created
-//create the master virtual processor
+// before the first core loop starts up. -- not sure how yet..
-masterEnv->masterVirtPr = VMS__create_procr( &masterLoop, masterEnv );
+//   masterEnv->coreLoopStartPt = ;
+//   masterEnv->coreLoopEndPt   = ;
-create_sched_slots( masterEnv );
+//Make a readyToAnimateQ for each core loop
-masterEnv->stillRunning = FALSE;
+readyToAnimateQs = malloc( NUM_CORES * sizeof(SRSWQueueStruc *) );
-masterEnv->numToPrecede = NUM_CORES;
+masterVPs        = malloc( NUM_CORES * sizeof(VirtProcr *) );
-//First core loop to start up gets this, which will schedule seed Pr
+//One array for each core, 3 in array, core's masterVP scheds all
-//TODO: debug: check address of masterVirtPr
+allSchedSlots    = malloc( NUM_CORES * sizeof(SchedSlot *) );
-writeVMSQ( masterEnv->masterVirtPr, workQ );
+for( coreIdx = 0; coreIdx < NUM_CORES; coreIdx++ )
-numProcrsCreated = 1;  //global counter for debugging
+{
+readyToAnimateQs[ coreIdx ] = makeSRSWQ();
+//Q: should give masterVP core-specific into as its init data?
+masterVPs[ coreIdx ] = VMS__create_procr( &masterLoop, masterEnv );
+masterVPs[ coreIdx ]->coreAnimatedBy = coreIdx;
+allSchedSlots[ coreIdx ] = create_sched_slots(); //makes for one core
+}
+_VMSMasterEnv->readyToAnimateQs = readyToAnimateQs;
+_VMSMasterEnv->masterVPs        = masterVPs;
+_VMSMasterEnv->allSchedSlots    = allSchedSlots;
+//Aug 19, 2010:  no longer need to place initial masterVP into queue
+// because coreLoop now controls -- animates its masterVP when no work
 //==================== malloc substitute ========================
 //
 //Testing whether malloc is using thread-local storage and therefore
 // causing unreliable behavior.
 }
 free( _VMSMasterEnv->freeList );
 }
 */
-void
+SchedSlot **
-create_sched_slots( MasterEnv *masterEnv )
+create_sched_slots()
-{ SchedSlot  **schedSlots, **filledSlots;
+{ SchedSlot  **schedSlots;
 int i;
 schedSlots  = malloc( NUM_SCHED_SLOTS * sizeof(SchedSlot *) );
-filledSlots = malloc( NUM_SCHED_SLOTS * sizeof(SchedSlot *) );
-masterEnv->schedSlots  = schedSlots;
-masterEnv->filledSlots = filledSlots;
 for( i = 0; i < NUM_SCHED_SLOTS; i++ )
 {
 schedSlots[i] = malloc( sizeof(SchedSlot) );
 //Set state to mean "handling requests done, slot needs filling"
 schedSlots[i]->workIsDone         = FALSE;
 schedSlots[i]->needsProcrAssigned = TRUE;
 }
+return schedSlots;
+}
+void
+freeSchedSlots( SchedSlot **schedSlots )
+{ int i;
+for( i = 0; i < NUM_SCHED_SLOTS; i++ )
+{
+free( schedSlots[i] );
+}
+free( schedSlots );
 }
 void
 create_the_coreLoop_OS_threads()
 newPr              = malloc( sizeof(VirtProcr) );
 newPr->procrID     = numProcrsCreated++;
 newPr->nextInstrPt = fnPtr;
 newPr->initialData = initialData;
+newPr->requests    = NULL;
+//   newPr->coreLoopStartPt = _VMSMasterEnv->coreLoopStartPt;
 //fnPtr takes two params -- void *initData & void *animProcr
 //alloc stack locations, make stackPtr be the highest addr minus room
 // for 2 params + return addr.  Return addr (NULL) is in loc pointed to
 // by stackPtr, initData at stackPtr + 4 bytes, animatingPr just above
 //   coreIdx = callingPr->coreAnimatedBy;
 stackPtrAddr      = &(callingPr->stackPtr);
 framePtrAddr      = &(callingPr->framePtr);
-jmpPt             = callingPr->coreLoopStartPt;
+jmpPt             = _VMSMasterEnv->coreLoopStartPt;
 coreLoopFramePtr  = callingPr->coreLoopFramePtr;//need this only
 coreLoopStackPtr  = callingPr->coreLoopStackPtr;//shouldn't need -- safety
 //Eclipse's compilation sequence complains -- so break into two
 // separate in-line assembly pieces
 return;
 }
-/*This is equivalent to "jump back to core loop" -- it's mainly only used
-* just after adding dissipate request to a processor -- so the semantic
-* layer is the only place it will be seen and/or used.
-*
-*It does almost the same thing as suspend, except don't need to save the
-* stack nor set the nextInstrPt
-*
-*As of June 30, 2010  just implementing as a call to suspend -- just sugar
-*/
-void
-VMS__return_from_fn( VirtProcr *animatingPr )
-{
-VMS__suspend_procr( animatingPr );
-}
 /*Not sure yet the form going to put "dissipate" in, so this is the third
 * possibility -- the semantic layer can just make a macro that looks like
 * a call to its name, then expands to a call to this.
 *
 //TODO: add a semantic-layer supplied "freer" for the semantic-data portion
 // of a request -- IE call with both a virt procr and a fn-ptr to request
 // freer (also maybe put sem request freer as a field in virt procr?)
-//VMSHW relies right now on this only freeing VMS layer of request -- the
+//SSR relies right now on this only freeing VMS layer of request -- the
 // semantic portion of request is alloc'd and freed by request handler
 void
 VMS__free_request( VMSReqst *req )
 {
 free( req );
 VMS__take_top_request_from( VirtProcr *procrWithReq )
 { VMSReqst *req;
 req = procrWithReq->requests;
 if( req == NULL ) return req;
 procrWithReq->requests = procrWithReq->requests->nextReqst;
 return req;
+}
+VMSReqst *
+VMS__free_top_and_give_next_request_from( VirtProcr *procrWithReq )
+{ VMSReqst *req;
+req = procrWithReq->requests;
+if( req == NULL ) return req;
+procrWithReq->requests = procrWithReq->requests->nextReqst;
+VMS__free_request( req );
+return procrWithReq->requests;
 }
 inline int
 VMS__isSemanticReqst( VMSReqst *req )
 {
 * locations it needs, and give ownership to masterVP.  Then, they will be
 * automatically freed when the masterVP is dissipated.  (This happens after
 * the core loop threads have all exited)
 *
 *In here,create one core-loop shut-down processor for each core loop and put
-* them all directly into the workQ.
+* them all directly into the readyToAnimateQ.
 *Note, this function can ONLY be called after the semantic environment no
 * longer cares if AppVPs get animated after the point this is called.  In
 * other words, this can be used as an abort, or else it should only be
 * called when all AppVPs have finished dissipate requests -- only at that
 * point is it sure that all results have completed.
 */
 void
 VMS__handle_shutdown_reqst( void *dummy, VirtProcr *animatingPr )
 { int coreIdx;
 VirtProcr *shutDownPr;
-VMSQueueStruc *workQ = _VMSWorkQ;
 //create the shutdown processors, one for each core loop -- put them
-// directly into _VMSWorkQ -- each core will die when gets one, so
+// directly into the Q -- each core will die when gets one
-// the system distributes them evenly itself.
 for( coreIdx=0; coreIdx < NUM_CORES; coreIdx++ )
 {
 shutDownPr = VMS__create_procr( &endOSThreadFn, NULL );
-writeVMSQ( shutDownPr, workQ );
+writeSRSWQ( shutDownPr, _VMSMasterEnv->readyToAnimateQs[coreIdx] );
 }
 }
 /* clobber */ : "memory", "%eax", "%ebx", "%ecx", "%edx", "%edi","%esi"  \
 );
 }
+/*This is called after the threads have shut down and control has returned
-/*This is called after the threads have shut down and control as returned
 * to the semantic layer, in the entry point function in the main thread.
 * It has to free anything allocated during VMS_init, and any other alloc'd
 * locations that might be left over.
 */
 void
 VMS__cleanup_after_shutdown()
-{ int i;
+{
+SRSWQueueStruc **readyToAnimateQs;
-free( _VMSWorkQ );
+int              coreIdx;
-free( _VMSMasterEnv->filledSlots );
+VirtProcr      **masterVPs;
-for( i = 0; i < NUM_SCHED_SLOTS; i++ )
+SchedSlot     ***allSchedSlots; //ptr to array of ptrs
+readyToAnimateQs = _VMSMasterEnv->readyToAnimateQs;
+masterVPs        = _VMSMasterEnv->masterVPs;
+allSchedSlots    = _VMSMasterEnv->allSchedSlots;
+for( coreIdx = 0; coreIdx < NUM_CORES; coreIdx++ )
 {
-free( _VMSMasterEnv->schedSlots[i] );
+freeSRSWQ( readyToAnimateQs[ coreIdx ] );
-}
+VMS__handle_dissipate_reqst( masterVPs[ coreIdx ] );
-free( _VMSMasterEnv->schedSlots);
-VMS__handle_dissipate_reqst( _VMSMasterEnv->masterVirtPr );
+freeSchedSlots( allSchedSlots[ coreIdx ] );
+}
+free( _VMSMasterEnv->readyToAnimateQs );
+free( _VMSMasterEnv->masterVPs );
+free( _VMSMasterEnv->allSchedSlots );
 free( _VMSMasterEnv );
 }
 //===========================================================================

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

comparison VMS.c @ 31:e69579a0e797