VMS/VMS_Implementations/VMS_impls/VMS__MC_shared

comparison VMS.c @ 38:17d20e5cf924

measures coreloop and masterVP times

author	Me
date	Tue, 07 Sep 2010 18:40:57 -0700
parents	e69579a0e797
children	1df8d7f2c9b1

comparison

equal deleted inserted replaced

-:9b4e00ead10c
+:26c99a33a71e
 /*
-* Copyright 2010  OpenSourceCodeStewardshipFoundation
+* Copyright 2010  OpenSourceStewardshipFoundation
 *
 * Licensed under BSD
 */
 #include <stdio.h>
 #include <stdlib.h>
 #include <malloc.h>
 #include "VMS.h"
 #include "Queue_impl/BlockingQueue.h"
+#include "Histogram/Histogram.h"
 #define thdAttrs NULL
 //===========================================================================
 //Just allocate a massive chunk of memory and roll own malloc/free and
 // make app use VMS__malloc_to, which will suspend and perform malloc
 // in the master, taking from this massive chunk.
 //   initFreeList();
+//============================= MEASUREMENT STUFF ========================
+#ifdef MEAS__TIME_STAMP_SUSP
+_VMSMasterEnv->measSuspHist   = makeHistogram( 25, 110, 135 );
+#endif
+#ifdef MEAS__TIME_MASTER
+_VMSMasterEnv->measMasterHist = makeHistogram( 25, 500, 800 );
+#endif
+//========================================================================
 }
 /*
 void
 initMasterMalloc()
 newPr              = malloc( sizeof(VirtProcr) );
 newPr->procrID     = numProcrsCreated++;
 newPr->nextInstrPt = fnPtr;
 newPr->initialData = initialData;
 newPr->requests    = NULL;
+newPr->schedSlot   = 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
 * slave that animated the just-ended work-unit, so all the state is saved
 * there, and will get passed along, inside the request handler, to the
 * next work-unit for that procr.
 */
 void
-VMS__suspend_procr( VirtProcr *callingPr )
+VMS__suspend_procr( VirtProcr *animatingPr )
 { void *jmpPt, *stackPtrAddr, *framePtrAddr, *coreLoopStackPtr;
 void *coreLoopFramePtr;
 //The request to master will cause this suspended virt procr to get
 // scheduled again at some future point -- to resume, core loop jumps
 // to the resume point (below), which causes restore of saved regs and
 // "return" from this call.
-callingPr->nextInstrPt = &&ResumePt;
+animatingPr->nextInstrPt = &&ResumePt;
 //return ownership of the virt procr and sched slot to Master virt pr
-callingPr->schedSlot->workIsDone = TRUE;
+animatingPr->schedSlot->workIsDone = TRUE;
 //   coreIdx = callingPr->coreAnimatedBy;
-stackPtrAddr      = &(callingPr->stackPtr);
+stackPtrAddr      = &(animatingPr->stackPtr);
-framePtrAddr      = &(callingPr->framePtr);
+framePtrAddr      = &(animatingPr->framePtr);
 jmpPt             = _VMSMasterEnv->coreLoopStartPt;
-coreLoopFramePtr  = callingPr->coreLoopFramePtr;//need this only
+coreLoopFramePtr  = animatingPr->coreLoopFramePtr;//need this only
-coreLoopStackPtr  = callingPr->coreLoopStackPtr;//shouldn't need -- safety
+coreLoopStackPtr  = animatingPr->coreLoopStackPtr;//safety
-//Eclipse's compilation sequence complains -- so break into two
-// separate in-line assembly pieces
 //Save the virt procr's stack and frame ptrs,
 asm volatile("movl %0,     %%eax;  \
 movl %%esp, (%%eax); \
 movl %1,     %%eax;  \
 movl %%ebp, (%%eax) "\
 /* outputs */ : "=g" (stackPtrAddr), "=g" (framePtrAddr) \
 /* inputs  */ :        \
 /* clobber */ : "%eax" \
 );
+#ifdef MEAS__TIME_STAMP_SUSP
+//record time stamp into animating procr: compared to time-stamp
+// recorded below, at the resume pt.
+//NOTE: doing minimal work here 'cause only a few instrs executed in
+// core loop, so only using bottom half of time-stamp -- have to
+// externally do sanity check & throw out absurd values due to rollover
+saveLowTimeStampCountInto( animatingPr->preSuspTSCLow );
+#endif
 //restore coreloop's frame ptr, then jump back to "start" of core loop
 //Note, GCC compiles to assembly that saves esp and ebp in the stack
 // frame -- so have to explicitly do assembly that saves to memory
 asm volatile("movl %0, %%eax;      \
 ); //list everything as clobbered to force GCC to save all
 // live vars that are in regs on stack before this
 // assembly, so that stack pointer is correct, before jmp
 ResumePt:
+#ifdef MEAS__TIME_STAMP_SUSP
+saveLowTimeStampCountInto( animatingPr->postSuspTSCLow );
+//Take difference between the pre-suspend and post-suspend times
+// and do sanity check to see if rollover happened between
+int  diff = animatingPr->postSuspTSCLow - animatingPr->preSuspTSCLow;
+if( diff > 1000000 ) diff = 0;
+addToHist( diff, _VMSMasterEnv->measSuspHist );
+#endif
 return;
 }
-/*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.
-*
-*As of June 30, 2010  this looks like the top choice..
-*
 *This adds a request to dissipate, then suspends the processor so that the
 * request handler will receive the request.  The request handler is what
 * does the work of freeing memory and removing the processor from the
 * semantic environment's data structures.
 *The request handler also is what figures out when to shutdown the VMS
 req->nextReqst      = callingPr->requests;
 callingPr->requests = req;
 }
+/*Use this to get first request before starting request handler's loop
-//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
+VMSReqst *
-// freer (or maybe put request freer as a field in virt procr?)
+VMS__take_top_request_from( VirtProcr *procrWithReq )
-void
-VMS__remove_and_free_top_request( VirtProcr *procrWithReq )
 { VMSReqst *req;
 req = procrWithReq->requests;
-if( req == NULL ) return;
+if( req == NULL ) return req;
+procrWithReq->requests = procrWithReq->requests->nextReqst;
+return req;
+}
+/*A subtle bug due to freeing then accessing "next" after freed caused this
+* form of call to be put in -- so call this at end of request handler loop
+* that iterates through the requests.
+*/
+VMSReqst *
+VMS__free_top_and_give_next_request_from( VirtProcr *procrWithReq )
+{ VMSReqst *req;
+req = procrWithReq->requests;
+if( req == NULL ) return NULL;
 procrWithReq->requests = procrWithReq->requests->nextReqst;
 VMS__free_request( req );
+return procrWithReq->requests;
 }
 //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?)
-//SSR relies right now on this only freeing VMS layer of request -- the
+//MeasVMS 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 );
 }
-VMSReqst *
-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 )
 {
 return ( req->reqType == semantic );
 {
 return ( req->reqType == regCreated );
 }
 void
-VMS__send_register_new_procr_request(VirtProcr *newPr, VirtProcr *reqstingPr)
+VMS__send_req_to_register_new_procr(VirtProcr *newPr, VirtProcr *reqstingPr)
 { VMSReqst *req;
 req                  = malloc( sizeof(VMSReqst) );
 req->reqType         = regCreated;
 req->semReqData      = newPr;
 //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 );
+VMS__free_top_and_give_next_request_from( animatingPr );
 //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

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

comparison VMS.c @ 38:17d20e5cf924