VMS/VMS_Implementations/VMS_impls/VMS__MC_shared

comparison VMS.c @ 29:0e008278fe3c

Works Sequentially -- took out all threads and debugged -- works

author	Me
date	Wed, 28 Jul 2010 13:12:10 -0700
parents	8b9e4c333fe6
children	c8823e0bb2b4

comparison

equal deleted inserted replaced

-:5b6503e02149
+:d21d939b862a
 void
 VMS__remove_and_free_top_request( VirtProcr *procrWithReq )
 { VMSReqst *req;
 req = procrWithReq->requests;
+if( req == NULL ) return;
 procrWithReq->requests = procrWithReq->requests->nextReqst;
-free( req );
+VMS__free_request( req );
 }
 //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
 reqstingPr->requests = req;
 VMS__suspend_procr( reqstingPr );
 }
-/*The semantic layer figures out when the work is done ( perhaps by a call
-* in the application to "work all done", or perhaps all the virtual
-* processors have dissipated.. a.s.o. )
-*
-*The semantic layer is responsible for making sure all work has fully
-* completed before using this to shutdown the VMS system.
-*
-*After the semantic layer has determined it wants to shut down, the
-* next time the Master Loop calls the scheduler plug-in, the scheduler
-* then calls this function and returns the virtual processor it gets back.
-*
-*When the shut-down processor runs, it first frees all locations malloc'd to
-* the VMS system (that wasn't
-* specified as return-locations).  Then it creates one core-loop shut-down
-* processor for each core loop and puts them all into the workQ.  When a
-* core loop animates a core loop shut-down processor, it causes exit-thread
-* to run, and when all core loop threads have exited, then the "wait for
-* work to finish" in the main thread is woken, and the function-call that
-* started all the work returns.
-*
-*The function animated by this processor performs the shut-down work.
-*/
-VirtProcr *
-VMS__create_the_shutdown_procr()
-{
-return VMS__create_procr( &shutdownFn, NULL );
-}
 /*This must be called by the request handler plugin -- it cannot be called
 * from the semantic library "dissipate processor" function -- instead, the
 * semantic layer has to generate a request for the plug-in to call this
 *If the dissipated processor is the sole (remaining) owner of VMS__malloc'd
 * state, then that state gets freed (or sent to recycling) as a side-effect
 * of dis-owning it.
 */
 void
-VMS__free_procr_locs( VirtProcr *animatingPr )
+VMS__handle_dissipate_reqst( VirtProcr *animatingPr )
 {
 //dis-own all locations owned by this processor, causing to be freed
 // any locations that it is (was) sole owner of
 //TODO: implement VMS__malloc system, including "give up ownership"
 //The dissipate request might still be attached, so remove and free it
 VMS__remove_and_free_top_request( animatingPr );
-free( animatingPr->startOfStack );
 //NOTE: initialData was given to the processor, so should either have
 // been alloc'd with VMS__malloc, or freed by the level above animPr.
 //So, all that's left to free here is the stack and the VirtProcr struc
 // itself
 free( animatingPr->startOfStack );
 free( animatingPr );
 }
+//TODO: re-architect so that have clean separation between request handler
-/*This is the function run by the special "shut-down" processor
+// and master loop, for dissipate, create, shutdown, and other non-semantic
+// requests.  Issue is chain: one removes requests from AppVP, one dispatches
+// on type of request, and one handles each type..  but some types require
+// action from both request handler and master loop -- maybe just give the
+// request handler calls like:  VMS__handle_X_request_type
+void
+endOSThreadFn( void *initData, VirtProcr *animatingPr );
+/*This is called by the semantic layer's request handler when it decides its
+* time to shut down the VMS system.  Calling this causes the core loop OS
+* threads to exit, which unblocks the entry-point function that started up
+* VMS, and allows it to grab the result and return to the original single-
+* threaded application.
 *
-*The _VMSMasterEnv is needed by this shut down function, so the "wait"
+*The _VMSMasterEnv is needed by this shut down function, so the create-seed-
-* function run in the main loop has to free it, and the thread-related
+* and-wait function has to free a bunch of stuff after it detects the
-* locations (coreLoopThdParams a.s.o.).
+* threads have all died: the masterEnv, the thread-related locations,
-*However, the semantic environment and all data malloc'd to VMS can be
+* masterVP any AppVPs that might still be allocated and sitting in the
-* freed here.
+* semantic environment, or have been orphaned in the _VMSWorkQ.
 *
-*NOTE: the semantic plug-in is expected to use VMS__malloc to get all the
+*NOTE: the semantic plug-in is expected to use VMS__malloc_to to get all the
-* locations it needs -- they will be automatically freed by the standard
+* locations it needs, and give ownership to masterVP.  Then, they will be
-* "free all owned locations"
+* automatically freed when the masterVP is dissipated.  (This happens after
-*
+* the core loop threads have all exited)
-*Free any locations malloc'd to the VMS system (that weren't
+*
-* specified as return-locations).
+*In here,create one core-loop shut-down processor for each core loop and put
-*Then create one core-loop shut-down processor for each core loop and puts
+* them all directly into the workQ.
-* them all into the workQ.
+*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
-void
+* other words, this can be used as an abort, or else it should only be
-shutdownFn( void *dummy, VirtProcr *animatingPr )
+* 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;
-//free all the locations owned within the VMS system
+//create the shutdown processors, one for each core loop -- put them
-//TODO: write VMS__malloc and free.. -- take the DKU malloc as starting pt
+// directly into _VMSWorkQ -- each core will die when gets one, so
+// the system distributes them evenly itself.
-//make the core loop shut-down processors and put them into the workQ
 for( coreIdx=0; coreIdx < NUM_CORES; coreIdx++ )
 {
-shutDownPr = VMS__create_procr( NULL, NULL );
+shutDownPr = VMS__create_procr( &endOSThreadFn, NULL );
-shutDownPr->nextInstrPt = _VMSMasterEnv->coreLoopShutDownPt;
 writeVMSQ( shutDownPr, workQ );
 }
-//This is an issue: the animating processor of this function may not
+}
-// get its request handled before all the cores have shutdown.
-//TODO: after all the threads stop, clean out the MasterEnv, the
-// SemanticEnv, and the workQ before returning.
+/*Am trying to be cute, avoiding IF statement in coreLoop that checks for
-VMS__dissipate_procr( animatingPr );  //will never come back from this
+* a special shutdown procr.  Ended up with extra-complex shutdown sequence.
-}
+*This function has the sole purpose of setting the stack and framePtr
+* to the coreLoop's stack and framePtr.. it does that then jumps to the
+* core loop's shutdown point -- might be able to just call Pthread_exit
-/*This has to free anything allocated during VMS_init, and any other alloc'd
+* from here, but going back to the pthread's stack and setting everything
+* up just as if it never jumped out, before calling pthread_exit.
+*The end-point of core loop will free the stack and so forth of the
+* processor that animates this function, (this fn is transfering the
+* animator of the AppVP that is in turn animating this function over
+* to core loop function -- note that this slices out a level of virtual
+* processors).
+*/
+void
+endOSThreadFn( void *initData, VirtProcr *animatingPr )
+{ void *jmpPt, *coreLoopStackPtr, *coreLoopFramePtr;
+jmpPt             = _VMSMasterEnv->coreLoopEndPt;
+coreLoopStackPtr  = animatingPr->coreLoopStackPtr;
+coreLoopFramePtr  = animatingPr->coreLoopFramePtr;
+asm volatile("movl %0, %%eax;      \
+movl %1, %%esp;      \
+movl %2, %%ebp;      \
+jmp  %%eax    "      \
+/* outputs */ :                    \
+/* inputs  */ : "m" (jmpPt), "m"(coreLoopStackPtr), "m"(coreLoopFramePtr)\
+/* clobber */ : "memory", "%eax", "%ebx", "%ecx", "%edx", "%edi","%esi"  \
+);
+}
+/*This is called has to free anything allocated during VMS_init, and any other alloc'd
 * locations that might be left over.
 */
 void
-VMS__shutdown()
+VMS__cleanup_after_shutdown()
 { int i;
 free( _VMSWorkQ );
 free( _VMSMasterEnv->filledSlots );
 for( i = 0; i < NUM_SCHED_SLOTS; i++ )
 {
 free( _VMSMasterEnv->schedSlots[i] );
 }
 free( _VMSMasterEnv->schedSlots);
-VMS__free_procr_locs( _VMSMasterEnv->masterVirtPr );
+VMS__handle_dissipate_reqst( _VMSMasterEnv->masterVirtPr );
 free( _VMSMasterEnv );
 }

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

comparison VMS.c @ 29:0e008278fe3c