1.1 --- a/AnimationMaster.c	Mon Sep 03 03:34:54 2012 -0700
     1.2 +++ b/AnimationMaster.c	Wed Sep 19 23:12:44 2012 -0700
     1.3 @@ -9,7 +9,7 @@
     1.4  #include <stdio.h>
     1.5  #include <stddef.h>
     1.6  
     1.7 -#include "VMS.h"
     1.8 +#include "PR.h"
     1.9  
    1.10  
    1.11  
    1.12 @@ -20,11 +20,39 @@
    1.13   * 
    1.14   *Within the code, this is the top-level-function of the masterVPs, and
    1.15   * runs when the coreController has no more slave VPs.  It's job is to
    1.16 - * refill the animation slots with slaves.
    1.17 + * refill the animation slots with slaves that have work.
    1.18   *
    1.19 - *To do this, it scans the animation slots for just-completed slaves.
    1.20 - * Each of these has a request in it.  So, the master hands each to the
    1.21 - * plugin's request handler.
    1.22 + *There are multiple versions of the master, each tuned to a specific 
    1.23 + * combination of modes.  This keeps the master simple, with reduced overhead,
    1.24 + * when the application is not using the extra complexity.
    1.25 + * 
    1.26 + *As of Sept 2012, the versions available will be:
    1.27 + * 1) Single langauge, which only exposes slaves (such as SSR or Vthread)
    1.28 + * 2) Single language, which only exposes tasks  (such as pure dataflow)
    1.29 + * 3) Single language, which exposes both (like Cilk, StarSs, and OpenMP)
    1.30 + * 4) Multi-language, which always assumes both tasks and slaves
    1.31 + * 5) Multi-language and multi-process, which also assumes both tasks and slaves
    1.32 + *
    1.33 + * 
    1.34 + *
    1.35 + */
    1.36 +
    1.37 +
    1.38 +//=====================  The versions of the Animation Master  =================
    1.39 +//
    1.40 +//==============================================================================
    1.41 +
    1.42 +/* 1) This version is for a single language, that has only slaves, no tasks,
    1.43 + *    such as Vthread or SSR.
    1.44 + *This version is for when an application has only a single language, and
    1.45 + * that language exposes slaves explicitly (as opposed to a task based 
    1.46 + * language like pure dataflow).
    1.47 + * 
    1.48 + *
    1.49 + *It scans the animation slots for just-completed slaves.
    1.50 + * Each completed slave has a request in it.  So, the master hands each to
    1.51 + * the plugin's request handler (there is only one plugin, because only one
    1.52 + * lang).
    1.53   *Each request represents a language construct that has been encountered
    1.54   * by the application code in the slave. Passing the request to the
    1.55   * request handler is how that language construct's behavior gets invoked.
    1.56 @@ -77,24 +105,24 @@
    1.57   *There is a separate masterVP for each core, but a single semantic
    1.58   * environment shared by all cores.  Each core also has its own scheduling
    1.59   * slots, which are used to communicate slaves between animationMaster and
    1.60 - * coreController.  There is only one global variable, _VMSMasterEnv, which
    1.61 + * coreController.  There is only one global variable, _PRMasterEnv, which
    1.62   * holds the semantic env and other things shared by the different
    1.63   * masterVPs.  The request handler and Assigner are registered with
    1.64   * the animationMaster by the language's init function, and a pointer to
    1.65 - * each is in the _VMSMasterEnv. (There are also some pthread related global
    1.66 - * vars, but they're only used during init of VMS).
    1.67 - *VMS gains control over the cores by essentially "turning off" the OS's
    1.68 + * each is in the _PRMasterEnv. (There are also some pthread related global
    1.69 + * vars, but they're only used during init of PR).
    1.70 + *PR gains control over the cores by essentially "turning off" the OS's
    1.71   * scheduler, using pthread pin-to-core commands.
    1.72   *
    1.73   *The masterVPs are created during init, with this animationMaster as their
    1.74   * top level function.  The masterVPs use the same SlaveVP data structure,
    1.75   * even though they're not slave VPs.
    1.76   *A "seed slave" is also created during init -- this is equivalent to the
    1.77 - * "main" function in C, and acts as the entry-point to the VMS-language-
    1.78 + * "main" function in C, and acts as the entry-point to the PR-language-
    1.79   * based application.
    1.80 - *The masterVPs shared a single system-wide master-lock, so only one
    1.81 + *The masterVPs share a single system-wide master-lock, so only one
    1.82   * masterVP may be animated at a time.
    1.83 - *The core controllers access _VMSMasterEnv to get the masterVP, and when
    1.84 + *The core controllers access _PRMasterEnv to get the masterVP, and when
    1.85   * they start, the slots are all empty, so they run their associated core's
    1.86   * masterVP.  The first of those to get the master lock sees the seed slave
    1.87   * in the shared semantic environment, so when it runs the Assigner, that
    1.88 @@ -104,14 +132,14 @@
    1.89   * constructs to create more slaves, and so on.  Each of those constructs
    1.90   * causes the seed slave to suspend, switching over to the core controller,
    1.91   * which eventually switches to the masterVP, which executes the 
    1.92 - * request handler, which uses VMS primitives to carry out the creation of
    1.93 + * request handler, which uses PR primitives to carry out the creation of
    1.94   * new slave VPs, which are marked as ready for the Assigner, and so on..
    1.95   * 
    1.96   *On animation slots, and system behavior:
    1.97 - * A request may linger in a animation slot for a long time while
    1.98 + * A request may linger in an animation slot for a long time while
    1.99   * the slaves in the other slots are animated.  This only becomes a problem
   1.100   * when such a request is a choke-point in the constraints, and is needed
   1.101 - * to free work for *other* cores.  To reduce this occurance, the number
   1.102 + * to free work for *other* cores.  To reduce this occurrence, the number
   1.103   * of animation slots should be kept low.  In balance, having multiple
   1.104   * animation slots amortizes the overhead of switching to the masterVP and
   1.105   * executing the animationMaster code, which drives for more than one. In
   1.106 @@ -163,7 +191,29 @@
   1.107         HOLISTIC__Record_AppResponder_start;
   1.108                 MEAS__startReqHdlr;
   1.109                 
   1.110 -            //process the requests made by the slave (held inside slave struc)
   1.111 +           currSlot->workIsDone         = FALSE;
   1.112 +            currSlot->needsSlaveAssigned = TRUE;
   1.113 +            SlaveVP *currSlave = currSlot->slaveAssignedToSlot;
   1.114 +            
   1.115 +	justAddedReqHdlrChg();
   1.116 +			//handle the request, either by VMS or by the language
   1.117 +            if( currSlave->requests->reqType != LangReq )
   1.118 +             {    //The request is a standard VMS one, not one defined by the
   1.119 +                  // language, so VMS handles it, then queues slave to be assigned
   1.120 +               handleReqInVMS( currSlave );
   1.121 +               writePrivQ( currSlave, VMSReadyQ ); //Q slave to be assigned below
   1.122 +             }
   1.123 +            else
   1.124 +             {       MEAS__startReqHdlr;
   1.125 +
   1.126 +                  //Language handles request, which is held inside slave struc
   1.127 +               (*requestHandler)( currSlave, semanticEnv );
   1.128 +
   1.129 +                     MEAS__endReqHdlr;
   1.130 +             }
   1.131 +          }
   1.132 +
   1.133 +		  //process the requests made by the slave (held inside slave struc)
   1.134           (*requestHandler)( currSlot->slaveAssignedToSlot, semanticEnv );
   1.135           
   1.136           HOLISTIC__Record_AppResponder_end;
   1.137 @@ -196,3 +246,756 @@
   1.138     }//while(1) 
   1.139   }
   1.140  
   1.141 +
   1.142 +/* 2)  This version is for a single language that has only tasks, which 
   1.143 + *     cannot be suspended.
   1.144 + */
   1.145 +void animationMaster( void *initData, SlaveVP *masterVP )
   1.146 + { 
   1.147 +      //Used while scanning and filling animation slots
   1.148 +   int32           slotIdx, numSlotsFilled;
   1.149 +   AnimSlot       *currSlot, **animSlots;
   1.150 +   SlaveVP        *assignedSlaveVP;  //the slave chosen by the assigner
   1.151 +   
   1.152 +      //Local copies, for performance
   1.153 +   MasterEnv      *masterEnv;
   1.154 +   SlaveAssigner   slaveAssigner;
   1.155 +   RequestHandler  requestHandler;
   1.156 +   PRSemEnv       *semanticEnv;
   1.157 +   int32           thisCoresIdx;
   1.158 +
   1.159 +   //#ifdef  MODE__MULTI_LANG
   1.160 +   SlaveVP        *slave;
   1.161 +   PRProcess      *process;
   1.162 +   PRConstrEnvHolder *constrEnvHolder;
   1.163 +   int32           langMagicNumber;
   1.164 +   //#endif
   1.165 +   
   1.166 +   //======================== Initializations ========================
   1.167 +   masterEnv        = (MasterEnv*)_PRMasterEnv;
   1.168 +   
   1.169 +   thisCoresIdx     = masterVP->coreAnimatedBy;
   1.170 +   animSlots        = masterEnv->allAnimSlots[thisCoresIdx];
   1.171 +
   1.172 +   requestHandler   = masterEnv->requestHandler;
   1.173 +   slaveAssigner    = masterEnv->slaveAssigner;
   1.174 +   semanticEnv      = masterEnv->semanticEnv;
   1.175 +   
   1.176 +      //initialize, for non-multi-lang, non multi-proc case
   1.177 +      // default handler gets put into master env by a registration call by lang
   1.178 +   endTaskHandler   = masterEnv->defaultTaskHandler;
   1.179 +   
   1.180 +      HOLISTIC__Insert_Master_Global_Vars;
   1.181 +   
   1.182 +   //======================== animationMaster ========================
   1.183 +   //Do loop gets requests handled and work assigned to slots..
   1.184 +   // work can either be a task or a resumed slave
   1.185 +   //Having two cases makes this logic complex.. can be finishing either, and 
   1.186 +   // then the next available work may be either.. so really have two distinct
   1.187 +   // loops that are inter-twined.. 
   1.188 +   while(1){
   1.189 +       
   1.190 +      MEAS__Capture_Pre_Master_Point
   1.191 +
   1.192 +      //Scan the animation slots
   1.193 +   numSlotsFilled = 0;
   1.194 +   for( slotIdx = 0; slotIdx < NUM_ANIM_SLOTS; slotIdx++)
   1.195 +    {
   1.196 +      currSlot = animSlots[ slotIdx ];
   1.197 +
   1.198 +         //Check if newly-done slave in slot, which will need request handled
   1.199 +      if( currSlot->workIsDone )
   1.200 +       { currSlot->workIsDone = FALSE;
   1.201 +       
   1.202 +               HOLISTIC__Record_AppResponder_start; //TODO: update to check which process for each slot
   1.203 +               MEAS__startReqHdlr;
   1.204 +               
   1.205 +         
   1.206 +            //process the request made by the slave (held inside slave struc)
   1.207 +         slave = currSlot->slaveAssignedToSlot;
   1.208 +         
   1.209 +            //check if the completed work was a task..
   1.210 +         if( slave->taskMetaInfo->isATask )
   1.211 +          {
   1.212 +             if( slave->reqst->type == TaskEnd ) 
   1.213 +              {    //do task end handler, which is registered separately
   1.214 +                   //note, end hdlr may use semantic data from reqst..
   1.215 +                //#ifdef  MODE__MULTI_LANG
   1.216 +                   //get end-task handler
   1.217 +                //taskEndHandler = lookup( slave->reqst->langMagicNumber, processEnv );
   1.218 +                taskEndHandler = slave->taskMetaInfo->endTaskHandler;
   1.219 +                //#endif
   1.220 +                (*taskEndHandler)( slave, semanticEnv );
   1.221 +                
   1.222 +                goto AssignWork;
   1.223 +              }
   1.224 +             else  //is a task, and just suspended
   1.225 +              {    //turn slot slave into free task slave & make replacement
   1.226 +                if( slave->typeOfVP == TaskSlotSlv ) changeSlvType();
   1.227 +                
   1.228 +                //goto normal slave request handling
   1.229 +                goto SlaveReqHandling; 
   1.230 +              }
   1.231 +          }
   1.232 +         else //is a slave that suspended
   1.233 +          {
   1.234 +          SlaveReqHandling:
   1.235 +            (*requestHandler)( slave, semanticEnv ); //(note: indirect Fn call more efficient when use fewer params, instead re-fetch from slave)
   1.236 +         
   1.237 +               HOLISTIC__Record_AppResponder_end;
   1.238 +               MEAS__endReqHdlr;
   1.239 +               
   1.240 +            goto AssignWork;
   1.241 +          }
   1.242 +       } //if has suspended slave that needs handling
   1.243 +      
   1.244 +         //if slot empty, hand to Assigner to fill with a slave
   1.245 +      if( currSlot->needsSlaveAssigned )
   1.246 +       {    //Call plugin's Assigner to give slot a new slave
   1.247 +               HOLISTIC__Record_Assigner_start;
   1.248 +               
   1.249 +       AssignWork:
   1.250 +     
   1.251 +         assignedSlaveVP = assignWork( semanticEnv, currSlot );
   1.252 +       
   1.253 +            //put the chosen slave into slot, and adjust flags and state
   1.254 +         if( assignedSlaveVP != NULL )
   1.255 +          { currSlot->slaveAssignedToSlot = assignedSlaveVP;
   1.256 +            assignedSlaveVP->animSlotAssignedTo = currSlot;
   1.257 +            currSlot->needsSlaveAssigned  = FALSE;
   1.258 +            numSlotsFilled               += 1;
   1.259 +          }
   1.260 +         else
   1.261 +          {
   1.262 +            currSlot->needsSlaveAssigned  = TRUE; //local write
   1.263 +          }
   1.264 +               HOLISTIC__Record_Assigner_end;
   1.265 +       }//if slot needs slave assigned
   1.266 +    }//for( slotIdx..
   1.267 +
   1.268 +         MEAS__Capture_Post_Master_Point;
   1.269 +   
   1.270 +   masterSwitchToCoreCtlr( masterVP ); //returns when ctlr switches back to master
   1.271 +   flushRegisters();
   1.272 +   }//while(1) 
   1.273 + }
   1.274 +
   1.275 +
   1.276 +/*This is the master when just multi-lang, but not multi-process mode is on.
   1.277 + * This version has to handle both tasks and slaves, and do extra work of 
   1.278 + * looking up the semantic env and handlers to use, for each completed bit of 
   1.279 + * work.
   1.280 + *It also has to search through the semantic envs to find one with work,
   1.281 + * then ask that env's assigner to return a unit of that work.
   1.282 + * 
   1.283 + *The language is written to startup in the same way as if it were the only
   1.284 + * language in the app, and it operates in the same way,
   1.285 + * the only difference between single language and multi-lang is here, in the
   1.286 + * master.
   1.287 + *This invisibility to mode is why the language has to use registration calls
   1.288 + * for everything during startup -- those calls do different things depending
   1.289 + * on whether it's single-language or multi-language mode.
   1.290 + * 
   1.291 + *In this version of the master, work can either be a task or a resumed slave
   1.292 + *Having two cases makes this logic complex.. can be finishing either, and
   1.293 + * then the next available work may be either.. so really have two distinct 
   1.294 + * loops that are inter-twined.. 
   1.295 + * 
   1.296 + *Some special cases:
   1.297 + * A task-end is a special case for a few reasons (below).
   1.298 + * A task-end can't block a slave (can't cause it to "logically suspend")
   1.299 + * A task available for work can only be assigned to a special slave, which 
   1.300 + *   has been set aside for doing tasks, one such task-slave is always 
   1.301 + *   assigned to each slot. So, when a task ends, a new task is assigned to
   1.302 + *   that slot's task-slave right away.  
   1.303 + * But if no tasks are available, then have to switch over to looking at
   1.304 + *   slaves to find one ready to resume, to find work for the slot.
   1.305 + * If a task just suspends, not ends, then its task-slave is no longer 
   1.306 + *   available to take new tasks, so a new task-slave has to be assigned to
   1.307 + *   that slot.  Then the slave of the suspended task is turned into a free
   1.308 + *   task-slave and request handling is done on it as if it were a slave 
   1.309 + *   that suspended.
   1.310 + * After request handling, do the same sequence of looking for a task to be
   1.311 + *   work, and if none, look for a slave ready to resume, as work for the slot.
   1.312 + * If a slave suspends, handle its request, then look for work.. first for a
   1.313 + *   task to assign, and if none, slaves ready to resume.
   1.314 + * Another special case is when task-end is done on a free task-slave.. in
   1.315 + *   that case, the slave has no more work and no way to get more.. so place
   1.316 + *   it into a recycle queue.
   1.317 + * If no work is found of either type, then do a special thing to prune down
   1.318 + *   the extra slaves in the recycle queue, just so don't get too many..
   1.319 + * 
   1.320 + *The multi-lang thing complicates matters..  
   1.321 + *
   1.322 + *For request handling, it means have to first fetch the semantic environment
   1.323 + * of the language, and then do the request handler pointed to by that
   1.324 + * semantic env.
   1.325 + *For assigning, things get more complex because of competing goals..  One
   1.326 + * goal is for language specific stuff to be used during assignment, so
   1.327 + * assigner can make higher quality decisions..  but with multiple languages,
   1.328 + * which only get mixed in the application, the assigners can't be written
   1.329 + * with knowledge of each other.  So, they can only make localized decisions,
   1.330 + * and so different language's assigners may interfere with each other..
   1.331 + * 
   1.332 + *So, have some possibilities available:
   1.333 + *1) can have a fixed scheduler in the proto-runtime, that all the
   1.334 + * languages give their work to..  (but then lose language-specific info, 
   1.335 + * there is a standard PR format for assignment info, and the langauge 
   1.336 + * attaches this to the work-unit when it gives it to PR.. also have issue
   1.337 + * with HWSim, which uses a priority Q instead of FIFO, and requests can 
   1.338 + * "undo" previous work put in, so request handlers need way to manipulate
   1.339 + * the work-holding Q..) (this might be fudgeable with
   1.340 + * HWSim, if the master did a lang-supplied callback each time it assigns a
   1.341 + * unit to a slot..  then HWSim can keep exactly one unit of work in PR's
   1.342 + * queue at a time..  but this is quite hack-like.. or perhaps HWSim supplies
   1.343 + * a task-end handler that kicks the next unit of work from HWSim internal
   1.344 + * priority queue, over to PR readyQ)
   1.345 + *2) can have each language have its own semantic env, that holds its own
   1.346 + * work, which is assigned by its own assigner.. then the master searches
   1.347 + * through all the semantic envs to find one with work and asks it give work..
   1.348 + * (this has downside of blinding assigners to each other.. but does work
   1.349 + * for HWSim case)
   1.350 + *3) could make PR have a different readyQ for each core, and ask the lang
   1.351 + * to put work to the core it prefers.. but the work may be moved by PR if
   1.352 + * needed, say if one core idles for too long. This is a hybrid approach, 
   1.353 + * letting the language decide which core, but PR keeps the work and does it
   1.354 + * FIFO style.. (this might als be fudgeable with HWSim, in similar fashion, 
   1.355 + * but it would be complicated by having to track cores separately) 
   1.356 + *
   1.357 + *Choosing 2, to keep compatibility with single-lang mode..  it allows the same
   1.358 + * assigner to be used for single-lang as for multi-lang..  the overhead of
   1.359 + * the extra master search for work is part of the price of the flexibility,
   1.360 + * but should be fairly small.. takes the first env that has work available, 
   1.361 + * and whatever it returns is assigned to the slot..
   1.362 + * 
   1.363 + *As a hybrid, giving an option for a unified override assigner to be registered
   1.364 + * and used..  This allows something like a static analysis to detect
   1.365 + * which languages are grouped together, and then analyze the pattern of 
   1.366 + * construct calls, and generate a custom assigner that uses info from all
   1.367 + * the languages in a unified way..  Don't really expect this to happen, 
   1.368 + * but making it possible.
   1.369 + */
   1.370 +#ifdef  MODE__MULTI_LANG
   1.371 +void animationMaster( void *initData, SlaveVP *masterVP )
   1.372 + { 
   1.373 +      //Used while scanning and filling animation slots
   1.374 +   int32           slotIdx, numSlotsFilled;
   1.375 +   AnimSlot       *currSlot, **animSlots;
   1.376 +   SlaveVP        *assignedSlaveVP;  //the slave chosen by the assigner
   1.377 +   
   1.378 +      //Local copies, for performance
   1.379 +   MasterEnv      *masterEnv;
   1.380 +   SlaveAssigner   slaveAssigner;
   1.381 +   RequestHandler  requestHandler;
   1.382 +   PRSemEnv       *semanticEnv;
   1.383 +   int32           thisCoresIdx;
   1.384 +
   1.385 +   //#ifdef  MODE__MULTI_LANG
   1.386 +   SlaveVP        *slave;
   1.387 +   PRProcess      *process;
   1.388 +   PRConstrEnvHolder *constrEnvHolder;
   1.389 +   int32           langMagicNumber;
   1.390 +   //#endif
   1.391 +   
   1.392 +   //======================== Initializations ========================
   1.393 +   masterEnv        = (MasterEnv*)_PRMasterEnv;
   1.394 +   
   1.395 +   thisCoresIdx     = masterVP->coreAnimatedBy;
   1.396 +   animSlots        = masterEnv->allAnimSlots[thisCoresIdx];
   1.397 +
   1.398 +   requestHandler   = masterEnv->requestHandler;
   1.399 +   slaveAssigner    = masterEnv->slaveAssigner;
   1.400 +   semanticEnv      = masterEnv->semanticEnv;
   1.401 +   
   1.402 +      //initialize, for non-multi-lang, non multi-proc case
   1.403 +      // default handler gets put into master env by a registration call by lang
   1.404 +   endTaskHandler   = masterEnv->defaultTaskHandler;
   1.405 +   
   1.406 +      HOLISTIC__Insert_Master_Global_Vars;
   1.407 +   
   1.408 +   //======================== animationMaster ========================
   1.409 +   //Do loop gets requests handled and work assigned to slots..
   1.410 +   // work can either be a task or a resumed slave
   1.411 +   //Having two cases makes this logic complex.. can be finishing either, and 
   1.412 +   // then the next available work may be either.. so really have two distinct
   1.413 +   // loops that are inter-twined.. 
   1.414 +   while(1){
   1.415 +       
   1.416 +      MEAS__Capture_Pre_Master_Point
   1.417 +
   1.418 +      //Scan the animation slots
   1.419 +   numSlotsFilled = 0;
   1.420 +   for( slotIdx = 0; slotIdx < NUM_ANIM_SLOTS; slotIdx++)
   1.421 +    {
   1.422 +      currSlot = animSlots[ slotIdx ];
   1.423 +
   1.424 +         //Check if newly-done slave in slot, which will need request handled
   1.425 +      if( currSlot->workIsDone )
   1.426 +       { currSlot->workIsDone = FALSE;
   1.427 +       
   1.428 +               HOLISTIC__Record_AppResponder_start; //TODO: update to check which process for each slot
   1.429 +               MEAS__startReqHdlr;
   1.430 +               
   1.431 +         
   1.432 +            //process the request made by the slave (held inside slave struc)
   1.433 +         slave = currSlot->slaveAssignedToSlot;
   1.434 +         
   1.435 +            //check if the completed work was a task..
   1.436 +         if( slave->taskMetaInfo->isATask )
   1.437 +          {
   1.438 +             if( slave->reqst->type == TaskEnd ) 
   1.439 +              {    //do task end handler, which is registered separately
   1.440 +                   //note, end hdlr may use semantic data from reqst..
   1.441 +                //#ifdef  MODE__MULTI_LANG
   1.442 +                   //get end-task handler
   1.443 +                //taskEndHandler = lookup( slave->reqst->langMagicNumber, processEnv );
   1.444 +                taskEndHandler = slave->taskMetaInfo->endTaskHandler;
   1.445 +                //#endif
   1.446 +                (*taskEndHandler)( slave, semanticEnv );
   1.447 +                
   1.448 +                goto AssignWork;
   1.449 +              }
   1.450 +             else  //is a task, and just suspended
   1.451 +              {    //turn slot slave into free task slave & make replacement
   1.452 +                if( slave->typeOfVP == TaskSlotSlv ) changeSlvType();
   1.453 +                
   1.454 +                //goto normal slave request handling
   1.455 +                goto SlaveReqHandling; 
   1.456 +              }
   1.457 +          }
   1.458 +         else //is a slave that suspended
   1.459 +          {
   1.460 +          SlaveReqHandling:
   1.461 +            (*requestHandler)( slave, semanticEnv ); //(note: indirect Fn call more efficient when use fewer params, instead re-fetch from slave)
   1.462 +         
   1.463 +               HOLISTIC__Record_AppResponder_end;
   1.464 +               MEAS__endReqHdlr;
   1.465 +               
   1.466 +            goto AssignWork;
   1.467 +          }
   1.468 +       } //if has suspended slave that needs handling
   1.469 +      
   1.470 +         //if slot empty, hand to Assigner to fill with a slave
   1.471 +      if( currSlot->needsSlaveAssigned )
   1.472 +       {    //Call plugin's Assigner to give slot a new slave
   1.473 +               HOLISTIC__Record_Assigner_start;
   1.474 +               
   1.475 +       AssignWork:
   1.476 +     
   1.477 +         assignedSlaveVP = assignWork( semanticEnv, currSlot );
   1.478 +       
   1.479 +            //put the chosen slave into slot, and adjust flags and state
   1.480 +         if( assignedSlaveVP != NULL )
   1.481 +          { currSlot->slaveAssignedToSlot = assignedSlaveVP;
   1.482 +            assignedSlaveVP->animSlotAssignedTo = currSlot;
   1.483 +            currSlot->needsSlaveAssigned  = FALSE;
   1.484 +            numSlotsFilled               += 1;
   1.485 +          }
   1.486 +         else
   1.487 +          {
   1.488 +            currSlot->needsSlaveAssigned  = TRUE; //local write
   1.489 +          }
   1.490 +               HOLISTIC__Record_Assigner_end;
   1.491 +       }//if slot needs slave assigned
   1.492 +    }//for( slotIdx..
   1.493 +
   1.494 +         MEAS__Capture_Post_Master_Point;
   1.495 +   
   1.496 +   masterSwitchToCoreCtlr( masterVP ); //returns when ctlr switches back to master
   1.497 +   flushRegisters();
   1.498 +   }//while(1) 
   1.499 + }
   1.500 +#endif //MODE__MULTI_LANG
   1.501 +
   1.502 +
   1.503 +
   1.504 +//This is the master when both multi-lang and multi-process modes are turned on
   1.505 +//#ifdef MODE__MULTI_LANG
   1.506 +//#ifdef MODE__MULTI_PROCESS
   1.507 +void animationMaster( void *initData, SlaveVP *masterVP )
   1.508 + { 
   1.509 +      //Used while scanning and filling animation slots
   1.510 +   int32           slotIdx, numSlotsFilled;
   1.511 +   AnimSlot       *currSlot, **animSlots;
   1.512 +   SlaveVP        *assignedSlaveVP;  //the slave chosen by the assigner
   1.513 +   
   1.514 +      //Local copies, for performance
   1.515 +   MasterEnv      *masterEnv;
   1.516 +   SlaveAssigner   slaveAssigner;
   1.517 +   RequestHandler  requestHandler;
   1.518 +   PRSemEnv       *semanticEnv;
   1.519 +   int32           thisCoresIdx;
   1.520 +
   1.521 +   SlaveVP        *slave;
   1.522 +   PRProcess      *process;
   1.523 +   PRConstrEnvHolder *constrEnvHolder;
   1.524 +   int32           langMagicNumber;
   1.525 +   
   1.526 +   //======================== Initializations ========================
   1.527 +   masterEnv        = (MasterEnv*)_PRMasterEnv;
   1.528 +   
   1.529 +   thisCoresIdx     = masterVP->coreAnimatedBy;
   1.530 +   animSlots        = masterEnv->allAnimSlots[thisCoresIdx];
   1.531 +
   1.532 +   requestHandler   = masterEnv->requestHandler;
   1.533 +   slaveAssigner    = masterEnv->slaveAssigner;
   1.534 +   semanticEnv      = masterEnv->semanticEnv;
   1.535 +   
   1.536 +      //initialize, for non-multi-lang, non multi-proc case
   1.537 +      // default handler gets put into master env by a registration call by lang
   1.538 +   endTaskHandler   = masterEnv->defaultTaskHandler;
   1.539 +   
   1.540 +      HOLISTIC__Insert_Master_Global_Vars;
   1.541 +   
   1.542 +   //======================== animationMaster ========================
   1.543 +   //Do loop gets requests handled and work assigned to slots..
   1.544 +   // work can either be a task or a resumed slave
   1.545 +   //Having two cases makes this logic complex.. can be finishing either, and 
   1.546 +   // then the next available work may be either.. so really have two distinct
   1.547 +   // loops that are inter-twined.. 
   1.548 +   while(1){
   1.549 +       
   1.550 +      MEAS__Capture_Pre_Master_Point
   1.551 +
   1.552 +      //Scan the animation slots
   1.553 +   numSlotsFilled = 0;
   1.554 +   for( slotIdx = 0; slotIdx < NUM_ANIM_SLOTS; slotIdx++)
   1.555 +    {
   1.556 +      currSlot = animSlots[ slotIdx ];
   1.557 +
   1.558 +         //Check if newly-done slave in slot, which will need request handled
   1.559 +      if( currSlot->workIsDone )
   1.560 +       { currSlot->workIsDone = FALSE;
   1.561 +       
   1.562 +               HOLISTIC__Record_AppResponder_start; //TODO: update to check which process for each slot
   1.563 +               MEAS__startReqHdlr;
   1.564 +               
   1.565 +         
   1.566 +            //process the request made by the slave (held inside slave struc)
   1.567 +         slave = currSlot->slaveAssignedToSlot;
   1.568 +         
   1.569 +            //check if the completed work was a task..
   1.570 +         if( slave->taskMetaInfo->isATask )
   1.571 +          {
   1.572 +             if( slave->reqst->type == TaskEnd ) 
   1.573 +              {    //do task end handler, which is registered separately
   1.574 +                   //note, end hdlr may use semantic data from reqst..
   1.575 +                   //get end-task handler
   1.576 +                //taskEndHandler = lookup( slave->reqst->langMagicNumber, processEnv );
   1.577 +                taskEndHandler = slave->taskMetaInfo->endTaskHandler;
   1.578 +                
   1.579 +                (*taskEndHandler)( slave, semanticEnv );
   1.580 +                
   1.581 +                goto AssignWork;
   1.582 +              }
   1.583 +             else  //is a task, and just suspended
   1.584 +              {    //turn slot slave into free task slave & make replacement
   1.585 +                if( slave->typeOfVP == TaskSlotSlv ) changeSlvType();
   1.586 +                
   1.587 +                //goto normal slave request handling
   1.588 +                goto SlaveReqHandling; 
   1.589 +              }
   1.590 +          }
   1.591 +         else //is a slave that suspended
   1.592 +          {
   1.593 +             
   1.594 +          SlaveReqHandling:
   1.595 +            (*requestHandler)( slave, semanticEnv ); //(note: indirect Fn call more efficient when use fewer params, instead re-fetch from slave)
   1.596 +         
   1.597 +               HOLISTIC__Record_AppResponder_end;
   1.598 +               MEAS__endReqHdlr;
   1.599 +               
   1.600 +            goto AssignWork;
   1.601 +          }
   1.602 +       } //if has suspended slave that needs handling
   1.603 +      
   1.604 +         //if slot empty, hand to Assigner to fill with a slave
   1.605 +      if( currSlot->needsSlaveAssigned )
   1.606 +       {    //Scan sem environs, looking for one with ready work.
   1.607 +            // call the Assigner for that sem Env, to give slot a new slave
   1.608 +               HOLISTIC__Record_Assigner_start;
   1.609 +               
   1.610 +       AssignWork:
   1.611 +     
   1.612 +         assignedSlaveVP = assignWork( semanticEnv, currSlot );
   1.613 +       
   1.614 +            //put the chosen slave into slot, and adjust flags and state
   1.615 +         if( assignedSlaveVP != NULL )
   1.616 +          { currSlot->slaveAssignedToSlot = assignedSlaveVP;
   1.617 +            assignedSlaveVP->animSlotAssignedTo = currSlot;
   1.618 +            currSlot->needsSlaveAssigned  = FALSE;
   1.619 +            numSlotsFilled               += 1;
   1.620 +          }
   1.621 +         else
   1.622 +          {
   1.623 +            currSlot->needsSlaveAssigned  = TRUE; //local write
   1.624 +          }
   1.625 +               HOLISTIC__Record_Assigner_end;
   1.626 +       }//if slot needs slave assigned
   1.627 +    }//for( slotIdx..
   1.628 +
   1.629 +         MEAS__Capture_Post_Master_Point;
   1.630 +   
   1.631 +   masterSwitchToCoreCtlr( masterVP ); //returns when ctlr switches back to master
   1.632 +   flushRegisters();
   1.633 +   }//while(1) 
   1.634 + }
   1.635 +#endif  //MODE__MULTI_LANG
   1.636 +#endif  //MODE__MULTI_PROCESS
   1.637 +
   1.638 +
   1.639 +/*This does three things:
   1.640 + * 1) ask for a slave ready to resume
   1.641 + * 2) if none, then ask for a task, and assign to the slot slave
   1.642 + * 3) if none, then prune former task slaves waiting to be recycled.
   1.643 + *
   1.644 +   //Have two separate assigners in each semantic env,
   1.645 +   // which keeps its own work in its own structures.. the master, here, 
   1.646 +   // searches through the semantic environs, takes the first that has work
   1.647 +   // available, and whatever it returns is assigned to the slot..
   1.648 +   //However, also have an override assigner.. because static analysis tools know
   1.649 +   // which languages are grouped together.. and the override enables them to
   1.650 +   // generate a custom assigner that uses info from all the languages in a 
   1.651 +   // unified way..  Don't really expect this to happen, but making it possible.
   1.652 + */
   1.653 +inline SlaveVP *
   1.654 +assignWork( PRProcessEnv *processEnv, AnimSlot *slot )
   1.655 + { SlaveVP     *returnSlv;
   1.656 +   //VSsSemEnv   *semEnv;
   1.657 +   //VSsSemData  *semData;
   1.658 +   int32        coreNum, slotNum;
   1.659 +   PRTaskMetaInfo *newTaskStub;
   1.660 +   SlaveVP     *freeTaskSlv;
   1.661 +
   1.662 +   
   1.663 +      //master has to handle slot slaves.. so either assigner returns
   1.664 +      // taskMetaInfo or else two assigners, one for slaves, other for tasks..     
   1.665 +   semEnvs = processEnv->semEnvs;
   1.666 +   numEnvs = processEnv->numSemEnvs;
   1.667 +   for( envIdx = 0; envIdx < numEnvs; envIdx++ )
   1.668 +    { semEnv = semEnvs[envIdx];
   1.669 +      if( semEnv->hasWork )
   1.670 +       { assigner = semEnv->assigner; 
   1.671 +         retTaskMetaInfo = (*assigner)( semEnv, slot );
   1.672 +         
   1.673 +         return retTaskMetaInfo; //quit, have work
   1.674 +       }
   1.675 +    }
   1.676 +   
   1.677 +   coreNum = slot->coreSlotIsOn;
   1.678 +   slotNum = slot->slotIdx;
   1.679 + 
   1.680 +      //first try to get a ready slave
   1.681 +   returnSlv = getReadySlave();
   1.682 +
   1.683 +   if( returnSlv != NULL )
   1.684 +    { returnSlv->coreAnimatedBy   = coreNum;
   1.685 +    
   1.686 +         //have work, so reset Done flag (when work generated on other core)
   1.687 +      if( processEnv->coreIsDone[coreNum] == TRUE ) //reads are higher perf
   1.688 +         processEnv->coreIsDone[coreNum] = FALSE;   //don't just write always
   1.689 +    
   1.690 +      goto ReturnTheSlv;
   1.691 +    }
   1.692 +   
   1.693 +      //were no slaves, so try to get a ready task.. 
   1.694 +   newTaskStub = getTaskStub();
   1.695 +   
   1.696 +   if( newTaskStub != NULL )
   1.697 +    { 
   1.698 +         //get the slot slave to assign the task to..
   1.699 +      returnSlv = processEnv->slotTaskSlvs[coreNum][slotNum];
   1.700 +
   1.701 +         //point slave to task's function, and mark slave as having task
   1.702 +      PR_int__reset_slaveVP_to_TopLvlFn( returnSlv, 
   1.703 +                          newTaskStub->taskType->fn, newTaskStub->args );
   1.704 +      returnSlv->taskStub          = newTaskStub;
   1.705 +      newTaskStub->slaveAssignedTo = returnSlv;
   1.706 +      returnSlv->needsTaskAssigned = FALSE;  //slot slave is a "Task" slave type
   1.707 +      
   1.708 +         //have work, so reset Done flag, if was set
   1.709 +      if( processEnv->coreIsDone[coreNum] == TRUE ) //reads are higher perf
   1.710 +         processEnv->coreIsDone[coreNum] = FALSE;   //don't just write always
   1.711 +      
   1.712 +      goto ReturnTheSlv;
   1.713 +    }
   1.714 +   else
   1.715 +    {    //no task, so prune the recycle pool of free task slaves
   1.716 +      freeTaskSlv = readPrivQ( processEnv->freeTaskSlvRecycleQ );
   1.717 +      if( freeTaskSlv != NULL )
   1.718 +       {    //delete to bound the num extras, and deliver shutdown cond
   1.719 +         handleDissipate( freeTaskSlv, processEnv );
   1.720 +            //then return NULL
   1.721 +         returnSlv = NULL;
   1.722 +         
   1.723 +         goto ReturnTheSlv;
   1.724 +       }
   1.725 +      else
   1.726 +       { //candidate for shutdown.. if all extras dissipated, and no tasks
   1.727 +         // and no ready to resume slaves, then no way to generate
   1.728 +         // more tasks (on this core -- other core might have task still)
   1.729 +         if( processEnv->numLiveExtraTaskSlvs == 0 && 
   1.730 +             processEnv->numLiveThreadSlvs == 0 )
   1.731 +          { //This core sees no way to generate more tasks, so say it
   1.732 +            if( processEnv->coreIsDone[coreNum] == FALSE )
   1.733 +             { processEnv->numCoresDone += 1;
   1.734 +               processEnv->coreIsDone[coreNum] = TRUE;
   1.735 +               #ifdef DEBUG__TURN_ON_SEQUENTIAL_MODE
   1.736 +               processEnv->shutdownInitiated = TRUE;
   1.737 +               
   1.738 +               #else
   1.739 +               if( processEnv->numCoresDone == NUM_CORES )
   1.740 +                { //means no cores have work, and none can generate more
   1.741 +                  processEnv->shutdownInitiated = TRUE;
   1.742 +                }
   1.743 +               #endif
   1.744 +             }
   1.745 +          }
   1.746 +            //check if shutdown has been initiated by this or other core
   1.747 +         if(processEnv->shutdownInitiated) 
   1.748 +          { returnSlv = PR_SS__create_shutdown_slave();
   1.749 +          }
   1.750 +         else
   1.751 +            returnSlv = NULL;
   1.752 +
   1.753 +         goto ReturnTheSlv; //don't need, but completes pattern
   1.754 +       } //if( freeTaskSlv != NULL )
   1.755 +    } //if( newTaskStub == NULL )
   1.756 +   //outcome: 1)slave was just pointed to task, 2)no tasks, so slave NULL
   1.757 + 
   1.758 +
   1.759 + ReturnTheSlv:  //All paths goto here.. to provide single point for holistic..
   1.760 +
   1.761 +   #ifdef HOLISTIC__TURN_ON_OBSERVE_UCC
   1.762 +   if( returnSlv == NULL )
   1.763 +    { returnSlv = processEnv->idleSlv[coreNum][slotNum]; 
   1.764 +    
   1.765 +         //things that would normally happen in resume(), but idle VPs
   1.766 +         // never go there
   1.767 +      returnSlv->assignCount++; //gives each idle unit a unique ID
   1.768 +      Unit newU;
   1.769 +      newU.vp = returnSlv->slaveID;
   1.770 +      newU.task = returnSlv->assignCount;
   1.771 +      addToListOfArrays(Unit,newU,processEnv->unitList);
   1.772 +
   1.773 +      if (returnSlv->assignCount > 1) //make a dependency from prev idle unit
   1.774 +       { Dependency newD;             // to this one
   1.775 +         newD.from_vp = returnSlv->slaveID;
   1.776 +         newD.from_task = returnSlv->assignCount - 1;
   1.777 +         newD.to_vp = returnSlv->slaveID;
   1.778 +         newD.to_task = returnSlv->assignCount;
   1.779 +         addToListOfArrays(Dependency, newD ,processEnv->ctlDependenciesList);  
   1.780 +       }
   1.781 +    }
   1.782 +   else //have a slave will be assigned to the slot
   1.783 +    { //assignSlv->numTimesAssigned++;
   1.784 +         //get previous occupant of the slot
   1.785 +      Unit prev_in_slot = 
   1.786 +         processEnv->last_in_slot[coreNum * NUM_ANIM_SLOTS + slotNum];
   1.787 +      if(prev_in_slot.vp != 0) //if not first slave in slot, make dependency
   1.788 +       { Dependency newD;      // is a hardware dependency
   1.789 +         newD.from_vp = prev_in_slot.vp;
   1.790 +         newD.from_task = prev_in_slot.task;
   1.791 +         newD.to_vp = returnSlv->slaveID;
   1.792 +         newD.to_task = returnSlv->assignCount;
   1.793 +         addToListOfArrays(Dependency,newD,processEnv->hwArcs);   
   1.794 +       }
   1.795 +      prev_in_slot.vp = returnSlv->slaveID; //make new slave the new previous
   1.796 +      prev_in_slot.task = returnSlv->assignCount;
   1.797 +      processEnv->last_in_slot[coreNum * NUM_ANIM_SLOTS + slotNum] =
   1.798 +         prev_in_slot;        
   1.799 +    }
   1.800 +   #endif
   1.801 +
   1.802 +   return( returnSlv );
   1.803 + }
   1.804 +
   1.805 +      
   1.806 +//=================================================================
   1.807 +         //#else  //is MODE__MULTI_LANG
   1.808 +            //For multi-lang mode, first, get the constraint-env holder out of
   1.809 +            // the process, which is in the slave.
   1.810 +            //Second, get the magic number out of the request, use it to look up
   1.811 +            // the constraint Env within the constraint-env holder.
   1.812 +            //Then get the request handler out of the constr env
   1.813 +         constrEnvHolder = slave->process->constrEnvHolder;
   1.814 +         reqst = slave->request;
   1.815 +         langMagicNumber = reqst->langMagicNumber;
   1.816 +         semanticEnv = lookup( langMagicNumber, constrEnvHolder ); //a macro
   1.817 +         if( slave->reqst->type == taskEnd ) //end-task is special
   1.818 +          {    //need to know what lang's task ended
   1.819 +            taskEndHandler = semanticEnv->taskEndHandler;
   1.820 +            (*taskEndHandler)( slave, reqst, semanticEnv ); //can put semantic data into task end reqst, for continuation, etc
   1.821 +               //this is a slot slave, get a new task for it
   1.822 +            if( !existsOverrideAssigner )//if exists, is set above, before loop
   1.823 +             {    //search for task assigner that has work
   1.824 +               for( a = 0; a < num_assigners; a++ )
   1.825 +                { if( taskAssigners[a]->hasWork )
   1.826 +                   { newTaskAssigner = taskAssigners[a];
   1.827 +                     (*newTaskAssigner)( slave, semanticEnv );
   1.828 +                     goto GotTask;
   1.829 +                   }
   1.830 +                }
   1.831 +               goto NoTasks;
   1.832 +             }
   1.833 +            
   1.834 +           GotTask:
   1.835 +            continue; //have work, so do next iter of loop, don't call slave assigner
   1.836 +          }
   1.837 +         if( slave->typeOfVP == taskSlotSlv ) changeSlvType();//is suspended task
   1.838 +            //now do normal suspended slave request handler
   1.839 +         requestHandler = semanticEnv->requestHandler;
   1.840 +         //#endif
   1.841 +
   1.842 +         
   1.843 +       }
   1.844 +         //If make it here, then was no task for this slot
   1.845 +         //slot empty, hand to Assigner to fill with a slave
   1.846 +      if( currSlot->needsSlaveAssigned )
   1.847 +       {    //Call plugin's Assigner to give slot a new slave
   1.848 +               HOLISTIC__Record_Assigner_start;
   1.849 +               
   1.850 +         //#ifdef  MODE__MULTI_LANG
   1.851 +        NoTasks:
   1.852 +            //First, choose an Assigner..
   1.853 +            //There are several Assigners, one for each langlet.. they all
   1.854 +            // indicate whether they have work available.. just pick the first
   1.855 +            // one that has work..  Or, if there's a Unified Assigner, call
   1.856 +            // that one..  So, go down array, checking..
   1.857 +         if( !existsOverrideAssigner ) 
   1.858 +          { for( a = 0; a < num_assigners; a++ )
   1.859 +             { if( assigners[a]->hasWork )
   1.860 +                { slaveAssigner = assigners[a];
   1.861 +                  goto GotAssigner;
   1.862 +                }
   1.863 +             }
   1.864 +            //no work, so just continue to next iter of scan loop
   1.865 +            continue;
   1.866 +          }
   1.867 +         //when exists override, the assigner is set, once, above, so do nothing
   1.868 +        GotAssigner:
   1.869 +         //#endif
   1.870 +        
   1.871 +         assignedSlaveVP =
   1.872 +          (*slaveAssigner)( semanticEnv, currSlot );
   1.873 +         
   1.874 +            //put the chosen slave into slot, and adjust flags and state
   1.875 +         if( assignedSlaveVP != NULL )
   1.876 +          { currSlot->slaveAssignedToSlot = assignedSlaveVP;
   1.877 +            assignedSlaveVP->animSlotAssignedTo = currSlot;
   1.878 +            currSlot->needsSlaveAssigned  = FALSE;
   1.879 +            numSlotsFilled               += 1;
   1.880 +            
   1.881 +            HOLISTIC__Record_Assigner_end;
   1.882 +          }
   1.883 +       }//if slot needs slave assigned
   1.884 +    }//for( slotIdx..
   1.885 +
   1.886 +         MEAS__Capture_Post_Master_Point;
   1.887 +   
   1.888 +   masterSwitchToCoreCtlr( masterVP );
   1.889 +   flushRegisters();
   1.890 +         DEBUG__printf(FALSE,"came back after switch to core -- so lock released!");
   1.891 +   }//while(1) 
   1.892 + }
   1.893 +

     2.1 --- a/CoreController.c	Mon Sep 03 03:34:54 2012 -0700
     2.2 +++ b/CoreController.c	Wed Sep 19 23:12:44 2012 -0700
     2.3 @@ -5,7 +5,7 @@
     2.4   */
     2.5  
     2.6  
     2.7 -#include "VMS.h"
     2.8 +#include "PR.h"
     2.9  
    2.10  #include <stdlib.h>
    2.11  #include <stdio.h>
    2.12 @@ -55,9 +55,9 @@
    2.13   * amortize the overhead of switching to the master VP and running it.  With
    2.14   * multiple animation slots, the time to switch-to-master and the code in
    2.15   * the animation master is divided by the number of animation slots.
    2.16 - *The core controller and animation slots are not fundamental parts of VMS,
    2.17 + *The core controller and animation slots are not fundamental parts of PR,
    2.18   * but rather optimizations put into the shared-semantic-state version of
    2.19 - * VMS.  Other versions of VMS will not have a core controller nor scheduling
    2.20 + * PR.  Other versions of PR will not have a core controller nor scheduling
    2.21   * slots.
    2.22   * 
    2.23   *The core controller "owns" the physical core, in effect, and is the 
    2.24 @@ -92,13 +92,13 @@
    2.25     thisCoresIdx = thisCoresThdParams->coreNum;
    2.26  
    2.27        //Assembly that saves addr of label of return instr -- label in assmbly
    2.28 -   recordCoreCtlrReturnLabelAddr((void**)&(_VMSMasterEnv->coreCtlrReturnPt));
    2.29 +   recordCoreCtlrReturnLabelAddr((void**)&(_PRMasterEnv->coreCtlrReturnPt));
    2.30  
    2.31 -   animSlots = _VMSMasterEnv->allAnimSlots[thisCoresIdx];
    2.32 +   animSlots = _PRMasterEnv->allAnimSlots[thisCoresIdx];
    2.33     currSlotIdx = 0; //start at slot 0, go up until one empty, then do master
    2.34     numRepetitionsWithNoWork = 0;
    2.35 -   addrOfMasterLock = &(_VMSMasterEnv->masterLock);
    2.36 -   thisCoresMasterVP = _VMSMasterEnv->masterVPs[thisCoresIdx];
    2.37 +   addrOfMasterLock = &(_PRMasterEnv->masterLock);
    2.38 +   thisCoresMasterVP = _PRMasterEnv->masterVPs[thisCoresIdx];
    2.39     
    2.40     //==================== pthread related stuff ======================
    2.41        //pin the pthread to the core -- takes away Linux control
    2.42 @@ -113,7 +113,7 @@
    2.43  
    2.44        //make sure the controllers all start at same time, by making them wait
    2.45     pthread_mutex_lock(  &suspendLock );
    2.46 -   while( !(_VMSMasterEnv->setupComplete) )
    2.47 +   while( !(_PRMasterEnv->setupComplete) )
    2.48      { pthread_cond_wait( &suspendCond, &suspendLock );
    2.49      }
    2.50     pthread_mutex_unlock( &suspendLock );
    2.51 @@ -209,7 +209,7 @@
    2.52      }//while(1)
    2.53   }
    2.54  
    2.55 -/*Shutdown of VMS involves several steps, of which this is the last.  This
    2.56 +/*Shutdown of PR involves several steps, of which this is the last.  This
    2.57   * function is jumped to from the asmTerminateCoreCtrl, which is in turn
    2.58   * called from endOSThreadFn, which is the top-level-fn of the shutdown
    2.59   * slaves.
    2.60 @@ -218,18 +218,18 @@
    2.61  terminateCoreCtlr(SlaveVP *currSlv)
    2.62   {
    2.63     //first, free shutdown Slv that jumped here, then end the pthread
    2.64 -   VMS_int__dissipate_slaveVP( currSlv );
    2.65 +   PR_int__dissipate_slaveVP( currSlv );
    2.66     pthread_exit( NULL );
    2.67   }
    2.68  
    2.69  inline uint32_t
    2.70  randomNumber()
    2.71   {
    2.72 -	_VMSMasterEnv->seed1 = (uint32)(36969 * (_VMSMasterEnv->seed1 & 65535) + 
    2.73 -                                   (_VMSMasterEnv->seed1 >> 16) );
    2.74 -	_VMSMasterEnv->seed2 = (uint32)(18000 * (_VMSMasterEnv->seed2 & 65535) + 
    2.75 -                                   (_VMSMasterEnv->seed2 >> 16) );
    2.76 -	return (_VMSMasterEnv->seed1 << 16) + _VMSMasterEnv->seed2;
    2.77 +	_PRMasterEnv->seed1 = (uint32)(36969 * (_PRMasterEnv->seed1 & 65535) + 
    2.78 +                                   (_PRMasterEnv->seed1 >> 16) );
    2.79 +	_PRMasterEnv->seed2 = (uint32)(18000 * (_PRMasterEnv->seed2 & 65535) + 
    2.80 +                                   (_PRMasterEnv->seed2 >> 16) );
    2.81 +	return (_PRMasterEnv->seed1 << 16) + _PRMasterEnv->seed2;
    2.82   }
    2.83  
    2.84  
    2.85 @@ -292,14 +292,14 @@
    2.86     
    2.87     //===============  Initializations ===================
    2.88     thisCoresIdx = 0; //sequential version
    2.89 -   animSlots = _VMSMasterEnv->allAnimSlots[thisCoresIdx];
    2.90 +   animSlots = _PRMasterEnv->allAnimSlots[thisCoresIdx];
    2.91     currSlotIdx = 0; //start at slot 0, go up until one empty, then do master
    2.92     numRepetitionsWithNoWork = 0;
    2.93 -   addrOfMasterLock = &(_VMSMasterEnv->masterLock);
    2.94 -   thisCoresMasterVP = _VMSMasterEnv->masterVPs[thisCoresIdx];
    2.95 +   addrOfMasterLock = &(_PRMasterEnv->masterLock);
    2.96 +   thisCoresMasterVP = _PRMasterEnv->masterVPs[thisCoresIdx];
    2.97     
    2.98        //Assembly that saves addr of label of return instr -- label in assmbly
    2.99 -   recordCoreCtlrReturnLabelAddr((void**)&(_VMSMasterEnv->coreCtlrReturnPt));
   2.100 +   recordCoreCtlrReturnLabelAddr((void**)&(_PRMasterEnv->coreCtlrReturnPt));
   2.101  
   2.102     
   2.103     //====================== The Core Controller ======================

     3.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     3.2 +++ b/Defines/MEAS__macros_to_be_moved_to_langs.h	Wed Sep 19 23:12:44 2012 -0700
     3.3 @@ -0,0 +1,57 @@
     3.4 +/*
     3.5 + *  Copyright 2009 OpenSourceStewardshipFoundation.org
     3.6 + *  Licensed under GNU General Public License version 2
     3.7 + *
     3.8 + * Author: seanhalle@yahoo.com
     3.9 + * 
    3.10 + */
    3.11 +
    3.12 +#ifndef  _PR_LANG_SPEC_DEFS_H
    3.13 +#define	_PR_LANG_SPEC_DEFS_H
    3.14 +
    3.15 +
    3.16 +
    3.17 +//===================  Language-specific Measurement Stuff ===================
    3.18 +//
    3.19 +//TODO:  move these into the language implementation directories
    3.20 +//
    3.21 +
    3.22 +
    3.23 +//===========================================================================
    3.24 +//VCilk
    3.25 +
    3.26 +#ifdef VCILK
    3.27 +
    3.28 +#define spawnHistIdx      1 //note: starts at 1
    3.29 +#define syncHistIdx       2
    3.30 +
    3.31 +#define MEAS__Make_Meas_Hists_for_Language() \
    3.32 +   _PRMasterEnv->measHistsInfo = \
    3.33 +          makePrivDynArrayOfSize( (void***)&(_PRMasterEnv->measHists), 200); \
    3.34 +    makeAMeasHist( spawnHistIdx,      "Spawn",        50, 0, 200 ) \
    3.35 +    makeAMeasHist( syncHistIdx,       "Sync",         50, 0, 200 )
    3.36 +
    3.37 +
    3.38 +#define Meas_startSpawn \
    3.39 +    int32 startStamp, endStamp; \
    3.40 +    saveLowTimeStampCountInto( startStamp ); \
    3.41 +
    3.42 +#define Meas_endSpawn \
    3.43 +    saveLowTimeStampCountInto( endStamp ); \
    3.44 +    addIntervalToHist( startStamp, endStamp, \
    3.45 +                             _PRMasterEnv->measHists[ spawnHistIdx ] );
    3.46 +
    3.47 +#define Meas_startSync \
    3.48 +    int32 startStamp, endStamp; \
    3.49 +    saveLowTimeStampCountInto( startStamp ); \
    3.50 +
    3.51 +#define Meas_endSync \
    3.52 +    saveLowTimeStampCountInto( endStamp ); \
    3.53 +    addIntervalToHist( startStamp, endStamp, \
    3.54 +                             _PRMasterEnv->measHists[ syncHistIdx ] );
    3.55 +#endif
    3.56 +
    3.57 +//===========================================================================
    3.58 +
    3.59 +#endif	/* _PR_DEFS_H */
    3.60 +

     4.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     4.2 +++ b/Defines/PR_defs.h	Wed Sep 19 23:12:44 2012 -0700
     4.3 @@ -0,0 +1,43 @@
     4.4 +/*
     4.5 + *  Copyright 2009 OpenSourceStewardshipFoundation.org
     4.6 + *  Licensed under GNU General Public License version 2
     4.7 + *
     4.8 + * Author: seanhalle@yahoo.com
     4.9 + * 
    4.10 + */
    4.11 +
    4.12 +#ifndef  _PR_DEFS_MAIN_H
    4.13 +#define	_PR_DEFS_MAIN_H
    4.14 +#define _GNU_SOURCE
    4.15 +
    4.16 +//===========================  PR-wide defs  ===============================
    4.17 +
    4.18 +#define SUCCESS 0
    4.19 +
    4.20 +   //only after macro-expansion are the defs of writePrivQ, aso looked up
    4.21 +   // so these defs can be at the top, and writePrivQ defined later on..
    4.22 +#define writePRQ     writePrivQ
    4.23 +#define readPRQ      readPrivQ
    4.24 +#define makePRQ      makePrivQ
    4.25 +#define numInPRQ     numInPrivQ
    4.26 +#define PRQueueStruc PrivQueueStruc
    4.27 +
    4.28 +
    4.29 +/*The language should re-define this, but need a default in case it doesn't*/
    4.30 +#ifndef _LANG_NAME_
    4.31 +#define _LANG_NAME_ ""
    4.32 +#endif
    4.33 +
    4.34 +//======================  Hardware Constants ============================
    4.35 +#include "PR_defs__HW_constants.h"
    4.36 +
    4.37 +//======================  Macros  ======================
    4.38 +   //for turning macros and other PR features on and off
    4.39 +#include "PR_defs__turn_on_and_off.h"
    4.40 +
    4.41 +#include "../Services_Offered_by_PR/Debugging/DEBUG__macros.h"
    4.42 +#include "../Services_Offered_by_PR/Measurement_and_Stats/MEAS__macros.h"
    4.43 +
    4.44 +//===========================================================================
    4.45 +#endif	/*  */
    4.46 +

     5.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     5.2 +++ b/Defines/PR_defs__HW_constants.h	Wed Sep 19 23:12:44 2012 -0700
     5.3 @@ -0,0 +1,54 @@
     5.4 +/*
     5.5 + *  Copyright 2012 OpenSourceStewardshipFoundation
     5.6 + *  Licensed under BSD
     5.7 + *
     5.8 + * Author: seanhalle@yahoo.com
     5.9 + * 
    5.10 + */
    5.11 +
    5.12 +#ifndef _PR_HW_SPEC_DEFS_H
    5.13 +#define	_PR_HW_SPEC_DEFS_H
    5.14 +#define _GNU_SOURCE
    5.15 +
    5.16 +
    5.17 +//=========================  Hardware related Constants =====================
    5.18 +   //This value is the number of hardware threads in the shared memory
    5.19 +   // machine
    5.20 +#define NUM_CORES        4
    5.21 +
    5.22 +   // tradeoff amortizing master fixed overhead vs imbalance potential
    5.23 +   // when work-stealing, can make bigger, at risk of losing cache affinity
    5.24 +#define NUM_ANIM_SLOTS  1
    5.25 +
    5.26 +   //These are for backoff inside core-loop, which reduces lock contention
    5.27 +#define NUM_REPS_W_NO_WORK_BEFORE_YIELD      10
    5.28 +#define NUM_REPS_W_NO_WORK_BEFORE_BACKOFF    2
    5.29 +#define MASTERLOCK_RETRIES_BEFORE_YIELD      100
    5.30 +#define NUM_TRIES_BEFORE_DO_BACKOFF          10
    5.31 +#define GET_LOCK_BACKOFF_WEIGHT 100
    5.32 +   
    5.33 +   // stack size in virtual processors created
    5.34 +#define VIRT_PROCR_STACK_SIZE 0x8000 /* 32K */
    5.35 +
    5.36 +   // memory for PR_int__malloc
    5.37 +#define MALLOC_ADDITIONAL_MEM_FROM_OS_SIZE 0x8000000 /* 128M */
    5.38 +
    5.39 +   //Frequency of TS counts -- have to do tests to verify
    5.40 +   //NOTE: turn off (in BIOS)  TURBO-BOOST and SPEED-STEP else won't be const
    5.41 +#define TSCOUNT_FREQ 3180000000
    5.42 +
    5.43 +#define CACHE_LINE_SZ  256
    5.44 +#define PAGE_SIZE     4096
    5.45 +
    5.46 +//To prevent false-sharing, aligns a variable to a cache-line boundary.
    5.47 +//No need to use for local vars because those are never shared between cores
    5.48 +#define __align_to_cacheline__ __attribute__ ((aligned(CACHE_LINE_SZ)))
    5.49 +
    5.50 +//aligns a pointer to cacheline. The memory area has to contain at least
    5.51 +//CACHE_LINE_SZ bytes more then needed
    5.52 +#define __align_address(ptr) ((void*)(((uintptr_t)(ptr))&((uintptr_t)(~0x0FF))))
    5.53 +
    5.54 +//===========================================================================
    5.55 +
    5.56 +#endif	/* _PR_DEFS_H */
    5.57 +

     6.1 --- a/Defines/VMS_defs.h	Mon Sep 03 03:34:54 2012 -0700
     6.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
     6.3 @@ -1,43 +0,0 @@
     6.4 -/*
     6.5 - *  Copyright 2009 OpenSourceStewardshipFoundation.org
     6.6 - *  Licensed under GNU General Public License version 2
     6.7 - *
     6.8 - * Author: seanhalle@yahoo.com
     6.9 - * 
    6.10 - */
    6.11 -
    6.12 -#ifndef  _VMS_DEFS_MAIN_H
    6.13 -#define	_VMS_DEFS_MAIN_H
    6.14 -#define _GNU_SOURCE
    6.15 -
    6.16 -//===========================  VMS-wide defs  ===============================
    6.17 -
    6.18 -#define SUCCESS 0
    6.19 -
    6.20 -   //only after macro-expansion are the defs of writePrivQ, aso looked up
    6.21 -   // so these defs can be at the top, and writePrivQ defined later on..
    6.22 -#define writeVMSQ     writePrivQ
    6.23 -#define readVMSQ      readPrivQ
    6.24 -#define makeVMSQ      makePrivQ
    6.25 -#define numInVMSQ     numInPrivQ
    6.26 -#define VMSQueueStruc PrivQueueStruc
    6.27 -
    6.28 -
    6.29 -/*The language should re-define this, but need a default in case it doesn't*/
    6.30 -#ifndef _LANG_NAME_
    6.31 -#define _LANG_NAME_ ""
    6.32 -#endif
    6.33 -
    6.34 -//======================  Hardware Constants ============================
    6.35 -#include "VMS_defs__HW_constants.h"
    6.36 -
    6.37 -//======================  Macros  ======================
    6.38 -   //for turning macros and other VMS features on and off
    6.39 -#include "VMS_defs__turn_on_and_off.h"
    6.40 -
    6.41 -#include "../Services_Offered_by_VMS/Debugging/DEBUG__macros.h"
    6.42 -#include "../Services_Offered_by_VMS/Measurement_and_Stats/MEAS__macros.h"
    6.43 -
    6.44 -//===========================================================================
    6.45 -#endif	/*  */
    6.46 -

     7.1 --- a/Defines/VMS_defs__HW_constants.h	Mon Sep 03 03:34:54 2012 -0700
     7.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
     7.3 @@ -1,54 +0,0 @@
     7.4 -/*
     7.5 - *  Copyright 2012 OpenSourceStewardshipFoundation
     7.6 - *  Licensed under BSD
     7.7 - *
     7.8 - * Author: seanhalle@yahoo.com
     7.9 - * 
    7.10 - */
    7.11 -
    7.12 -#ifndef _VMS_HW_SPEC_DEFS_H
    7.13 -#define	_VMS_HW_SPEC_DEFS_H
    7.14 -#define _GNU_SOURCE
    7.15 -
    7.16 -
    7.17 -//=========================  Hardware related Constants =====================
    7.18 -   //This value is the number of hardware threads in the shared memory
    7.19 -   // machine
    7.20 -#define NUM_CORES        4
    7.21 -
    7.22 -   // tradeoff amortizing master fixed overhead vs imbalance potential
    7.23 -   // when work-stealing, can make bigger, at risk of losing cache affinity
    7.24 -#define NUM_ANIM_SLOTS  1
    7.25 -
    7.26 -   //These are for backoff inside core-loop, which reduces lock contention
    7.27 -#define NUM_REPS_W_NO_WORK_BEFORE_YIELD      10
    7.28 -#define NUM_REPS_W_NO_WORK_BEFORE_BACKOFF    2
    7.29 -#define MASTERLOCK_RETRIES_BEFORE_YIELD      100
    7.30 -#define NUM_TRIES_BEFORE_DO_BACKOFF          10
    7.31 -#define GET_LOCK_BACKOFF_WEIGHT 100
    7.32 -   
    7.33 -   // stack size in virtual processors created
    7.34 -#define VIRT_PROCR_STACK_SIZE 0x8000 /* 32K */
    7.35 -
    7.36 -   // memory for VMS_int__malloc
    7.37 -#define MALLOC_ADDITIONAL_MEM_FROM_OS_SIZE 0x8000000 /* 128M */
    7.38 -
    7.39 -   //Frequency of TS counts -- have to do tests to verify
    7.40 -   //NOTE: turn off (in BIOS)  TURBO-BOOST and SPEED-STEP else won't be const
    7.41 -#define TSCOUNT_FREQ 3180000000
    7.42 -
    7.43 -#define CACHE_LINE_SZ  256
    7.44 -#define PAGE_SIZE     4096
    7.45 -
    7.46 -//To prevent false-sharing, aligns a variable to a cache-line boundary.
    7.47 -//No need to use for local vars because those are never shared between cores
    7.48 -#define __align_to_cacheline__ __attribute__ ((aligned(CACHE_LINE_SZ)))
    7.49 -
    7.50 -//aligns a pointer to cacheline. The memory area has to contain at least
    7.51 -//CACHE_LINE_SZ bytes more then needed
    7.52 -#define __align_address(ptr) ((void*)(((uintptr_t)(ptr))&((uintptr_t)(~0x0FF))))
    7.53 -
    7.54 -//===========================================================================
    7.55 -
    7.56 -#endif	/* _VMS_DEFS_H */
    7.57 -

     8.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     8.2 +++ b/HW_Dependent_Primitives/PR__HW_measurement.c	Wed Sep 19 23:12:44 2012 -0700
     8.3 @@ -0,0 +1,87 @@
     8.4 +#include <unistd.h>
     8.5 +#include <fcntl.h>
     8.6 +#include <linux/types.h>
     8.7 +#include <linux/perf_event.h>
     8.8 +#include <errno.h>
     8.9 +#include <sys/syscall.h>
    8.10 +#include <linux/prctl.h>
    8.11 +
    8.12 +#include "../PR.h"
    8.13 +
    8.14 +void setup_perf_counters(){
    8.15 +#ifdef HOLISTIC__TURN_ON_PERF_COUNTERS
    8.16 +    struct perf_event_attr hw_event;
    8.17 +   memset(&hw_event,0,sizeof(hw_event));
    8.18 +	hw_event.size = sizeof(struct perf_event_attr);
    8.19 +	hw_event.disabled = 1;
    8.20 +	hw_event.inherit = 1; /* children inherit it   */
    8.21 +	hw_event.pinned = 1; /* must always be on PMU */
    8.22 +	hw_event.exclusive = 0; /* only group on PMU     */
    8.23 +	hw_event.exclude_user = 0; /* don't count user      */
    8.24 +	hw_event.exclude_kernel = 0; /* ditto kernel          */
    8.25 +	hw_event.exclude_hv = 0; /* ditto hypervisor      */
    8.26 +	hw_event.exclude_idle = 0; /* don't count when idle */
    8.27 +
    8.28 +        int coreIdx;
    8.29 +   for( coreIdx = 0; coreIdx < NUM_CORES; coreIdx++ )
    8.30 +    {
    8.31 +       hw_event.type = PERF_TYPE_HARDWARE;	
    8.32 +       hw_event.config = PERF_COUNT_HW_CPU_CYCLES; //cycles
    8.33 +        _PRMasterEnv->cycles_counter_fd[coreIdx] = syscall(__NR_perf_event_open, &hw_event,
    8.34 + 		0,//pid_t pid, 
    8.35 +		coreIdx,//int cpu, 
    8.36 +		-1,//int group_fd,
    8.37 +		0//unsigned long flags
    8.38 +	);
    8.39 +        if (_PRMasterEnv->cycles_counter_fd[coreIdx]<0){
    8.40 +            fprintf(stderr,"On core %d: ",coreIdx);
    8.41 +            perror("Failed to open cycles counter");
    8.42 +        }
    8.43 +        hw_event.type = PERF_TYPE_HARDWARE;
    8.44 +        hw_event.config = PERF_COUNT_HW_INSTRUCTIONS; //instrs
    8.45 +        _PRMasterEnv->instrs_counter_fd[coreIdx] = syscall(__NR_perf_event_open, &hw_event,
    8.46 + 		0,//pid_t pid, 
    8.47 +		coreIdx,//int cpu, 
    8.48 +		-1,//int group_fd,
    8.49 +		0//unsigned long flags
    8.50 +	);
    8.51 +        if (_PRMasterEnv->instrs_counter_fd[coreIdx]<0){
    8.52 +            fprintf(stderr,"On core %d: ",coreIdx);
    8.53 +            perror("Failed to open instrs counter");
    8.54 +        }
    8.55 +        hw_event.type = PERF_TYPE_HW_CACHE;
    8.56 +        hw_event.config = PERF_COUNT_HW_CACHE_L1D <<  0  |
    8.57 +	(PERF_COUNT_HW_CACHE_OP_READ		<<  8) |
    8.58 +	(PERF_COUNT_HW_CACHE_RESULT_MISS	<< 16); //cache misses
    8.59 +        _PRMasterEnv->cachem_counter_fd[coreIdx] = syscall(__NR_perf_event_open, &hw_event,
    8.60 + 		0,//pid_t pid, 
    8.61 +		coreIdx,//int cpu, 
    8.62 +		-1,//int group_fd,
    8.63 +		0//unsigned long flags
    8.64 +	);
    8.65 +        if (_PRMasterEnv->cachem_counter_fd[coreIdx]<0){
    8.66 +            fprintf(stderr,"On core %d: ",coreIdx);
    8.67 +            perror("Failed to open cache miss counter");
    8.68 +            exit(1);
    8.69 +        }
    8.70 +   }
    8.71 +        
    8.72 +   prctl(PR_TASK_PERF_EVENTS_ENABLE);
    8.73 +#endif
    8.74 +}
    8.75 +
    8.76 +__inline__ uint64_t rdtsc(){
    8.77 +    uint32_t lo, hi;
    8.78 +    __asm__ __volatile__ (      // serialize
    8.79 +    "xorl %%eax,%%eax \n        cpuid"
    8.80 +    ::: "%rax", "%rbx", "%rcx", "%rdx");
    8.81 +    __asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi)); 
    8.82 +   /* asm volatile("RDTSC;"                   
    8.83 +                 "movl %%eax, %0;"         
    8.84 +                 "movl %%edx, %1;"         
    8.85 +               : "=m" (lo), "=m" (hi)
    8.86 +               :                        
    8.87 +               : "%eax", "%edx"         
    8.88 +                ); */
    8.89 +    return (uint64_t)hi << 32 | lo;
    8.90 +}
    8.91 \ No newline at end of file

     9.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     9.2 +++ b/HW_Dependent_Primitives/PR__HW_measurement.h	Wed Sep 19 23:12:44 2012 -0700
     9.3 @@ -0,0 +1,63 @@
     9.4 +/*
     9.5 + *  Copyright 2009 OpenSourceStewardshipFoundation.org
     9.6 + *  Licensed under GNU General Public License version 2
     9.7 + *
     9.8 + * Author: seanhalle@yahoo.com
     9.9 + * 
    9.10 + */
    9.11 +
    9.12 +#ifndef _PR__HW_MEASUREMENT_H
    9.13 +#define	_PR__HW_MEASUREMENT_H
    9.14 +#define _GNU_SOURCE
    9.15 +
    9.16 +
    9.17 +//===================  Macros to Capture Measurements  ======================
    9.18 +
    9.19 +typedef union
    9.20 + { uint32 lowHigh[2];
    9.21 +   uint64 longVal;
    9.22 + }
    9.23 +TSCountLowHigh;
    9.24 +
    9.25 +
    9.26 +//===================  Macros to Capture Measurements  ======================
    9.27 +//
    9.28 +//===== RDTSC wrapper ===== 
    9.29 +//Also runs with x86_64 code
    9.30 +#define saveTSCLowHigh(lowHighIn) \
    9.31 +   asm volatile("RDTSC;                   \
    9.32 +                 movl %%eax, %0;          \
    9.33 +                 movl %%edx, %1;"         \
    9.34 +   /* outputs */ : "=m" (lowHighIn.lowHigh[0]), "=m" (lowHighIn.lowHigh[1])\
    9.35 +   /* inputs  */ :                        \
    9.36 +   /* clobber */ : "%eax", "%edx"         \
    9.37 +                );
    9.38 +
    9.39 +#define saveTimeStampCountInto(low, high) \
    9.40 +   asm volatile("RDTSC;                   \
    9.41 +                 movl %%eax, %0;          \
    9.42 +                 movl %%edx, %1;"         \
    9.43 +   /* outputs */ : "=m" (low), "=m" (high)\
    9.44 +   /* inputs  */ :                        \
    9.45 +   /* clobber */ : "%eax", "%edx"         \
    9.46 +                );
    9.47 +
    9.48 +#define saveLowTimeStampCountInto(low)    \
    9.49 +   asm volatile("RDTSC;                   \
    9.50 +                 movl %%eax, %0;"         \
    9.51 +   /* outputs */ : "=m" (low)             \
    9.52 +   /* inputs  */ :                        \
    9.53 +   /* clobber */ : "%eax", "%edx"         \
    9.54 +                );
    9.55 +
    9.56 +inline TSCount getTSCount();
    9.57 +
    9.58 +
    9.59 +   //For code that calculates normalization-offset between TSC counts of
    9.60 +   // different cores.
    9.61 +//#define NUM_TSC_ROUND_TRIPS 10
    9.62 +
    9.63 +void setup_perf_counters();
    9.64 +uint64_t rdtsc(void);
    9.65 +#endif	/* */
    9.66 +

    10.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    10.2 +++ b/HW_Dependent_Primitives/PR__primitives.c	Wed Sep 19 23:12:44 2012 -0700
    10.3 @@ -0,0 +1,137 @@
    10.4 +/*
    10.5 + * This File contains all hardware dependent C code.
    10.6 + */
    10.7 +
    10.8 +
    10.9 +#include "../PR.h"
   10.10 +
   10.11 +/*Reset the stack then set it up with __cdecl structure on it
   10.12 + * Except doing a trick for 64 bits, where point slave to helper assembly
   10.13 + * that copies the function pointer off stack and into a reg, then
   10.14 + * jumps to it.  So, set the resumeInstrPtr to the helper-assembly.
   10.15 + *This is for first-time startup of slave.. it trashes the stack.
   10.16 + *No registers saved into old stack frame, and no animator state to
   10.17 + * return to
   10.18 + * 
   10.19 + *This was factored into separate function because it's used stand-alone in
   10.20 + * some wrapper-libraries (but only "int" version, to warn users to check
   10.21 + * carefully that it's safe)
   10.22 + */
   10.23 +inline void
   10.24 +PR_int__reset_slaveVP_to_TopLvlFn( SlaveVP *slaveVP, TopLevelFnPtr fnPtr,
   10.25 +                              void    *dataParam)
   10.26 + { void  *stackPtr;
   10.27 +
   10.28 +// Start of Hardware dependent part           
   10.29 +   
   10.30 +    //Set slave's instr pointer to a helper Fn that copies params from stack
   10.31 +   slaveVP->resumeInstrPtr  = (TopLevelFnPtr)&startUpTopLevelFn;
   10.32 +   
   10.33 +    //fnPtr takes two params -- void *dataParam & void *animSlv
   10.34 +    // Stack grows *down*, so start it at highest stack addr, minus room
   10.35 +    // for 2 params + return addr. Do ptr arith in terms of bytes..
   10.36 +   stackPtr = 
   10.37 +     (uint8 *)slaveVP->startOfStack + VIRT_PROCR_STACK_SIZE - 4*sizeof(void*);
   10.38 +  
   10.39 +    //setup __cdecl on stack
   10.40 +    //Normally, return Addr is in loc pointed to by stackPtr, but doing a
   10.41 +    // trick for 64 bit arch, where put ptr to top-level fn there instead,
   10.42 +    // and set resumeInstrPtr to a helper-fn that copies the top-level
   10.43 +    // fn ptr and params into registers.
   10.44 +    //Then, dataParam is at stackPtr + 8 bytes, & animating SlaveVP above
   10.45 +    //Do ptr arith in terms of pointers
   10.46 +   *((SlaveVP**)stackPtr + 2 ) = slaveVP; //rightmost param
   10.47 +   *((void**)stackPtr + 1 ) = dataParam;  //next  param to left
   10.48 +   *((void**)stackPtr) = (void*)fnPtr;    //copied to reg by helper Fn
   10.49 +   
   10.50 +  
   10.51 +// end of Hardware dependent part           
   10.52 +   
   10.53 +      //core controller will switch to stack & frame pointers stored in slave,
   10.54 +      // can't use this fn if have state on stack that needs preserving.
   10.55 +   slaveVP->stackPtr = stackPtr; 
   10.56 +   slaveVP->framePtr = stackPtr; 
   10.57 + }
   10.58 +
   10.59 +
   10.60 +/*Preserve the stack, pushing the __cdecl structure onto it
   10.61 + * For 64 bits, params passed in regs, so point slave to helper assembly
   10.62 + * that copies the arguments off stack and into regs, then
   10.63 + * jumps to Fn.  So, set the resumeInstrPtr to the helper-assembly.
   10.64 + * 
   10.65 + *This preserves the stack state existed at time slave was suspended.
   10.66 + */
   10.67 +inline void
   10.68 +PR_int__point_slaveVP_to_OneParamFn( SlaveVP *slaveVP, void *fnPtr,
   10.69 +                              void    *param)
   10.70 + { void  *stackPtr;
   10.71 +
   10.72 +// Start of Hardware dependent part           
   10.73 +   
   10.74 +    // Get the slave's current stack ptr, and make room for param + ret addr
   10.75 +   stackPtr = ((void **)slaveVP->stackPtr - 2);
   10.76 +  
   10.77 +    //save slave's current instr ptr as the return addr, so stack looks
   10.78 +    // just like it does after a call instr.
   10.79 +    //Put argument plus fn addr onto stack -- helper will copy into regs
   10.80 +    // then jump to the fn
   10.81 +    //fnPtr is just below top of stack, param is above at stackPtr + 8 bytes
   10.82 +   *((void**)stackPtr + 1 ) = param;
   10.83 +   *((void**)stackPtr) = slaveVP->resumeInstrPtr; //acts as return addr
   10.84 +   *((void**)stackPtr - 1) = (void*)fnPtr;        //what helper jmps to
   10.85 +   
   10.86 +    //Set slave's instr pointer to a helper Fn that copies params from stack
   10.87 +   slaveVP->resumeInstrPtr  = (TopLevelFnPtr)&jmpToOneParamFn;
   10.88 +   
   10.89 +// end of Hardware dependent part           
   10.90 +   
   10.91 +      //core controller will switch to stack & frame pointers stored in slave,
   10.92 +      // then jmp to helper Fn, which will then move param to register used
   10.93 +      // to pass argument and jmp to fnPtr saved on stack.
   10.94 +      //That fn should save the framePtr on stack and make room
   10.95 +      // for its own frame, as normal.  So don't modify framePtr, only stack
   10.96 +   slaveVP->stackPtr = stackPtr;
   10.97 + }
   10.98 +
   10.99 +
  10.100 +/*Same as for one-parameter function, but puts two arguments on stack
  10.101 + *Preserve the stack, pushing the __cdecl structure onto it
  10.102 + * For 64 bits, params passed in regs, so point slave to helper assembly
  10.103 + * that copies the arguments off stack and into regs, then
  10.104 + * jumps to Fn.  So, set the resumeInstrPtr to the helper-assembly.
  10.105 + * 
  10.106 + *This preserves the stack state existed at time slave was suspended.
  10.107 + */
  10.108 +inline void
  10.109 +PR_int__point_slaveVP_to_TwoParamFn( SlaveVP *slaveVP, void *fnPtr,
  10.110 +                              void    *param1, void *param2)
  10.111 + { void  *stackPtr;
  10.112 +
  10.113 +// Start of Hardware dependent part           
  10.114 +   
  10.115 +    // Get the slave's current stack ptr, and make room for param + ret addr
  10.116 +   stackPtr = slaveVP->stackPtr - 3;
  10.117 +  
  10.118 +    //save slave's current instr ptr as the return addr, so stack looks
  10.119 +    // just like it does after a call instr.
  10.120 +    //Put argument plus fn addr onto stack -- helper will copy into regs
  10.121 +    // then jump to the fn
  10.122 +    //fnPtr is just below top of stack, param1 is above at stackPtr + 8 bytes
  10.123 +   *((void**)stackPtr + 2 ) = param2;
  10.124 +   *((void**)stackPtr + 1 ) = param1;
  10.125 +   *((void**)stackPtr) = slaveVP->resumeInstrPtr; //acts as return addr
  10.126 +   *((void**)stackPtr - 1) = (void*)fnPtr;        //what helper jmps to
  10.127 +   
  10.128 +    //Set slave's instr pointer to a helper Fn that copies params from stack
  10.129 +   slaveVP->resumeInstrPtr  = (TopLevelFnPtr)&jmpToTwoParamFn;
  10.130 +   
  10.131 +// end of Hardware dependent part           
  10.132 +   
  10.133 +      //core controller will switch to stack & frame pointers stored in slave,
  10.134 +      // then jmp to helper Fn, which will then move param to register used
  10.135 +      // to pass argument and jmp to fnPtr saved on stack.
  10.136 +      //That fn should save the framePtr on stack and make room
  10.137 +      // for its own frame, as normal.  So don't modify framePtr, only stack
  10.138 +   slaveVP->stackPtr = stackPtr;
  10.139 + }
  10.140 +

    11.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    11.2 +++ b/HW_Dependent_Primitives/PR__primitives.h	Wed Sep 19 23:12:44 2012 -0700
    11.3 @@ -0,0 +1,55 @@
    11.4 +/*
    11.5 + *  Copyright 2009 OpenSourceStewardshipFoundation.org
    11.6 + *  Licensed under GNU General Public License version 2
    11.7 + *
    11.8 + * Author: seanhalle@yahoo.com
    11.9 + * 
   11.10 + */
   11.11 +
   11.12 +#ifndef  _PR__PRIMITIVES_H
   11.13 +#define	_PR__PRIMITIVES_H
   11.14 +#define _GNU_SOURCE
   11.15 +
   11.16 +void 
   11.17 +recordCoreCtlrReturnLabelAddr(void **returnAddress);
   11.18 +
   11.19 +void 
   11.20 +switchToSlv(SlaveVP *nextSlave);
   11.21 +
   11.22 +void 
   11.23 +switchToCoreCtlr(SlaveVP *nextSlave);
   11.24 +
   11.25 +void 
   11.26 +masterSwitchToCoreCtlr(SlaveVP *nextSlave);
   11.27 +
   11.28 +void 
   11.29 +startUpTopLevelFn();
   11.30 +
   11.31 +void 
   11.32 +jmpToOneParamFn();
   11.33 +
   11.34 +void 
   11.35 +jmpToTwoParamFn();
   11.36 +
   11.37 +void *
   11.38 +asmTerminateCoreCtlr(SlaveVP *currSlv);
   11.39 +
   11.40 +#define flushRegisters() \
   11.41 +        asm volatile ("":::"%rbx", "%r12", "%r13","%r14","%r15")
   11.42 +
   11.43 +void
   11.44 +PR_int__save_return_into_ptd_to_loc_then_do_ret(void *ptdToLoc);
   11.45 +
   11.46 +void
   11.47 +PR_int__return_to_addr_in_ptd_to_loc(void *ptdToLoc);
   11.48 +
   11.49 +inline void
   11.50 +PR_int__point_slaveVP_to_OneParamFn( SlaveVP *slaveVP, void *fnPtr,
   11.51 +                              void    *param);
   11.52 +
   11.53 +inline void
   11.54 +PR_int__point_slaveVP_to_TwoParamFn( SlaveVP *slaveVP, void *fnPtr,
   11.55 +                              void    *param1, void *param2);
   11.56 +
   11.57 +#endif	/* _PR__HW_DEPENDENT_H */
   11.58 +

    12.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    12.2 +++ b/HW_Dependent_Primitives/PR__primitives_asm.s	Wed Sep 19 23:12:44 2012 -0700
    12.3 @@ -0,0 +1,189 @@
    12.4 +.data
    12.5 +
    12.6 +
    12.7 +.text
    12.8 +
    12.9 +//Save return label address for the coreCtlr to pointer
   12.10 +//Arguments: Pointer to variable holding address
   12.11 +.globl recordCoreCtlrReturnLabelAddr
   12.12 +recordCoreCtlrReturnLabelAddr:
   12.13 +    movq    $coreCtlrReturn, %rcx  #load label address
   12.14 +    movq    %rcx, (%rdi)           #save address to pointer
   12.15 +    ret
   12.16 +
   12.17 +
   12.18 +//Trick for 64 bit arch -- copies args from stack into regs, then does jmp to
   12.19 +// the top-level function, which was pointed to by the stack-ptr
   12.20 +.globl startUpTopLevelFn
   12.21 +startUpTopLevelFn:
   12.22 +    movq    %rdi      , %rsi #get second argument from first argument of switchSlv
   12.23 +    movq    0x08(%rsp), %rdi #get first argument from stack
   12.24 +    movq    (%rsp)    , %rax #get top-level function's addr from stack
   12.25 +    jmp     *%rax            #jump to the top-level function
   12.26 +
   12.27 +
   12.28 +//Args passed in regs in 64 bit arch. This copies args from stack into regs,
   12.29 +// then does jmp to the function, whose addr is on stack.
   12.30 +//For 64bit, %rdi is first arg, %rsi is second arg to function
   12.31 +//The top of stack is a valid return addr (old value of slaveVP's instrPtr),
   12.32 +// and the fnPtr is just below the top of stack (will be overwritten when
   12.33 +// fn saves the frame ptr)
   12.34 +.globl jmpToOneParamFn
   12.35 +jmpToOneParamFn:
   12.36 +    movq    0x08(%rsp), %rdi #get the argument from stack
   12.37 +    movq   -0x08(%rsp), %rax #get function's addr from stack
   12.38 +    jmp     *%rax            #jump to the function
   12.39 +
   12.40 +.globl jmpToTwoParamFn
   12.41 +jmpToTwoParamFn:
   12.42 +    movq    0x10(%rsp), %rsi #get the second argument from stack
   12.43 +    movq    0x08(%rsp), %rdi #get the first argument from stack
   12.44 +    movq   -0x08(%rsp), %rax #get function's addr from stack
   12.45 +    jmp     *%rax            #jump to the function
   12.46 +
   12.47 +
   12.48 +//Switches form CoreCtlr to either a normal Slv VP or the Master VP
   12.49 +//switch to VP's stack and frame ptr then jump to VP's next-instr-ptr
   12.50 +/* SlaveVP  offsets:
   12.51 + * 0x00  stackPtr
   12.52 + * 0x08 framePtr
   12.53 + * 0x10 resumeInstrPtr
   12.54 + * 0x18 coreCtlrFramePtr
   12.55 + * 0x20 coreCtlrStackPtr
   12.56 + *
   12.57 + * _PRMasterEnv  offsets:
   12.58 + * 0x00 coreCtlrReturnPt
   12.59 + * 0x100 masterLock
   12.60 + */
   12.61 +.globl switchToSlv
   12.62 +switchToSlv:
   12.63 +    #SlaveVP in %rdi
   12.64 +    movq    %rsp      , 0x20(%rdi)   #save core ctlr stack pointer 
   12.65 +    movq    %rbp      , 0x18(%rdi)   #save core ctlr frame pointer
   12.66 +    movq    0x00(%rdi), %rsp         #restore stack pointer
   12.67 +    movq    0x08(%rdi), %rbp         #restore frame pointer
   12.68 +    movq    0x10(%rdi), %rax         #get jmp pointer
   12.69 +    jmp     *%rax                    #jmp to Slv
   12.70 +coreCtlrReturn:
   12.71 +    ret
   12.72 +
   12.73 +    
   12.74 +//switches to core controller. saves return address
   12.75 +/* SlaveVP  offsets:
   12.76 + * 0x00  stackPtr
   12.77 + * 0x08 framePtr
   12.78 + * 0x10 resumeInstrPtr
   12.79 + * 0x18 coreCtlrFramePtr
   12.80 + * 0x20 coreCtlrStackPtr
   12.81 + *
   12.82 + * _PRMasterEnv  offsets:
   12.83 + * 0x00 coreCtlrReturnPt
   12.84 + * 0x100 masterLock
   12.85 + */
   12.86 +.globl switchToCoreCtlr
   12.87 +switchToCoreCtlr:
   12.88 +    #SlaveVP in %rdi
   12.89 +    movq    $SlvReturn, 0x10(%rdi)   #store return address
   12.90 +    movq    %rsp      , 0x00(%rdi)   #save stack pointer 
   12.91 +    movq    %rbp      , 0x08(%rdi)   #save frame pointer
   12.92 +    movq    0x20(%rdi), %rsp         #restore stack pointer
   12.93 +    movq    0x18(%rdi), %rbp         #restore frame pointer
   12.94 +    movq    $_PRMasterEnv, %rcx
   12.95 +    movq        (%rcx), %rcx         #_PRMasterEnv is pointer to struct
   12.96 +    movq    0x00(%rcx), %rax         #get CoreCtlrStartPt
   12.97 +    jmp     *%rax                    #jmp to CoreCtlr
   12.98 +SlvReturn:
   12.99 +    ret
  12.100 +
  12.101 +
  12.102 +
  12.103 +//switches to core controller from master. saves return address
  12.104 +//Releases masterLock so the next AnimationMaster can be executed
  12.105 +/* SlaveVP  offsets:
  12.106 + * 0x00  stackPtr
  12.107 + * 0x08 framePtr
  12.108 + * 0x10 resumeInstrPtr
  12.109 + * 0x18 coreCtlrFramePtr
  12.110 + * 0x20 coreCtlrStackPtr
  12.111 + *
  12.112 + * _PRMasterEnv  offsets:
  12.113 + * 0x00 coreCtlrReturnPt
  12.114 + * 0x100 masterLock
  12.115 + */
  12.116 +.globl masterSwitchToCoreCtlr
  12.117 +masterSwitchToCoreCtlr:
  12.118 +    #SlaveVP in %rdi
  12.119 +    movq    $MasterReturn, 0x10(%rdi)   #store return address
  12.120 +    movq    %rsp      , 0x00(%rdi)   #save stack pointer 
  12.121 +    movq    %rbp      , 0x08(%rdi)   #save frame pointer
  12.122 +    movq    0x20(%rdi), %rsp         #restore stack pointer
  12.123 +    movq    0x18(%rdi), %rbp         #restore frame pointer
  12.124 +    movq    $_PRMasterEnv, %rcx
  12.125 +    movq        (%rcx), %rcx         #_PRMasterEnv is pointer to struct
  12.126 +    movq    0x00(%rcx), %rax         #get CoreCtlr return pt
  12.127 +    movl    $0x0      , 0x100(%rcx)  #release lock
  12.128 +    jmp     *%rax                    #jmp to CoreCtlr
  12.129 +MasterReturn:
  12.130 +    ret
  12.131 +
  12.132 +
  12.133 +/*Switch to terminateCoreCtlr
  12.134 + *This is called by endOSThreadFn, which is the top-level function given
  12.135 + * to a shutdown slave.  When such a slave gets switched to, by the core
  12.136 + * controller, it runs the top-level function, which calls this, which
  12.137 + * then calls terminateCoreCtlr, which ends the pthread.  Note, when get
  12.138 + * here, stack is already set up for switchSlv and Slv ptr is in %rdi.
  12.139 + *Do not save registers of Slv because this function will never return
  12.140 + *
  12.141 + * SlaveVP  offsets:
  12.142 + * 0x00  stackPtr
  12.143 + * 0x08 framePtr
  12.144 + * 0x10 resumeInstrPtr
  12.145 + * 0x18 coreCtlrFramePtr
  12.146 + * 0x20 coreCtlrStackPtr
  12.147 + *
  12.148 + * _PRMasterEnv  offsets:
  12.149 + * 0x00 coreCtlrReturnPt
  12.150 + * 0x100 masterLock
  12.151 + */
  12.152 +.globl asmTerminateCoreCtlr
  12.153 +asmTerminateCoreCtlr:                #SlaveVP ptr is in %rdi
  12.154 +    movq    0x20(%rdi), %rsp         #restore stack pointer
  12.155 +    movq    0x18(%rdi), %rbp         #restore frame pointer
  12.156 +    movq    $terminateCoreCtlr, %rax
  12.157 +    jmp     *%rax                    #jmp to fn that ends the pthread
  12.158 +
  12.159 +
  12.160 +/*
  12.161 + * This one for the sequential version is special. It discards the current stack
  12.162 + * and returns directly from the coreCtlr after PR_WL__dissipate_slaveVP was called
  12.163 + */
  12.164 +.globl asmTerminateCoreCtlrSeq
  12.165 +asmTerminateCoreCtlrSeq:
  12.166 +    #SlaveVP in %rdi
  12.167 +    movq    0x20(%rdi), %rsp         #restore stack pointer
  12.168 +    movq    0x18(%rdi), %rbp         #restore frame pointer
  12.169 +    #argument is in %rdi
  12.170 +    call    PR_int__dissipate_slaveVP
  12.171 +    movq    %rbp      , %rsp        #goto the coreCtlrs stack
  12.172 +    pop     %rbp        #restore the old framepointer
  12.173 +    ret                 #return from core controller
  12.174 +    
  12.175 +
  12.176 +//Takes the return addr off the stack and saves into the loc pointed to by
  12.177 +// by the parameter passed in via rdi.  Return addr is at 0x8(%rbp) for 64bit
  12.178 +.globl PR_int__save_return_into_ptd_to_loc_then_do_ret
  12.179 +PR_int__save_return_into_ptd_to_loc_then_do_ret:
  12.180 +    movq 0x08(%rbp),   %rax  #get ret address, rbp is the same as in the calling function
  12.181 +    movq      %rax,   (%rdi) #write ret addr into addr passed as param field
  12.182 +    ret
  12.183 +
  12.184 +
  12.185 +//Assembly code changes the return addr on the stack to the one
  12.186 +// pointed to by the parameter, then returns. Stack's return addr is at 0x8(%rbp)
  12.187 +.globl PR_int__return_to_addr_in_ptd_to_loc
  12.188 +PR_int__return_to_addr_in_ptd_to_loc:
  12.189 +    movq   (%rdi),     %rax  #get return addr from addr passed as param
  12.190 +    movq    %rax, 0x08(%rbp) #write return addr to the stack of the caller
  12.191 +    ret
  12.192 +

    13.1 --- a/HW_Dependent_Primitives/VMS__HW_measurement.c	Mon Sep 03 03:34:54 2012 -0700
    13.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
    13.3 @@ -1,87 +0,0 @@
    13.4 -#include <unistd.h>
    13.5 -#include <fcntl.h>
    13.6 -#include <linux/types.h>
    13.7 -#include <linux/perf_event.h>
    13.8 -#include <errno.h>
    13.9 -#include <sys/syscall.h>
   13.10 -#include <linux/prctl.h>
   13.11 -
   13.12 -#include "../VMS.h"
   13.13 -
   13.14 -void setup_perf_counters(){
   13.15 -#ifdef HOLISTIC__TURN_ON_PERF_COUNTERS
   13.16 -    struct perf_event_attr hw_event;
   13.17 -   memset(&hw_event,0,sizeof(hw_event));
   13.18 -	hw_event.size = sizeof(struct perf_event_attr);
   13.19 -	hw_event.disabled = 1;
   13.20 -	hw_event.inherit = 1; /* children inherit it   */
   13.21 -	hw_event.pinned = 1; /* must always be on PMU */
   13.22 -	hw_event.exclusive = 0; /* only group on PMU     */
   13.23 -	hw_event.exclude_user = 0; /* don't count user      */
   13.24 -	hw_event.exclude_kernel = 0; /* ditto kernel          */
   13.25 -	hw_event.exclude_hv = 0; /* ditto hypervisor      */
   13.26 -	hw_event.exclude_idle = 0; /* don't count when idle */
   13.27 -
   13.28 -        int coreIdx;
   13.29 -   for( coreIdx = 0; coreIdx < NUM_CORES; coreIdx++ )
   13.30 -    {
   13.31 -       hw_event.type = PERF_TYPE_HARDWARE;	
   13.32 -       hw_event.config = PERF_COUNT_HW_CPU_CYCLES; //cycles
   13.33 -        _VMSMasterEnv->cycles_counter_fd[coreIdx] = syscall(__NR_perf_event_open, &hw_event,
   13.34 - 		0,//pid_t pid, 
   13.35 -		coreIdx,//int cpu, 
   13.36 -		-1,//int group_fd,
   13.37 -		0//unsigned long flags
   13.38 -	);
   13.39 -        if (_VMSMasterEnv->cycles_counter_fd[coreIdx]<0){
   13.40 -            fprintf(stderr,"On core %d: ",coreIdx);
   13.41 -            perror("Failed to open cycles counter");
   13.42 -        }
   13.43 -        hw_event.type = PERF_TYPE_HARDWARE;
   13.44 -        hw_event.config = PERF_COUNT_HW_INSTRUCTIONS; //instrs
   13.45 -        _VMSMasterEnv->instrs_counter_fd[coreIdx] = syscall(__NR_perf_event_open, &hw_event,
   13.46 - 		0,//pid_t pid, 
   13.47 -		coreIdx,//int cpu, 
   13.48 -		-1,//int group_fd,
   13.49 -		0//unsigned long flags
   13.50 -	);
   13.51 -        if (_VMSMasterEnv->instrs_counter_fd[coreIdx]<0){
   13.52 -            fprintf(stderr,"On core %d: ",coreIdx);
   13.53 -            perror("Failed to open instrs counter");
   13.54 -        }
   13.55 -        hw_event.type = PERF_TYPE_HW_CACHE;
   13.56 -        hw_event.config = PERF_COUNT_HW_CACHE_L1D <<  0  |
   13.57 -	(PERF_COUNT_HW_CACHE_OP_READ		<<  8) |
   13.58 -	(PERF_COUNT_HW_CACHE_RESULT_MISS	<< 16); //cache misses
   13.59 -        _VMSMasterEnv->cachem_counter_fd[coreIdx] = syscall(__NR_perf_event_open, &hw_event,
   13.60 - 		0,//pid_t pid, 
   13.61 -		coreIdx,//int cpu, 
   13.62 -		-1,//int group_fd,
   13.63 -		0//unsigned long flags
   13.64 -	);
   13.65 -        if (_VMSMasterEnv->cachem_counter_fd[coreIdx]<0){
   13.66 -            fprintf(stderr,"On core %d: ",coreIdx);
   13.67 -            perror("Failed to open cache miss counter");
   13.68 -            exit(1);
   13.69 -        }
   13.70 -   }
   13.71 -        
   13.72 -   prctl(PR_TASK_PERF_EVENTS_ENABLE);
   13.73 -#endif
   13.74 -}
   13.75 -
   13.76 -__inline__ uint64_t rdtsc(){
   13.77 -    uint32_t lo, hi;
   13.78 -    __asm__ __volatile__ (      // serialize
   13.79 -    "xorl %%eax,%%eax \n        cpuid"
   13.80 -    ::: "%rax", "%rbx", "%rcx", "%rdx");
   13.81 -    __asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi)); 
   13.82 -   /* asm volatile("RDTSC;"                   
   13.83 -                 "movl %%eax, %0;"         
   13.84 -                 "movl %%edx, %1;"         
   13.85 -               : "=m" (lo), "=m" (hi)
   13.86 -               :                        
   13.87 -               : "%eax", "%edx"         
   13.88 -                ); */
   13.89 -    return (uint64_t)hi << 32 | lo;
   13.90 -}
   13.91 \ No newline at end of file

    14.1 --- a/HW_Dependent_Primitives/VMS__HW_measurement.h	Mon Sep 03 03:34:54 2012 -0700
    14.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
    14.3 @@ -1,63 +0,0 @@
    14.4 -/*
    14.5 - *  Copyright 2009 OpenSourceStewardshipFoundation.org
    14.6 - *  Licensed under GNU General Public License version 2
    14.7 - *
    14.8 - * Author: seanhalle@yahoo.com
    14.9 - * 
   14.10 - */
   14.11 -
   14.12 -#ifndef _VMS__HW_MEASUREMENT_H
   14.13 -#define	_VMS__HW_MEASUREMENT_H
   14.14 -#define _GNU_SOURCE
   14.15 -
   14.16 -
   14.17 -//===================  Macros to Capture Measurements  ======================
   14.18 -
   14.19 -typedef union
   14.20 - { uint32 lowHigh[2];
   14.21 -   uint64 longVal;
   14.22 - }
   14.23 -TSCountLowHigh;
   14.24 -
   14.25 -
   14.26 -//===================  Macros to Capture Measurements  ======================
   14.27 -//
   14.28 -//===== RDTSC wrapper ===== 
   14.29 -//Also runs with x86_64 code
   14.30 -#define saveTSCLowHigh(lowHighIn) \
   14.31 -   asm volatile("RDTSC;                   \
   14.32 -                 movl %%eax, %0;          \
   14.33 -                 movl %%edx, %1;"         \
   14.34 -   /* outputs */ : "=m" (lowHighIn.lowHigh[0]), "=m" (lowHighIn.lowHigh[1])\
   14.35 -   /* inputs  */ :                        \
   14.36 -   /* clobber */ : "%eax", "%edx"         \
   14.37 -                );
   14.38 -
   14.39 -#define saveTimeStampCountInto(low, high) \
   14.40 -   asm volatile("RDTSC;                   \
   14.41 -                 movl %%eax, %0;          \
   14.42 -                 movl %%edx, %1;"         \
   14.43 -   /* outputs */ : "=m" (low), "=m" (high)\
   14.44 -   /* inputs  */ :                        \
   14.45 -   /* clobber */ : "%eax", "%edx"         \
   14.46 -                );
   14.47 -
   14.48 -#define saveLowTimeStampCountInto(low)    \
   14.49 -   asm volatile("RDTSC;                   \
   14.50 -                 movl %%eax, %0;"         \
   14.51 -   /* outputs */ : "=m" (low)             \
   14.52 -   /* inputs  */ :                        \
   14.53 -   /* clobber */ : "%eax", "%edx"         \
   14.54 -                );
   14.55 -
   14.56 -inline TSCount getTSCount();
   14.57 -
   14.58 -
   14.59 -   //For code that calculates normalization-offset between TSC counts of
   14.60 -   // different cores.
   14.61 -//#define NUM_TSC_ROUND_TRIPS 10
   14.62 -
   14.63 -void setup_perf_counters();
   14.64 -uint64_t rdtsc(void);
   14.65 -#endif	/* */
   14.66 -

    15.1 --- a/HW_Dependent_Primitives/VMS__primitives.c	Mon Sep 03 03:34:54 2012 -0700
    15.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
    15.3 @@ -1,137 +0,0 @@
    15.4 -/*
    15.5 - * This File contains all hardware dependent C code.
    15.6 - */
    15.7 -
    15.8 -
    15.9 -#include "../VMS.h"
   15.10 -
   15.11 -/*Reset the stack then set it up with __cdecl structure on it
   15.12 - * Except doing a trick for 64 bits, where point slave to helper assembly
   15.13 - * that copies the function pointer off stack and into a reg, then
   15.14 - * jumps to it.  So, set the resumeInstrPtr to the helper-assembly.
   15.15 - *This is for first-time startup of slave.. it trashes the stack.
   15.16 - *No registers saved into old stack frame, and no animator state to
   15.17 - * return to
   15.18 - * 
   15.19 - *This was factored into separate function because it's used stand-alone in
   15.20 - * some wrapper-libraries (but only "int" version, to warn users to check
   15.21 - * carefully that it's safe)
   15.22 - */
   15.23 -inline void
   15.24 -VMS_int__reset_slaveVP_to_TopLvlFn( SlaveVP *slaveVP, TopLevelFnPtr fnPtr,
   15.25 -                              void    *dataParam)
   15.26 - { void  *stackPtr;
   15.27 -
   15.28 -// Start of Hardware dependent part           
   15.29 -   
   15.30 -    //Set slave's instr pointer to a helper Fn that copies params from stack
   15.31 -   slaveVP->resumeInstrPtr  = (TopLevelFnPtr)&startUpTopLevelFn;
   15.32 -   
   15.33 -    //fnPtr takes two params -- void *dataParam & void *animSlv
   15.34 -    // Stack grows *down*, so start it at highest stack addr, minus room
   15.35 -    // for 2 params + return addr. Do ptr arith in terms of bytes..
   15.36 -   stackPtr = 
   15.37 -     (uint8 *)slaveVP->startOfStack + VIRT_PROCR_STACK_SIZE - 4*sizeof(void*);
   15.38 -  
   15.39 -    //setup __cdecl on stack
   15.40 -    //Normally, return Addr is in loc pointed to by stackPtr, but doing a
   15.41 -    // trick for 64 bit arch, where put ptr to top-level fn there instead,
   15.42 -    // and set resumeInstrPtr to a helper-fn that copies the top-level
   15.43 -    // fn ptr and params into registers.
   15.44 -    //Then, dataParam is at stackPtr + 8 bytes, & animating SlaveVP above
   15.45 -    //Do ptr arith in terms of pointers
   15.46 -   *((SlaveVP**)stackPtr + 2 ) = slaveVP; //rightmost param
   15.47 -   *((void**)stackPtr + 1 ) = dataParam;  //next  param to left
   15.48 -   *((void**)stackPtr) = (void*)fnPtr;    //copied to reg by helper Fn
   15.49 -   
   15.50 -  
   15.51 -// end of Hardware dependent part           
   15.52 -   
   15.53 -      //core controller will switch to stack & frame pointers stored in slave,
   15.54 -      // can't use this fn if have state on stack that needs preserving.
   15.55 -   slaveVP->stackPtr = stackPtr; 
   15.56 -   slaveVP->framePtr = stackPtr; 
   15.57 - }
   15.58 -
   15.59 -
   15.60 -/*Preserve the stack, pushing the __cdecl structure onto it
   15.61 - * For 64 bits, params passed in regs, so point slave to helper assembly
   15.62 - * that copies the arguments off stack and into regs, then
   15.63 - * jumps to Fn.  So, set the resumeInstrPtr to the helper-assembly.
   15.64 - * 
   15.65 - *This preserves the stack state existed at time slave was suspended.
   15.66 - */
   15.67 -inline void
   15.68 -VMS_int__point_slaveVP_to_OneParamFn( SlaveVP *slaveVP, void *fnPtr,
   15.69 -                              void    *param)
   15.70 - { void  *stackPtr;
   15.71 -
   15.72 -// Start of Hardware dependent part           
   15.73 -   
   15.74 -    // Get the slave's current stack ptr, and make room for param + ret addr
   15.75 -   stackPtr = ((void **)slaveVP->stackPtr - 2);
   15.76 -  
   15.77 -    //save slave's current instr ptr as the return addr, so stack looks
   15.78 -    // just like it does after a call instr.
   15.79 -    //Put argument plus fn addr onto stack -- helper will copy into regs
   15.80 -    // then jump to the fn
   15.81 -    //fnPtr is just below top of stack, param is above at stackPtr + 8 bytes
   15.82 -   *((void**)stackPtr + 1 ) = param;
   15.83 -   *((void**)stackPtr) = slaveVP->resumeInstrPtr; //acts as return addr
   15.84 -   *((void**)stackPtr - 1) = (void*)fnPtr;        //what helper jmps to
   15.85 -   
   15.86 -    //Set slave's instr pointer to a helper Fn that copies params from stack
   15.87 -   slaveVP->resumeInstrPtr  = (TopLevelFnPtr)&jmpToOneParamFn;
   15.88 -   
   15.89 -// end of Hardware dependent part           
   15.90 -   
   15.91 -      //core controller will switch to stack & frame pointers stored in slave,
   15.92 -      // then jmp to helper Fn, which will then move param to register used
   15.93 -      // to pass argument and jmp to fnPtr saved on stack.
   15.94 -      //That fn should save the framePtr on stack and make room
   15.95 -      // for its own frame, as normal.  So don't modify framePtr, only stack
   15.96 -   slaveVP->stackPtr = stackPtr;
   15.97 - }
   15.98 -
   15.99 -
  15.100 -/*Same as for one-parameter function, but puts two arguments on stack
  15.101 - *Preserve the stack, pushing the __cdecl structure onto it
  15.102 - * For 64 bits, params passed in regs, so point slave to helper assembly
  15.103 - * that copies the arguments off stack and into regs, then
  15.104 - * jumps to Fn.  So, set the resumeInstrPtr to the helper-assembly.
  15.105 - * 
  15.106 - *This preserves the stack state existed at time slave was suspended.
  15.107 - */
  15.108 -inline void
  15.109 -VMS_int__point_slaveVP_to_TwoParamFn( SlaveVP *slaveVP, void *fnPtr,
  15.110 -                              void    *param1, void *param2)
  15.111 - { void  *stackPtr;
  15.112 -
  15.113 -// Start of Hardware dependent part           
  15.114 -   
  15.115 -    // Get the slave's current stack ptr, and make room for param + ret addr
  15.116 -   stackPtr = slaveVP->stackPtr - 3;
  15.117 -  
  15.118 -    //save slave's current instr ptr as the return addr, so stack looks
  15.119 -    // just like it does after a call instr.
  15.120 -    //Put argument plus fn addr onto stack -- helper will copy into regs
  15.121 -    // then jump to the fn
  15.122 -    //fnPtr is just below top of stack, param1 is above at stackPtr + 8 bytes
  15.123 -   *((void**)stackPtr + 2 ) = param2;
  15.124 -   *((void**)stackPtr + 1 ) = param1;
  15.125 -   *((void**)stackPtr) = slaveVP->resumeInstrPtr; //acts as return addr
  15.126 -   *((void**)stackPtr - 1) = (void*)fnPtr;        //what helper jmps to
  15.127 -   
  15.128 -    //Set slave's instr pointer to a helper Fn that copies params from stack
  15.129 -   slaveVP->resumeInstrPtr  = (TopLevelFnPtr)&jmpToTwoParamFn;
  15.130 -   
  15.131 -// end of Hardware dependent part           
  15.132 -   
  15.133 -      //core controller will switch to stack & frame pointers stored in slave,
  15.134 -      // then jmp to helper Fn, which will then move param to register used
  15.135 -      // to pass argument and jmp to fnPtr saved on stack.
  15.136 -      //That fn should save the framePtr on stack and make room
  15.137 -      // for its own frame, as normal.  So don't modify framePtr, only stack
  15.138 -   slaveVP->stackPtr = stackPtr;
  15.139 - }
  15.140 -

    16.1 --- a/HW_Dependent_Primitives/VMS__primitives.h	Mon Sep 03 03:34:54 2012 -0700
    16.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
    16.3 @@ -1,55 +0,0 @@
    16.4 -/*
    16.5 - *  Copyright 2009 OpenSourceStewardshipFoundation.org
    16.6 - *  Licensed under GNU General Public License version 2
    16.7 - *
    16.8 - * Author: seanhalle@yahoo.com
    16.9 - * 
   16.10 - */
   16.11 -
   16.12 -#ifndef  _VMS__PRIMITIVES_H
   16.13 -#define	_VMS__PRIMITIVES_H
   16.14 -#define _GNU_SOURCE
   16.15 -
   16.16 -void 
   16.17 -recordCoreCtlrReturnLabelAddr(void **returnAddress);
   16.18 -
   16.19 -void 
   16.20 -switchToSlv(SlaveVP *nextSlave);
   16.21 -
   16.22 -void 
   16.23 -switchToCoreCtlr(SlaveVP *nextSlave);
   16.24 -
   16.25 -void 
   16.26 -masterSwitchToCoreCtlr(SlaveVP *nextSlave);
   16.27 -
   16.28 -void 
   16.29 -startUpTopLevelFn();
   16.30 -
   16.31 -void 
   16.32 -jmpToOneParamFn();
   16.33 -
   16.34 -void 
   16.35 -jmpToTwoParamFn();
   16.36 -
   16.37 -void *
   16.38 -asmTerminateCoreCtlr(SlaveVP *currSlv);
   16.39 -
   16.40 -#define flushRegisters() \
   16.41 -        asm volatile ("":::"%rbx", "%r12", "%r13","%r14","%r15")
   16.42 -
   16.43 -void
   16.44 -VMS_int__save_return_into_ptd_to_loc_then_do_ret(void *ptdToLoc);
   16.45 -
   16.46 -void
   16.47 -VMS_int__return_to_addr_in_ptd_to_loc(void *ptdToLoc);
   16.48 -
   16.49 -inline void
   16.50 -VMS_int__point_slaveVP_to_OneParamFn( SlaveVP *slaveVP, void *fnPtr,
   16.51 -                              void    *param);
   16.52 -
   16.53 -inline void
   16.54 -VMS_int__point_slaveVP_to_TwoParamFn( SlaveVP *slaveVP, void *fnPtr,
   16.55 -                              void    *param1, void *param2);
   16.56 -
   16.57 -#endif	/* _VMS__HW_DEPENDENT_H */
   16.58 -

    17.1 --- a/HW_Dependent_Primitives/VMS__primitives_asm.s	Mon Sep 03 03:34:54 2012 -0700
    17.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
    17.3 @@ -1,189 +0,0 @@
    17.4 -.data
    17.5 -
    17.6 -
    17.7 -.text
    17.8 -
    17.9 -//Save return label address for the coreCtlr to pointer
   17.10 -//Arguments: Pointer to variable holding address
   17.11 -.globl recordCoreCtlrReturnLabelAddr
   17.12 -recordCoreCtlrReturnLabelAddr:
   17.13 -    movq    $coreCtlrReturn, %rcx  #load label address
   17.14 -    movq    %rcx, (%rdi)           #save address to pointer
   17.15 -    ret
   17.16 -
   17.17 -
   17.18 -//Trick for 64 bit arch -- copies args from stack into regs, then does jmp to
   17.19 -// the top-level function, which was pointed to by the stack-ptr
   17.20 -.globl startUpTopLevelFn
   17.21 -startUpTopLevelFn:
   17.22 -    movq    %rdi      , %rsi #get second argument from first argument of switchSlv
   17.23 -    movq    0x08(%rsp), %rdi #get first argument from stack
   17.24 -    movq    (%rsp)    , %rax #get top-level function's addr from stack
   17.25 -    jmp     *%rax            #jump to the top-level function
   17.26 -
   17.27 -
   17.28 -//Args passed in regs in 64 bit arch. This copies args from stack into regs,
   17.29 -// then does jmp to the function, whose addr is on stack.
   17.30 -//For 64bit, %rdi is first arg, %rsi is second arg to function
   17.31 -//The top of stack is a valid return addr (old value of slaveVP's instrPtr),
   17.32 -// and the fnPtr is just below the top of stack (will be overwritten when
   17.33 -// fn saves the frame ptr)
   17.34 -.globl jmpToOneParamFn
   17.35 -jmpToOneParamFn:
   17.36 -    movq    0x08(%rsp), %rdi #get the argument from stack
   17.37 -    movq   -0x08(%rsp), %rax #get function's addr from stack
   17.38 -    jmp     *%rax            #jump to the function
   17.39 -
   17.40 -.globl jmpToTwoParamFn
   17.41 -jmpToTwoParamFn:
   17.42 -    movq    0x10(%rsp), %rsi #get the second argument from stack
   17.43 -    movq    0x08(%rsp), %rdi #get the first argument from stack
   17.44 -    movq   -0x08(%rsp), %rax #get function's addr from stack
   17.45 -    jmp     *%rax            #jump to the function
   17.46 -
   17.47 -
   17.48 -//Switches form CoreCtlr to either a normal Slv VP or the Master VP
   17.49 -//switch to VP's stack and frame ptr then jump to VP's next-instr-ptr
   17.50 -/* SlaveVP  offsets:
   17.51 - * 0x00  stackPtr
   17.52 - * 0x08 framePtr
   17.53 - * 0x10 resumeInstrPtr
   17.54 - * 0x18 coreCtlrFramePtr
   17.55 - * 0x20 coreCtlrStackPtr
   17.56 - *
   17.57 - * _VMSMasterEnv  offsets:
   17.58 - * 0x00 coreCtlrReturnPt
   17.59 - * 0x100 masterLock
   17.60 - */
   17.61 -.globl switchToSlv
   17.62 -switchToSlv:
   17.63 -    #SlaveVP in %rdi
   17.64 -    movq    %rsp      , 0x20(%rdi)   #save core ctlr stack pointer 
   17.65 -    movq    %rbp      , 0x18(%rdi)   #save core ctlr frame pointer
   17.66 -    movq    0x00(%rdi), %rsp         #restore stack pointer
   17.67 -    movq    0x08(%rdi), %rbp         #restore frame pointer
   17.68 -    movq    0x10(%rdi), %rax         #get jmp pointer
   17.69 -    jmp     *%rax                    #jmp to Slv
   17.70 -coreCtlrReturn:
   17.71 -    ret
   17.72 -
   17.73 -    
   17.74 -//switches to core controller. saves return address
   17.75 -/* SlaveVP  offsets:
   17.76 - * 0x00  stackPtr
   17.77 - * 0x08 framePtr
   17.78 - * 0x10 resumeInstrPtr
   17.79 - * 0x18 coreCtlrFramePtr
   17.80 - * 0x20 coreCtlrStackPtr
   17.81 - *
   17.82 - * _VMSMasterEnv  offsets:
   17.83 - * 0x00 coreCtlrReturnPt
   17.84 - * 0x100 masterLock
   17.85 - */
   17.86 -.globl switchToCoreCtlr
   17.87 -switchToCoreCtlr:
   17.88 -    #SlaveVP in %rdi
   17.89 -    movq    $SlvReturn, 0x10(%rdi)   #store return address
   17.90 -    movq    %rsp      , 0x00(%rdi)   #save stack pointer 
   17.91 -    movq    %rbp      , 0x08(%rdi)   #save frame pointer
   17.92 -    movq    0x20(%rdi), %rsp         #restore stack pointer
   17.93 -    movq    0x18(%rdi), %rbp         #restore frame pointer
   17.94 -    movq    $_VMSMasterEnv, %rcx
   17.95 -    movq        (%rcx), %rcx         #_VMSMasterEnv is pointer to struct
   17.96 -    movq    0x00(%rcx), %rax         #get CoreCtlrStartPt
   17.97 -    jmp     *%rax                    #jmp to CoreCtlr
   17.98 -SlvReturn:
   17.99 -    ret
  17.100 -
  17.101 -
  17.102 -
  17.103 -//switches to core controller from master. saves return address
  17.104 -//Releases masterLock so the next AnimationMaster can be executed
  17.105 -/* SlaveVP  offsets:
  17.106 - * 0x00  stackPtr
  17.107 - * 0x08 framePtr
  17.108 - * 0x10 resumeInstrPtr
  17.109 - * 0x18 coreCtlrFramePtr
  17.110 - * 0x20 coreCtlrStackPtr
  17.111 - *
  17.112 - * _VMSMasterEnv  offsets:
  17.113 - * 0x00 coreCtlrReturnPt
  17.114 - * 0x100 masterLock
  17.115 - */
  17.116 -.globl masterSwitchToCoreCtlr
  17.117 -masterSwitchToCoreCtlr:
  17.118 -    #SlaveVP in %rdi
  17.119 -    movq    $MasterReturn, 0x10(%rdi)   #store return address
  17.120 -    movq    %rsp      , 0x00(%rdi)   #save stack pointer 
  17.121 -    movq    %rbp      , 0x08(%rdi)   #save frame pointer
  17.122 -    movq    0x20(%rdi), %rsp         #restore stack pointer
  17.123 -    movq    0x18(%rdi), %rbp         #restore frame pointer
  17.124 -    movq    $_VMSMasterEnv, %rcx
  17.125 -    movq        (%rcx), %rcx         #_VMSMasterEnv is pointer to struct
  17.126 -    movq    0x00(%rcx), %rax         #get CoreCtlr return pt
  17.127 -    movl    $0x0      , 0x100(%rcx)  #release lock
  17.128 -    jmp     *%rax                    #jmp to CoreCtlr
  17.129 -MasterReturn:
  17.130 -    ret
  17.131 -
  17.132 -
  17.133 -/*Switch to terminateCoreCtlr
  17.134 - *This is called by endOSThreadFn, which is the top-level function given
  17.135 - * to a shutdown slave.  When such a slave gets switched to, by the core
  17.136 - * controller, it runs the top-level function, which calls this, which
  17.137 - * then calls terminateCoreCtlr, which ends the pthread.  Note, when get
  17.138 - * here, stack is already set up for switchSlv and Slv ptr is in %rdi.
  17.139 - *Do not save registers of Slv because this function will never return
  17.140 - *
  17.141 - * SlaveVP  offsets:
  17.142 - * 0x00  stackPtr
  17.143 - * 0x08 framePtr
  17.144 - * 0x10 resumeInstrPtr
  17.145 - * 0x18 coreCtlrFramePtr
  17.146 - * 0x20 coreCtlrStackPtr
  17.147 - *
  17.148 - * _VMSMasterEnv  offsets:
  17.149 - * 0x00 coreCtlrReturnPt
  17.150 - * 0x100 masterLock
  17.151 - */
  17.152 -.globl asmTerminateCoreCtlr
  17.153 -asmTerminateCoreCtlr:                #SlaveVP ptr is in %rdi
  17.154 -    movq    0x20(%rdi), %rsp         #restore stack pointer
  17.155 -    movq    0x18(%rdi), %rbp         #restore frame pointer
  17.156 -    movq    $terminateCoreCtlr, %rax
  17.157 -    jmp     *%rax                    #jmp to fn that ends the pthread
  17.158 -
  17.159 -
  17.160 -/*
  17.161 - * This one for the sequential version is special. It discards the current stack
  17.162 - * and returns directly from the coreCtlr after VMS_WL__dissipate_slaveVP was called
  17.163 - */
  17.164 -.globl asmTerminateCoreCtlrSeq
  17.165 -asmTerminateCoreCtlrSeq:
  17.166 -    #SlaveVP in %rdi
  17.167 -    movq    0x20(%rdi), %rsp         #restore stack pointer
  17.168 -    movq    0x18(%rdi), %rbp         #restore frame pointer
  17.169 -    #argument is in %rdi
  17.170 -    call    VMS_int__dissipate_slaveVP
  17.171 -    movq    %rbp      , %rsp        #goto the coreCtlrs stack
  17.172 -    pop     %rbp        #restore the old framepointer
  17.173 -    ret                 #return from core controller
  17.174 -    
  17.175 -
  17.176 -//Takes the return addr off the stack and saves into the loc pointed to by
  17.177 -// by the parameter passed in via rdi.  Return addr is at 0x8(%rbp) for 64bit
  17.178 -.globl VMS_int__save_return_into_ptd_to_loc_then_do_ret
  17.179 -VMS_int__save_return_into_ptd_to_loc_then_do_ret:
  17.180 -    movq 0x08(%rbp),   %rax  #get ret address, rbp is the same as in the calling function
  17.181 -    movq      %rax,   (%rdi) #write ret addr into addr passed as param field
  17.182 -    ret
  17.183 -
  17.184 -
  17.185 -//Assembly code changes the return addr on the stack to the one
  17.186 -// pointed to by the parameter, then returns. Stack's return addr is at 0x8(%rbp)
  17.187 -.globl VMS_int__return_to_addr_in_ptd_to_loc
  17.188 -VMS_int__return_to_addr_in_ptd_to_loc:
  17.189 -    movq   (%rdi),     %rax  #get return addr from addr passed as param
  17.190 -    movq    %rax, 0x08(%rbp) #write return addr to the stack of the caller
  17.191 -    ret
  17.192 -

    18.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    18.2 +++ b/PR.h	Wed Sep 19 23:12:44 2012 -0700
    18.3 @@ -0,0 +1,442 @@
    18.4 +/*
    18.5 + *  Copyright 2009 OpenSourceStewardshipFoundation.org
    18.6 + *  Licensed under GNU General Public License version 2
    18.7 + *
    18.8 + * Author: seanhalle@yahoo.com
    18.9 + * 
   18.10 + */
   18.11 +
   18.12 +#ifndef _PR_H
   18.13 +#define	_PR_H
   18.14 +#define _GNU_SOURCE
   18.15 +
   18.16 +#include "DynArray/DynArray.h"
   18.17 +#include "Hash_impl/PrivateHash.h"
   18.18 +#include "Histogram/Histogram.h"
   18.19 +#include "Queue_impl/PrivateQueue.h"
   18.20 +
   18.21 +#include "PR_primitive_data_types.h"
   18.22 +#include "Services_Offered_by_PR/Memory_Handling/vmalloc.h"
   18.23 +
   18.24 +#include <pthread.h>
   18.25 +#include <sys/time.h>
   18.26 +
   18.27 +//=================  Defines: included from separate files  =================
   18.28 +//
   18.29 +// Note: ALL defines are in other files, none are in here
   18.30 +//
   18.31 +#include "Defines/PR_defs.h"
   18.32 +
   18.33 +
   18.34 +//================================ Typedefs =================================
   18.35 +//
   18.36 +typedef unsigned long long    TSCount;
   18.37 +
   18.38 +typedef struct _AnimSlot     AnimSlot;
   18.39 +typedef struct _PRReqst      PRReqst;
   18.40 +typedef struct _SlaveVP       SlaveVP;
   18.41 +typedef struct _MasterVP      MasterVP;
   18.42 +typedef struct _IntervalProbe IntervalProbe;
   18.43 +
   18.44 +
   18.45 +typedef SlaveVP *(*SlaveAssigner)  ( void *, AnimSlot*); //semEnv, slot for HW info
   18.46 +typedef void     (*RequestHandler) ( SlaveVP *, void * ); //prWReqst, semEnv
   18.47 +typedef void     (*TopLevelFnPtr)  ( void *, SlaveVP * ); //initData, animSlv
   18.48 +typedef void       TopLevelFn      ( void *, SlaveVP * ); //initData, animSlv
   18.49 +typedef void     (*ResumeSlvFnPtr) ( SlaveVP *, void * );
   18.50 +      //=========== MEASUREMENT STUFF ==========
   18.51 +        MEAS__Insert_Counter_Handler
   18.52 +      //========================================
   18.53 +
   18.54 +//============================ HW Dependent Fns ================================
   18.55 +
   18.56 +#include "HW_Dependent_Primitives/PR__HW_measurement.h"
   18.57 +#include "HW_Dependent_Primitives/PR__primitives.h"
   18.58 +
   18.59 +
   18.60 +//============= Request Related ===========
   18.61 +//
   18.62 +
   18.63 +enum PRReqstType   //avoid starting enums at 0, for debug reasons
   18.64 + {
   18.65 +   semantic = 1,
   18.66 +   createReq,
   18.67 +   dissipate,
   18.68 +   PRSemantic      //goes with PRSemReqst below
   18.69 + };
   18.70 +
   18.71 +struct _PRReqst
   18.72 + {
   18.73 +   enum PRReqstType  reqType;//used for dissipate and in future for IO requests
   18.74 +   void              *semReqData;
   18.75 +
   18.76 +   PRReqst *nextReqst;
   18.77 + };
   18.78 +//PRReqst
   18.79 +
   18.80 +enum PRSemReqstType   //These are equivalent to semantic requests, but for
   18.81 + {                     // PR's services available directly to app, like OS
   18.82 +   make_probe = 1,    // and probe services -- like a PR-wide built-in lang
   18.83 +   throw_excp,
   18.84 +   openFile,
   18.85 +   otherIO
   18.86 + };
   18.87 +
   18.88 +typedef struct
   18.89 + { enum PRSemReqstType reqType;
   18.90 +   SlaveVP             *requestingSlv;
   18.91 +   char                *nameStr;  //for create probe
   18.92 +   char                *msgStr;   //for exception
   18.93 +   void                *exceptionData;
   18.94 + }
   18.95 + PRSemReq;
   18.96 +
   18.97 +
   18.98 +//====================  Core data structures  ===================
   18.99 +
  18.100 +typedef struct
  18.101 + {
  18.102 +   //for future expansion
  18.103 + }
  18.104 +SlotPerfInfo;
  18.105 +
  18.106 +struct _AnimSlot
  18.107 + {
  18.108 +   int           workIsDone;
  18.109 +   int           needsSlaveAssigned;
  18.110 +   SlaveVP      *slaveAssignedToSlot;
  18.111 +   
  18.112 +   int           slotIdx;  //needed by Holistic Model's data gathering
  18.113 +   int           coreSlotIsOn;
  18.114 +   SlotPerfInfo *perfInfo; //used by assigner to pick best slave for core
  18.115 + };
  18.116 +//AnimSlot
  18.117 +
  18.118 +enum VPtype 
  18.119 + { TaskSlotSlv = 1,//Slave tied to an anim slot, only animates tasks
  18.120 +   TaskExtraSlv,   //When a suspended task ends, the slave becomes this
  18.121 +   PersistentSlv,  //the VP is explicitly seen in the app code, or task suspends
  18.122 +   Slave, //to be removed
  18.123 +   Master,
  18.124 +   Shutdown,
  18.125 +   Idle
  18.126 + };
  18.127 + 
  18.128 +/*This structure embodies the state of a slaveVP.  It is reused for masterVP
  18.129 + * and shutdownVPs.
  18.130 + */
  18.131 +struct _SlaveVP
  18.132 + {    //The offsets of these fields are hard-coded into assembly
  18.133 +   void       *stackPtr;         //save the core's stack ptr when suspend
  18.134 +   void       *framePtr;         //save core's frame ptr when suspend
  18.135 +   void       *resumeInstrPtr;   //save core's program-counter when suspend
  18.136 +   void       *coreCtlrFramePtr; //restore before jmp back to core controller
  18.137 +   void       *coreCtlrStackPtr; //restore before jmp back to core controller
  18.138 +   
  18.139 +      //============ below this, no fields are used in asm =============
  18.140 +   
  18.141 +   int         slaveID;       //each slave given a globally unique ID
  18.142 +   int         coreAnimatedBy; 
  18.143 +   void       *startOfStack;  //used to free, and to point slave to Fn
  18.144 +   enum VPtype typeOfVP;      //Slave vs Master vs Shutdown..
  18.145 +   int         assignCount;   //Each assign is for one work-unit, so IDs it
  18.146 +      //note, a scheduling decision is uniquely identified by the triple:
  18.147 +      // <slaveID, coreAnimatedBy, assignCount> -- used in record & replay
  18.148 +   
  18.149 +      //for comm -- between master and coreCtlr & btwn wrapper lib and plugin
  18.150 +   AnimSlot   *animSlotAssignedTo;
  18.151 +   PRReqst   *request;      //wrapper lib puts in requests, plugin takes out
  18.152 +   void       *dataRetFromReq;//Return vals from plugin to Wrapper Lib
  18.153 +
  18.154 +      //For using Slave as carrier for data
  18.155 +   void       *semanticData;  //Lang saves lang-specific things in slave here
  18.156 +
  18.157 +        //=========== MEASUREMENT STUFF ==========
  18.158 +         MEAS__Insert_Meas_Fields_into_Slave;
  18.159 +         float64     createPtInSecs;  //time VP created, in seconds
  18.160 +        //========================================
  18.161 + };
  18.162 +//SlaveVP
  18.163 +
  18.164 + 
  18.165 +/* The one and only global variable, holds many odds and ends
  18.166 + */
  18.167 +typedef struct
  18.168 + {    //The offsets of these fields are hard-coded into assembly
  18.169 +   void            *coreCtlrReturnPt;    //offset to this field used in asm
  18.170 +   int8             falseSharePad1[256 - sizeof(void*)];
  18.171 +   int32            masterLock;          //offset to this field used in asm
  18.172 +   int8             falseSharePad2[256 - sizeof(int32)];
  18.173 +      //============ below this, no fields are used in asm =============
  18.174 +
  18.175 +      //Basic PR infrastructure
  18.176 +   SlaveVP        **masterVPs;
  18.177 +   AnimSlot      ***allAnimSlots;
  18.178 +   
  18.179 +      //plugin related
  18.180 +   PRSemEnv       **langlets;
  18.181 +   
  18.182 +      //Slave creation -- global count of slaves existing, across langs and processes
  18.183 +   int32            numSlavesCreated;  //used to give unique ID to processor
  18.184 +//no reasonable way to do fail-safe when have mult langlets and processes.. have to detect for each langlet separately
  18.185 +//   int32            numSlavesAlive;    //used to detect fail-safe shutdown
  18.186 +
  18.187 +      //Initialization related
  18.188 +   int32            setupComplete;      //use while starting up coreCtlr
  18.189 +
  18.190 +      //Memory management related
  18.191 +   MallocArrays    *freeLists;
  18.192 +   int32            amtOfOutstandingMem;//total currently allocated
  18.193 +
  18.194 +      //Random number seeds -- random nums used in various places  
  18.195 +   uint32_t seed1;
  18.196 +   uint32_t seed2;
  18.197 +
  18.198 +      //=========== MEASUREMENT STUFF =============
  18.199 +       IntervalProbe   **intervalProbes;
  18.200 +       PtrToPrivDynArray *dynIntervalProbesInfo;
  18.201 +       HashTable        *probeNameHashTbl;
  18.202 +       int32             masterCreateProbeID;
  18.203 +       float64           createPtInSecs; //real-clock time PR initialized
  18.204 +       Histogram       **measHists;
  18.205 +       PtrToPrivDynArray *measHistsInfo;
  18.206 +       MEAS__Insert_Susp_Meas_Fields_into_MasterEnv;
  18.207 +       MEAS__Insert_Master_Meas_Fields_into_MasterEnv;
  18.208 +       MEAS__Insert_Master_Lock_Meas_Fields_into_MasterEnv;
  18.209 +       MEAS__Insert_Malloc_Meas_Fields_into_MasterEnv;
  18.210 +       MEAS__Insert_Plugin_Meas_Fields_into_MasterEnv;
  18.211 +       MEAS__Insert_System_Meas_Fields_into_MasterEnv;
  18.212 +       MEAS__Insert_Counter_Meas_Fields_into_MasterEnv;
  18.213 +      //==========================================
  18.214 + }
  18.215 +MasterEnv;
  18.216 +
  18.217 +//=====================
  18.218 +typedef struct
  18.219 + { int32   langletID; //acts as index into array of langlets in master env
  18.220 +   void   *langletSemEnv;
  18.221 +   int32   langMagicNumber;
  18.222 +   SlaveAssigner    slaveAssigner;
  18.223 +   RequestHandler   requestHandler;
  18.224 +   EndTaskHandler   endTaskHandler;
  18.225 +   
  18.226 +      //Tack slaves created, separately for each langlet (in each process)
  18.227 +   int32            numSlavesCreated;  //gives ordering to processor creation
  18.228 +   int32            numSlavesAlive;    //used to detect fail-safe shutdown
  18.229 +   
  18.230 +      //when multi-lang, master polls sem env's to find one with work in it..
  18.231 +      // in single-lang case, flag ignored, master always asks lang for work
  18.232 +   int32   hasWork;    
  18.233 + }
  18.234 +PRSemEnv;
  18.235 +
  18.236 +//=====================  Top Processor level Data Strucs  ======================
  18.237 +typedef struct
  18.238 + { 
  18.239 +   
  18.240 + }
  18.241 +PRProcess;
  18.242 +/*This structure holds all the information PR needs to manage a program.  PR
  18.243 + * stores information about what percent of CPU time the program is getting, 
  18.244 + * 
  18.245 + */
  18.246 +typedef struct
  18.247 + { //void               *semEnv;
  18.248 +   //RequestHdlrFnPtr    requestHandler;
  18.249 +   //SlaveAssignerFnPtr  slaveAssigner;
  18.250 +   int32               numSlavesLive;
  18.251 +   void               *resultToReturn;
  18.252 +  
  18.253 +   SlaveVP        *seedSlv;   
  18.254 +   
  18.255 +      //These are used to coordinate within the main function..?
  18.256 +   bool32          executionIsComplete;
  18.257 +   pthread_mutex_t doneLock; //? not sure need these..?
  18.258 +   pthread_cond_t  doneCond;
  18.259 + }
  18.260 +PRProcess;
  18.261 +
  18.262 +
  18.263 +//=========================  Extra Stuff Data Strucs  =======================
  18.264 +typedef struct
  18.265 + {
  18.266 +
  18.267 + }
  18.268 +PRExcp; //exception
  18.269 +
  18.270 +//=======================  OS Thread related  ===============================
  18.271 +
  18.272 +void * coreController( void *paramsIn );  //standard PThreads fn prototype
  18.273 +void * coreCtlr_Seq( void *paramsIn );  //standard PThreads fn prototype
  18.274 +void animationMaster( void *initData, SlaveVP *masterVP );
  18.275 +
  18.276 +
  18.277 +typedef struct
  18.278 + {
  18.279 +   void           *endThdPt;
  18.280 +   unsigned int    coreNum;
  18.281 + }
  18.282 +ThdParams;
  18.283 +
  18.284 +//=============================  Global Vars ================================
  18.285 +
  18.286 +volatile MasterEnv      *_PRMasterEnv __align_to_cacheline__;
  18.287 +
  18.288 +   //these are global, but only used for startup and shutdown
  18.289 +pthread_t       coreCtlrThdHandles[ NUM_CORES ]; //pthread's virt-procr state
  18.290 +ThdParams      *coreCtlrThdParams [ NUM_CORES ];
  18.291 +
  18.292 +pthread_mutex_t suspendLock;
  18.293 +pthread_cond_t  suspendCond;
  18.294 +
  18.295 +//=========================  Function Prototypes  ===========================
  18.296 +/* MEANING OF   WL  PI  SS  int PROS
  18.297 + * These indicate which places the function is safe to use.  They stand for:
  18.298 + * 
  18.299 + * WL   Wrapper Library -- wrapper lib code should only use these
  18.300 + * PI   Plugin          -- plugin code should only use these
  18.301 + * SS   Startup and Shutdown -- designates these relate to startup & shutdown
  18.302 + * int  internal to PR -- should not be used in wrapper lib or plugin
  18.303 + * PROS means "OS functions for applications to use"
  18.304 + * 
  18.305 + * PR_int__ functions touch internal PR data structs and are only safe
  18.306 + *  to be used inside the master lock.  However, occasionally, they appear
  18.307 + * in wrapper-lib or plugin code.  In those cases, very careful analysis
  18.308 + * has been done to be sure no concurrency issues could arise.
  18.309 + * 
  18.310 + * PR_WL__ functions are all safe for use outside the master lock.
  18.311 + * 
  18.312 + * PROS are only safe for applications to use -- they're like a second
  18.313 + * language mixed in -- but they can't be used inside plugin code, and
  18.314 + * aren't meant for use in wrapper libraries, because they are themselves
  18.315 + * wrapper-library calls!
  18.316 + */
  18.317 +//========== Startup and shutdown ==========
  18.318 +void
  18.319 +PR__start();
  18.320 +
  18.321 +void
  18.322 +PR_SS__start_the_work_then_wait_until_done();
  18.323 +
  18.324 +SlaveVP* 
  18.325 +PR_SS__create_shutdown_slave();
  18.326 +
  18.327 +void
  18.328 +PR_SS__shutdown();
  18.329 +
  18.330 +void
  18.331 +PR_SS__cleanup_at_end_of_shutdown();
  18.332 +
  18.333 +void
  18.334 +PR_SS__register_langlets_semEnv( PRSemEnv *semEnv, int32 VSs_MAGIC_NUMBER, 
  18.335 +                              SlaveVP  *seedVP );
  18.336 +
  18.337 +
  18.338 +//==============    ===============
  18.339 +
  18.340 +inline SlaveVP *
  18.341 +PR_int__create_slaveVP( TopLevelFnPtr fnPtr, void *dataParam );
  18.342 +#define PR_PI__create_slaveVP PR_int__create_slaveVP
  18.343 +#define PR_WL__create_slaveVP PR_int__create_slaveVP
  18.344 +
  18.345 +   //Use this to create processor inside entry point & other places outside
  18.346 +   // the PR system boundary (IE, don't animate with a SlaveVP or MasterVP)
  18.347 +SlaveVP *
  18.348 +PR_ext__create_slaveVP( TopLevelFnPtr fnPtr, void *dataParam );
  18.349 +
  18.350 +inline SlaveVP *
  18.351 +PR_int__create_slaveVP_helper( SlaveVP *newSlv,       TopLevelFnPtr  fnPtr,
  18.352 +                                void      *dataParam, void           *stackLocs );
  18.353 +
  18.354 +inline void
  18.355 +PR_int__reset_slaveVP_to_TopLvlFn( SlaveVP *slaveVP, TopLevelFnPtr fnPtr,
  18.356 +                              void    *dataParam);
  18.357 +
  18.358 +inline void
  18.359 +PR_int__point_slaveVP_to_OneParamFn( SlaveVP *slaveVP, void *fnPtr,
  18.360 +                              void    *param);
  18.361 +
  18.362 +inline void
  18.363 +PR_int__point_slaveVP_to_TwoParamFn( SlaveVP *slaveVP, void *fnPtr,
  18.364 +                              void    *param1, void *param2);
  18.365 +
  18.366 +void
  18.367 +PR_int__dissipate_slaveVP( SlaveVP *slaveToDissipate );
  18.368 +#define PR_PI__dissipate_slaveVP PR_int__dissipate_slaveVP
  18.369 +//WL: dissipate a SlaveVP by sending a request
  18.370 +
  18.371 +void
  18.372 +PR_ext__dissipate_slaveVP( SlaveVP *slaveToDissipate );
  18.373 +
  18.374 +void
  18.375 +PR_int__throw_exception( char *msgStr, SlaveVP *reqstSlv, PRExcp *excpData );
  18.376 +#define PR_PI__throw_exception  PR_int__throw_exception
  18.377 +void
  18.378 +PR_WL__throw_exception( char *msgStr, SlaveVP *reqstSlv,  PRExcp *excpData );
  18.379 +#define PR_App__throw_exception PR_WL__throw_exception
  18.380 +
  18.381 +void *
  18.382 +PR_int__give_sem_env_for( SlaveVP *animSlv );
  18.383 +#define PR_PI__give_sem_env_for  PR_int__give_sem_env_for
  18.384 +#define PR_SS__give_sem_env_for  PR_int__give_sem_env_for
  18.385 +//No WL version -- not safe!  if use in WL, be sure data rd & wr is stable
  18.386 +
  18.387 +
  18.388 +inline void
  18.389 +PR_int__get_master_lock();
  18.390 +
  18.391 +#define PR_int__release_master_lock() _PRMasterEnv->masterLock = UNLOCKED
  18.392 +
  18.393 +inline uint32_t
  18.394 +PR_int__randomNumber();
  18.395 +
  18.396 +//==============  Request Related  ===============
  18.397 +
  18.398 +void
  18.399 +PR_int__suspend_slaveVP_and_send_req( SlaveVP *callingSlv );
  18.400 +
  18.401 +inline void
  18.402 +PR_WL__add_sem_request_in_mallocd_PRReqst( void *semReqData, SlaveVP *callingSlv );
  18.403 +
  18.404 +inline void
  18.405 +PR_WL__send_sem_request( void *semReqData, SlaveVP *callingSlv );
  18.406 +
  18.407 +void
  18.408 +PR_WL__send_create_slaveVP_req( void *semReqData, SlaveVP *reqstingSlv );
  18.409 +
  18.410 +void inline
  18.411 +PR_WL__send_dissipate_req( SlaveVP *prToDissipate );
  18.412 +
  18.413 +inline void
  18.414 +PR_WL__send_PRSem_request( void *semReqData, SlaveVP *callingSlv );
  18.415 +
  18.416 +PRReqst *
  18.417 +PR_PI__take_next_request_out_of( SlaveVP *slaveWithReq );
  18.418 +//#define PR_PI__take_next_request_out_of( slave ) slave->requests
  18.419 +
  18.420 +//inline void *
  18.421 +//PR_PI__take_sem_reqst_from( PRReqst *req );
  18.422 +#define PR_PI__take_sem_reqst_from( req ) req->semReqData
  18.423 +
  18.424 +void inline
  18.425 +PR_PI__handle_PRSemReq( PRReqst *req, SlaveVP *requestingSlv, void *semEnv,
  18.426 +                       ResumeSlvFnPtr resumeSlvFnPtr );
  18.427 +
  18.428 +//======================== MEASUREMENT ======================
  18.429 +uint64
  18.430 +PR_WL__give_num_plugin_cycles();
  18.431 +uint32
  18.432 +PR_WL__give_num_plugin_animations();
  18.433 +
  18.434 +
  18.435 +//========================= Utilities =======================
  18.436 +inline char *
  18.437 +PR_int__strDup( char *str );
  18.438 +
  18.439 +
  18.440 +//========================= Probes =======================
  18.441 +#include "Services_Offered_by_PR/Measurement_and_Stats/probes.h"
  18.442 +
  18.443 +//================================================
  18.444 +#endif	/* _PR_H */
  18.445 +

    19.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    19.2 +++ b/PR__PI.c	Wed Sep 19 23:12:44 2012 -0700
    19.3 @@ -0,0 +1,121 @@
    19.4 +/*
    19.5 + * Copyright 2010  OpenSourceStewardshipFoundation
    19.6 + *
    19.7 + * Licensed under BSD
    19.8 + */
    19.9 +
   19.10 +#include <stdio.h>
   19.11 +#include <stdlib.h>
   19.12 +#include <string.h>
   19.13 +#include <malloc.h>
   19.14 +#include <inttypes.h>
   19.15 +#include <sys/time.h>
   19.16 +
   19.17 +#include "PR.h"
   19.18 +
   19.19 +
   19.20 +/* MEANING OF   WL  PI  SS  int
   19.21 + * These indicate which places the function is safe to use.  They stand for:
   19.22 + * WL: Wrapper Library
   19.23 + * PI: Plugin 
   19.24 + * SS: Startup and Shutdown
   19.25 + * int: internal to the PR implementation
   19.26 + */
   19.27 +
   19.28 +//=========================  Local Declarations  ========================
   19.29 +void inline
   19.30 +handleMakeProbe( PRSemReq *semReq, void *semEnv, ResumeSlvFnPtr resumeFn );
   19.31 +
   19.32 +void inline
   19.33 +handleThrowException( PRSemReq *semReq, void *semEnv, ResumeSlvFnPtr resumeFn );
   19.34 +//=======================================================================
   19.35 +
   19.36 + 
   19.37 +PRReqst *
   19.38 +PR_PI__take_next_request_out_of( SlaveVP *slaveWithReq )
   19.39 + { PRReqst *req;
   19.40 +
   19.41 +   req = slaveWithReq->request;
   19.42 +   if( req == NULL ) return NULL;
   19.43 +
   19.44 +   slaveWithReq->request = slaveWithReq->request->nextReqst;
   19.45 +   return req;
   19.46 + }
   19.47 +
   19.48 + 
   19.49 +
   19.50 +/*May 2012
   19.51 + *CHANGED IMPL -- now a macro in header file
   19.52 + *
   19.53 + *Turn function into macro that just accesses the request field
   19.54 + *
   19.55 +inline void *
   19.56 +PR_PI__take_sem_reqst_from( PRReqst *req )
   19.57 + {
   19.58 +   return req->semReqData;
   19.59 + }
   19.60 +*/
   19.61 +
   19.62 +
   19.63 +/* This is for OS requests and PR infrastructure requests, such as to create
   19.64 + *  a probe -- a probe is inside the heart of PR-core, it's not part of any
   19.65 + *  language -- but it's also a semantic thing that's triggered from and used
   19.66 + *  in the application.. so it crosses abstractions..  so, need some special
   19.67 + *  pattern here for handling such requests.
   19.68 + * Doing this just like it were a second language sharing PR-core.
   19.69 + * 
   19.70 + * This is called from the language's request handler when it sees a request
   19.71 + *  of type PRSemReq
   19.72 + *
   19.73 + * TODO: Later change this, to give probes their own separate plugin & have
   19.74 + *  PR-core steer the request to appropriate plugin
   19.75 + * Do the same for OS calls -- look later at it..
   19.76 + */
   19.77 +void inline
   19.78 +PR_PI__handle_PRSemReq( PRReqst *req, SlaveVP *requestingSlv, void *semEnv,
   19.79 +                       ResumeSlvFnPtr resumeFn )
   19.80 + { PRSemReq *semReq;
   19.81 +
   19.82 +   semReq = PR_PI__take_sem_reqst_from(req);
   19.83 +   if( semReq == NULL ) return;
   19.84 +   switch( semReq->reqType )  //sem handlers are all in other file
   19.85 +    {
   19.86 +      case make_probe:      handleMakeProbe(   semReq, semEnv, resumeFn);
   19.87 +         break;
   19.88 +      case throw_excp:  handleThrowException(  semReq, semEnv, resumeFn);
   19.89 +         break;
   19.90 +    }
   19.91 + }
   19.92 +
   19.93 +/*
   19.94 + */
   19.95 +void inline
   19.96 +handleMakeProbe( PRSemReq *semReq, void *semEnv, ResumeSlvFnPtr resumeFn )
   19.97 + { IntervalProbe *newProbe;
   19.98 +
   19.99 +   newProbe          = PR_int__malloc( sizeof(IntervalProbe) );
  19.100 +   newProbe->nameStr = PR_int__strDup( semReq->nameStr );
  19.101 +   newProbe->hist    = NULL;
  19.102 +   newProbe->schedChoiceWasRecorded = FALSE;
  19.103 +
  19.104 +      //This runs in masterVP, so no race-condition worries
  19.105 +   newProbe->probeID =
  19.106 +            addToDynArray( newProbe, _PRMasterEnv->dynIntervalProbesInfo );
  19.107 +
  19.108 +   semReq->requestingSlv->dataRetFromReq = newProbe;
  19.109 +
  19.110 +   //This in inside PR, while resume_slaveVP fn is inside language, so pass
  19.111 +   // pointer from lang to here, then call it.
  19.112 +   (*resumeFn)( semReq->requestingSlv, semEnv );
  19.113 + }
  19.114 +
  19.115 +void inline
  19.116 +handleThrowException( PRSemReq *semReq, void *semEnv, ResumeSlvFnPtr resumeFn )
  19.117 + {
  19.118 +   PR_int__throw_exception(  semReq->msgStr, semReq->requestingSlv, semReq->exceptionData );
  19.119 +   
  19.120 +   (*resumeFn)( semReq->requestingSlv, semEnv );
  19.121 + }
  19.122 +
  19.123 +
  19.124 +

    20.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    20.2 +++ b/PR__WL.c	Wed Sep 19 23:12:44 2012 -0700
    20.3 @@ -0,0 +1,160 @@
    20.4 +/*
    20.5 + * Copyright 2010  OpenSourceStewardshipFoundation
    20.6 + *
    20.7 + * Licensed under BSD
    20.8 + */
    20.9 +
   20.10 +#include <stdio.h>
   20.11 +#include <stdlib.h>
   20.12 +#include <string.h>
   20.13 +#include <malloc.h>
   20.14 +#include <inttypes.h>
   20.15 +#include <sys/time.h>
   20.16 +
   20.17 +#include "PR.h"
   20.18 +
   20.19 +
   20.20 +/* MEANING OF   WL  PI  SS  int
   20.21 + * These indicate which places the function is safe to use.  They stand for:
   20.22 + * WL: Wrapper Library
   20.23 + * PI: Plugin 
   20.24 + * SS: Startup and Shutdown
   20.25 + * int: internal to the PR implementation
   20.26 + */
   20.27 +
   20.28 +
   20.29 +
   20.30 +/*For this implementation of PR, it may not make much sense to have the
   20.31 + * system of requests for creating a new processor done this way.. but over
   20.32 + * the scope of single-master, multi-master, mult-tasking, OS-implementing,
   20.33 + * distributed-memory, and so on, this gives PR implementation a chance to
   20.34 + * do stuff before suspend, in the SlaveVP, and in the Master before the plugin
   20.35 + * is called, as well as in the lang-lib before this is called, and in the
   20.36 + * plugin.  So, this gives both PR and language implementations a chance to
   20.37 + * intercept at various points and do order-dependent stuff.
   20.38 + *Having a standard PRNewPrReqData struc allows the language to create and
   20.39 + * free the struc, while PR knows how to get the newSlv if it wants it, and
   20.40 + * it lets the lang have lang-specific data related to creation transported
   20.41 + * to the plugin.
   20.42 + */
   20.43 +void
   20.44 +PR_WL__send_create_slaveVP_req( void *semReqData, SlaveVP *reqstingSlv )
   20.45 + { PRReqst req;
   20.46 +
   20.47 +   req.reqType          = createReq;
   20.48 +   req.semReqData       = semReqData;
   20.49 +   req.nextReqst        = reqstingSlv->request;
   20.50 +   reqstingSlv->request = &req;
   20.51 +
   20.52 +   PR_int__suspend_slaveVP_and_send_req( reqstingSlv );
   20.53 + }
   20.54 +
   20.55 +
   20.56 +/*
   20.57 + *This adds a request to dissipate, then suspends the processor so that the
   20.58 + * request handler will receive the request.  The request handler is what
   20.59 + * does the work of freeing memory and removing the processor from the
   20.60 + * semantic environment's data structures.
   20.61 + *The request handler also is what figures out when to shutdown the PR
   20.62 + * system -- which causes all the core controller threads to die, and returns from
   20.63 + * the call that started up PR to perform the work.
   20.64 + *
   20.65 + *This form is a bit misleading to understand if one is trying to figure out
   20.66 + * how PR works -- it looks like a normal function call, but inside it
   20.67 + * sends a request to the request handler and suspends the processor, which
   20.68 + * jumps out of the PR_WL__dissipate_slaveVP function, and out of all nestings
   20.69 + * above it, transferring the work of dissipating to the request handler,
   20.70 + * which then does the actual work -- causing the processor that animated
   20.71 + * the call of this function to disappear and the "hanging" state of this
   20.72 + * function to just poof into thin air -- the virtual processor's trace
   20.73 + * never returns from this call, but instead the virtual processor's trace
   20.74 + * gets suspended in this call and all the virt processor's state disap-
   20.75 + * pears -- making that suspend the last thing in the Slv's trace.
   20.76 + */
   20.77 +void
   20.78 +PR_WL__send_dissipate_req( SlaveVP *slaveToDissipate )
   20.79 + { PRReqst req;
   20.80 +
   20.81 +   req.reqType                = dissipate;
   20.82 +   req.nextReqst              = slaveToDissipate->request;
   20.83 +   slaveToDissipate->request = &req;
   20.84 +
   20.85 +   PR_int__suspend_slaveVP_and_send_req( slaveToDissipate );
   20.86 + }
   20.87 +
   20.88 +
   20.89 +
   20.90 +/*This call's name indicates that request is malloc'd -- so req handler
   20.91 + * has to free any extra requests tacked on before a send, using this.
   20.92 + *
   20.93 + * This inserts the semantic-layer's request data into standard PR carrier
   20.94 + * request data-struct that is mallocd.  The sem request doesn't need to
   20.95 + * be malloc'd if this is called inside the same call chain before the
   20.96 + * send of the last request is called.
   20.97 + *
   20.98 + *The request handler has to call PR_int__free_PRReq for any of these
   20.99 + */
  20.100 +inline void
  20.101 +PR_WL__add_sem_request_in_mallocd_PRReqst( void *semReqData,
  20.102 +                                          SlaveVP *callingSlv )
  20.103 + { PRReqst *req;
  20.104 +
  20.105 +   req = PR_int__malloc( sizeof(PRReqst) );
  20.106 +   req->reqType         = semantic;
  20.107 +   req->semReqData      = semReqData;
  20.108 +   req->nextReqst       = callingSlv->request;
  20.109 +   callingSlv->request = req;
  20.110 + }
  20.111 +
  20.112 +/*This inserts the semantic-layer's request data into standard PR carrier
  20.113 + * request data-struct is allocated on stack of this call & ptr to it sent
  20.114 + * to plugin
  20.115 + *Then it does suspend, to cause request to be sent.
  20.116 + */
  20.117 +inline void
  20.118 +PR_WL__send_sem_request( void *semReqData, SlaveVP *callingSlv )
  20.119 + { PRReqst req;
  20.120 +
  20.121 +   req.reqType         = semantic;
  20.122 +   req.semReqData      = semReqData;
  20.123 +   req.nextReqst       = callingSlv->request;
  20.124 +   callingSlv->request = &req;
  20.125 +   
  20.126 +   PR_int__suspend_slaveVP_and_send_req( callingSlv );
  20.127 + }
  20.128 +
  20.129 +
  20.130 +/*May 2012 Not sure what this is..  looks like old idea for PR semantic
  20.131 + * request
  20.132 + */
  20.133 +inline void
  20.134 +PR_WL__send_PRSem_request( void *semReqData, SlaveVP *callingSlv )
  20.135 + { PRReqst req;
  20.136 +
  20.137 +   req.reqType         = PRSemantic;
  20.138 +   req.semReqData      = semReqData;
  20.139 +   req.nextReqst       = callingSlv->request; //gab any other preceeding 
  20.140 +   callingSlv->request = &req;
  20.141 +
  20.142 +   PR_int__suspend_slaveVP_and_send_req( callingSlv );
  20.143 + }
  20.144 +
  20.145 +/*May 2012
  20.146 + *To throw exception from wrapper lib or application, first turn
  20.147 + * it into a request, then send the request
  20.148 + */
  20.149 +void
  20.150 +PR_WL__throw_exception( char *msgStr, SlaveVP *reqstSlv,  PRExcp *excpData )
  20.151 + { PRReqst req;
  20.152 +   PRSemReq semReq;
  20.153 +
  20.154 +   req.reqType         = PRSemantic;
  20.155 +   req.semReqData      = &semReq;
  20.156 +   req.nextReqst       = reqstSlv->request; //gab any other preceeding 
  20.157 +   reqstSlv->request   = &req;
  20.158 +
  20.159 +   semReq.msgStr        = msgStr;
  20.160 +   semReq.exceptionData = excpData;
  20.161 +   
  20.162 +   PR_int__suspend_slaveVP_and_send_req( reqstSlv );
  20.163 + }

    21.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    21.2 +++ b/PR__int.c	Wed Sep 19 23:12:44 2012 -0700
    21.3 @@ -0,0 +1,289 @@
    21.4 +/*
    21.5 + * Copyright 2010  OpenSourceStewardshipFoundation
    21.6 + *
    21.7 + * Licensed under BSD
    21.8 + */
    21.9 +
   21.10 +#include <stdio.h>
   21.11 +#include <stdlib.h>
   21.12 +#include <string.h>
   21.13 +#include <malloc.h>
   21.14 +#include <inttypes.h>
   21.15 +#include <sys/time.h>
   21.16 +
   21.17 +#include "PR.h"
   21.18 +
   21.19 +
   21.20 +/* MEANING OF   WL  PI  SS  int
   21.21 + * These indicate which places the function is safe to use.  They stand for:
   21.22 + * WL: Wrapper Library
   21.23 + * PI: Plugin 
   21.24 + * SS: Startup and Shutdown
   21.25 + * int: internal to the PR implementation
   21.26 + */
   21.27 +
   21.28 +
   21.29 +inline SlaveVP *
   21.30 +PR_int__create_slaveVP( TopLevelFnPtr fnPtr, void *dataParam )
   21.31 + { SlaveVP *newSlv;
   21.32 +   void      *stackLocs;
   21.33 +
   21.34 +   newSlv      = PR_int__malloc( sizeof(SlaveVP) );
   21.35 +   stackLocs   = PR_int__malloc( VIRT_PROCR_STACK_SIZE );
   21.36 +   if( stackLocs == 0 )
   21.37 +    { perror("PR_int__malloc stack"); exit(1); }
   21.38 +
   21.39 +   _PRMasterEnv->numSlavesAlive += 1;
   21.40 +
   21.41 +   return PR_int__create_slaveVP_helper( newSlv, fnPtr, dataParam, stackLocs );
   21.42 + }
   21.43 +
   21.44 +/* "ext" designates that it's for use outside the PR system -- should only
   21.45 + * be called from main thread or other thread -- never from code animated by
   21.46 + * a PR virtual processor.
   21.47 + */
   21.48 +inline SlaveVP *
   21.49 +PR_ext__create_slaveVP( TopLevelFnPtr fnPtr, void *dataParam )
   21.50 + { SlaveVP *newSlv;
   21.51 +   char      *stackLocs;
   21.52 +
   21.53 +   newSlv      = malloc( sizeof(SlaveVP) );
   21.54 +   stackLocs  = malloc( VIRT_PROCR_STACK_SIZE );
   21.55 +   if( stackLocs == 0 )
   21.56 +    { perror("malloc stack"); exit(1); }
   21.57 +
   21.58 +   _PRMasterEnv->numSlavesAlive += 1;
   21.59 +
   21.60 +   return PR_int__create_slaveVP_helper(newSlv, fnPtr, dataParam, stackLocs);
   21.61 + }
   21.62 +
   21.63 +
   21.64 +//===========================================================================
   21.65 +/*there is a label inside this function -- save the addr of this label in
   21.66 + * the callingSlv struc, as the pick-up point from which to start the next
   21.67 + * work-unit for that slave.  If turns out have to save registers, then
   21.68 + * save them in the slave struc too.  Then do assembly jump to the CoreCtlr's
   21.69 + * "done with work-unit" label.  The slave struc is in the request in the
   21.70 + * slave that animated the just-ended work-unit, so all the state is saved
   21.71 + * there, and will get passed along, inside the request handler, to the
   21.72 + * next work-unit for that slave.
   21.73 + */
   21.74 +void
   21.75 +PR_int__suspend_slaveVP_and_send_req( SlaveVP *animatingSlv )
   21.76 + { 
   21.77 +
   21.78 +      //This suspended Slv will get assigned by Master again at some
   21.79 +      // future point
   21.80 +
   21.81 +      //return ownership of the Slv and anim slot to Master virt pr
   21.82 +   animatingSlv->animSlotAssignedTo->workIsDone = TRUE;
   21.83 +
   21.84 +        HOLISTIC__Record_HwResponderInvocation_start;
   21.85 +         MEAS__Capture_Pre_Susp_Point;
   21.86 +      //This assembly function is a PR primitive that first saves the
   21.87 +      // stack and frame pointer, plus an addr inside this assembly code.
   21.88 +      //When core ctlr later gets this slave out of a sched slot, it
   21.89 +      // restores the stack and frame and then jumps to the addr.. that
   21.90 +      // jmp causes return from this function.
   21.91 +      //So, in effect, this function takes a variable amount of wall-clock
   21.92 +      // time to complete -- the amount of time is determined by the
   21.93 +      // Master, which makes sure the memory is in a consistent state first.
   21.94 +   switchToCoreCtlr(animatingSlv);
   21.95 +   flushRegisters();
   21.96 +         MEAS__Capture_Post_Susp_Point;
   21.97 +		 
   21.98 +   return;
   21.99 + }
  21.100 +
  21.101 +
  21.102 +/* "ext" designates that it's for use outside the PR system -- should only
  21.103 + * be called from main thread or other thread -- never from code animated by
  21.104 + * a SlaveVP, nor from a masterVP.
  21.105 + *
  21.106 + *Use this version to dissipate Slvs created outside the PR system.
  21.107 + */
  21.108 +void
  21.109 +PR_ext__dissipate_slaveVP( SlaveVP *slaveToDissipate )
  21.110 + {
  21.111 +   _PRMasterEnv->numSlavesAlive -= 1;
  21.112 +   if( _PRMasterEnv->numSlavesAlive == 0 )
  21.113 +    {    //no more work, so shutdown
  21.114 +      PR_SS__shutdown();  //note, creates shut-down slaves on each core
  21.115 +    }
  21.116 +
  21.117 +   //NOTE: dataParam was given to the processor, so should either have
  21.118 +      // been alloc'd with PR_int__malloc, or freed by the level above animSlv.
  21.119 +      //So, all that's left to free here is the stack and the SlaveVP struc
  21.120 +      // itself
  21.121 +      //Note, should not stack-allocate the data param -- no guarantee, in
  21.122 +      // general that creating processor will outlive ones it creates.
  21.123 +   free( slaveToDissipate->startOfStack );
  21.124 +   free( slaveToDissipate );
  21.125 + }
  21.126 +
  21.127 +
  21.128 +
  21.129 +/*This must be called by the request handler plugin -- it cannot be called
  21.130 + * from the semantic library "dissipate processor" function -- instead, the
  21.131 + * semantic layer has to generate a request, and the plug-in calls this
  21.132 + * function.
  21.133 + *The reason is that this frees the virtual processor's stack -- which is
  21.134 + * still in use inside semantic library calls!
  21.135 + *
  21.136 + *This frees or recycles all the state owned by and comprising the PR
  21.137 + * portion of the animating virtual procr.  The request handler must first
  21.138 + * free any semantic data created for the processor that didn't use the
  21.139 + * PR_malloc mechanism.  Then it calls this, which first asks the malloc
  21.140 + * system to disown any state that did use PR_malloc, and then frees the
  21.141 + * statck and the processor-struct itself.
  21.142 + *If the dissipated processor is the sole (remaining) owner of PR_int__malloc'd
  21.143 + * state, then that state gets freed (or sent to recycling) as a side-effect
  21.144 + * of dis-owning it.
  21.145 + */
  21.146 +void
  21.147 +PR_int__dissipate_slaveVP( SlaveVP *animatingSlv )
  21.148 + {
  21.149 +         DEBUG__printf2(dbgRqstHdlr, "PR int dissipate slaveID: %d, alive: %d",animatingSlv->slaveID, _PRMasterEnv->numSlavesAlive-1);
  21.150 +      //dis-own all locations owned by this processor, causing to be freed
  21.151 +      // any locations that it is (was) sole owner of
  21.152 +   _PRMasterEnv->numSlavesAlive -= 1;
  21.153 +   if( _PRMasterEnv->numSlavesAlive == 0 )
  21.154 +    {    //no more work, so shutdown
  21.155 +      PR_SS__shutdown();  //note, creates shut-down processor on each core
  21.156 +    }
  21.157 +
  21.158 +      //NOTE: dataParam was given to the processor, so should either have
  21.159 +      // been alloc'd with PR_int__malloc, or freed by the level above animSlv.
  21.160 +      //So, all that's left to free here is the stack and the SlaveVP struc
  21.161 +      // itself
  21.162 +      //Note, should not stack-allocate initial data -- no guarantee, in
  21.163 +      // general that creating processor will outlive ones it creates.
  21.164 +   PR_int__free( animatingSlv->startOfStack );
  21.165 +   PR_int__free( animatingSlv );
  21.166 + }
  21.167 +
  21.168 +/*Anticipating multi-tasking
  21.169 + */
  21.170 +void *
  21.171 +PR_int__give_sem_env_for( SlaveVP *animSlv )
  21.172 + {
  21.173 +   return _PRMasterEnv->semanticEnv;
  21.174 + }
  21.175 +
  21.176 +/*
  21.177 + *
  21.178 + */
  21.179 +inline SlaveVP *
  21.180 +PR_int__create_slaveVP_helper( SlaveVP *newSlv,    TopLevelFnPtr  fnPtr,
  21.181 +                     void    *dataParam, void          *stackLocs )
  21.182 + {
  21.183 +   newSlv->startOfStack = stackLocs;
  21.184 +   newSlv->slaveID      = _PRMasterEnv->numSlavesCreated++;
  21.185 +   newSlv->request     = NULL;
  21.186 +   newSlv->animSlotAssignedTo    = NULL;
  21.187 +   newSlv->typeOfVP     = Slave;
  21.188 +   newSlv->assignCount  = 0;
  21.189 +
  21.190 +   PR_int__reset_slaveVP_to_TopLvlFn( newSlv, fnPtr, dataParam );
  21.191 +           
  21.192 +   //============================= MEASUREMENT STUFF ========================
  21.193 +   #ifdef PROBES__TURN_ON_STATS_PROBES
  21.194 +   //TODO: make this TSCHiLow or generic equivalent
  21.195 +   //struct timeval timeStamp;
  21.196 +   //gettimeofday( &(timeStamp), NULL);
  21.197 +   //newSlv->createPtInSecs = timeStamp.tv_sec +(timeStamp.tv_usec/1000000.0) -
  21.198 +   //                                           _PRMasterEnv->createPtInSecs;
  21.199 +   #endif
  21.200 +   //========================================================================
  21.201 +
  21.202 +   return newSlv;
  21.203 + }
  21.204 +
  21.205 +
  21.206 +/*Later, improve this -- for now, just exits the application after printing
  21.207 + * the error message.
  21.208 + */
  21.209 +void
  21.210 +PR_int__throw_exception( char *msgStr, SlaveVP *reqstSlv, PRExcp *excpData )
  21.211 + {
  21.212 +   printf("%s",msgStr);
  21.213 +   fflush(stdin);
  21.214 +   exit(1);
  21.215 + }
  21.216 +
  21.217 +
  21.218 +inline char *
  21.219 +PR_int__strDup( char *str )
  21.220 + { char *retStr;
  21.221 +
  21.222 +   if( str == NULL ) return (char *)NULL;
  21.223 +   retStr = (char *)PR_int__malloc( strlen(str) + 1 );
  21.224 +   strcpy( retStr, str );
  21.225 +
  21.226 +   return (char *)retStr;
  21.227 + }
  21.228 +
  21.229 +
  21.230 +inline void
  21.231 +PR_int__backoff_for_TooLongToGetLock( int32 numTriesToGetLock );
  21.232 +
  21.233 +inline void
  21.234 +PR_int__get_master_lock()
  21.235 + { int32 *addrOfMasterLock;
  21.236 + 
  21.237 +   addrOfMasterLock = &(_PRMasterEnv->masterLock);
  21.238 +
  21.239 +   int numTriesToGetLock = 0;
  21.240 +   int gotLock = 0;
  21.241 +   
  21.242 +            MEAS__Capture_Pre_Master_Lock_Point;
  21.243 +
  21.244 +   while( !gotLock ) //keep going until get master lock
  21.245 +    { 
  21.246 +      numTriesToGetLock++;   //if too many, means too much contention
  21.247 +      if( numTriesToGetLock > NUM_TRIES_BEFORE_DO_BACKOFF )
  21.248 +       { PR_int__backoff_for_TooLongToGetLock( numTriesToGetLock );
  21.249 +       }
  21.250 +      if( numTriesToGetLock > MASTERLOCK_RETRIES_BEFORE_YIELD ) 
  21.251 +       { numTriesToGetLock = 0; 
  21.252 +         pthread_yield();
  21.253 +       }
  21.254 +   
  21.255 +         //try to get the lock
  21.256 +      gotLock = __sync_bool_compare_and_swap( addrOfMasterLock,
  21.257 +                                                         UNLOCKED, LOCKED );
  21.258 +    }
  21.259 +            MEAS__Capture_Post_Master_Lock_Point;
  21.260 + }
  21.261 +
  21.262 +/*Used by the backoff to pick a random amount of busy-wait.  Can't use the
  21.263 + * system rand because it takes much too long.
  21.264 + *Note, are passing pointers to the seeds, which are then modified
  21.265 + */
  21.266 +inline uint32_t
  21.267 +PR_int__randomNumber()
  21.268 + {
  21.269 +	_PRMasterEnv->seed1 = 36969 * (_PRMasterEnv->seed1 & 65535) + 
  21.270 +                          (_PRMasterEnv->seed1 >> 16);
  21.271 +	_PRMasterEnv->seed2 = 18000 * (_PRMasterEnv->seed2 & 65535) + 
  21.272 +                          (_PRMasterEnv->seed2 >> 16);
  21.273 +	return (_PRMasterEnv->seed1 << 16) + _PRMasterEnv->seed2;
  21.274 + }
  21.275 +
  21.276 +
  21.277 +/*Busy-waits for a random number of cycles -- chooses number of cycles 
  21.278 + * differently than for the no-work backoff
  21.279 + */
  21.280 +inline void
  21.281 +PR_int__backoff_for_TooLongToGetLock( int32 numTriesToGetLock )
  21.282 + { int32 i, waitIterations;
  21.283 +   volatile double fakeWorkVar; //busy-wait fake work
  21.284 +
  21.285 +   waitIterations = 
  21.286 +    PR_int__randomNumber()% (numTriesToGetLock * GET_LOCK_BACKOFF_WEIGHT);   
  21.287 +   //addToHist( wait_iterations, coreLoopThdParams->wait_iterations_hist );
  21.288 +   for( i = 0; i < waitIterations; i++ )
  21.289 +    { fakeWorkVar += (fakeWorkVar + 32.0) / 2.0; //busy-wait
  21.290 +    }
  21.291 + }
  21.292 +

    22.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    22.2 +++ b/PR__startup_and_shutdown.c	Wed Sep 19 23:12:44 2012 -0700
    22.3 @@ -0,0 +1,601 @@
    22.4 +/*
    22.5 + * Copyright 2010  OpenSourceStewardshipFoundation
    22.6 + *
    22.7 + * Licensed under BSD
    22.8 + */
    22.9 +
   22.10 +#include <stdio.h>
   22.11 +#include <stdlib.h>
   22.12 +#include <string.h>
   22.13 +#include <malloc.h>
   22.14 +#include <inttypes.h>
   22.15 +#include <sys/time.h>
   22.16 +#include <pthread.h>
   22.17 +
   22.18 +#include "PR.h"
   22.19 +
   22.20 +
   22.21 +#define thdAttrs NULL
   22.22 +
   22.23 +
   22.24 +/* MEANING OF   WL  PI  SS  int
   22.25 + * These indicate which places the function is safe to use.  They stand for:
   22.26 + * WL: Wrapper Library
   22.27 + * PI: Plugin 
   22.28 + * SS: Startup and Shutdown
   22.29 + * int: internal to the PR implementation
   22.30 + */
   22.31 +
   22.32 +
   22.33 +//===========================================================================
   22.34 +AnimSlot **
   22.35 +create_anim_slots( int32 coreSlotsAreOn );
   22.36 +
   22.37 +void
   22.38 +create_masterEnv();
   22.39 +
   22.40 +void
   22.41 +create_the_coreCtlr_OS_threads();
   22.42 +
   22.43 +MallocProlog *
   22.44 +create_free_list();
   22.45 +
   22.46 +void
   22.47 +endOSThreadFn( void *initData, SlaveVP *animatingSlv );
   22.48 +
   22.49 +
   22.50 +//===========================================================================
   22.51 +
   22.52 +/*Setup has two phases:
   22.53 + * 1) Semantic layer first calls init_PR, which creates masterEnv, and puts
   22.54 + *    the master Slv into the work-queue, ready for first "call"
   22.55 + * 2) Semantic layer then does its own init, which creates the seed virt
   22.56 + *    slave inside the semantic layer, ready to assign it when
   22.57 + *    asked by the first run of the animationMaster.
   22.58 + *
   22.59 + *This part is bit weird because PR really wants to be "always there", and
   22.60 + * have applications attach and detach..  for now, this PR is part of
   22.61 + * the app, so the PR system starts up as part of running the app.
   22.62 + *
   22.63 + *The semantic layer is isolated from the PR internals by making the
   22.64 + * semantic layer do setup to a state that it's ready with its
   22.65 + * initial Slvs, ready to assign them to slots when the animationMaster
   22.66 + * asks.  Without this pattern, the semantic layer's setup would
   22.67 + * have to modify slots directly to assign the initial virt-procrs, and put
   22.68 + * them into the readyToAnimateQ itself, breaking the isolation completely.
   22.69 + *
   22.70 + * 
   22.71 + *The semantic layer creates the initial Slv(s), and adds its
   22.72 + * own environment to masterEnv, and fills in the pointers to
   22.73 + * the requestHandler and slaveAssigner plug-in functions
   22.74 + */
   22.75 +
   22.76 +/*This allocates PR data structures, populates the master PRProc,
   22.77 + * and master environment, and returns the master environment to the semantic
   22.78 + * layer.
   22.79 + */
   22.80 +void
   22.81 +PR__start()
   22.82 + {
   22.83 +   #ifdef DEBUG__TURN_ON_SEQUENTIAL_MODE
   22.84 +      create_masterEnv();
   22.85 +      printf( "\n\n Running in SEQUENTIAL mode \n\n" );
   22.86 +   #else
   22.87 +      create_masterEnv();
   22.88 +      DEBUG__printf1(dbgInfra,"Offset of lock in masterEnv: %d ", (int32)offsetof(MasterEnv,masterLock) );
   22.89 +      create_the_coreCtlr_OS_threads();
   22.90 +   #endif
   22.91 + }
   22.92 +
   22.93 +/*This gets the process struct out of the seedVP, then gets the semEnv-holding
   22.94 + * struct out of that, then inserts the semantic env into that struct, using
   22.95 + * the magic number as the key to the sem env placement.  The master will 
   22.96 + * use the magic number from a request to retrieve the semantic env appropriate
   22.97 + * for the construct that made the request.
   22.98 + */
   22.99 +void
  22.100 +PR__register_langlets_semEnv( PRSemEnv *semEnv, int32 magicNumber, 
  22.101 +                              SlaveVP  *seedVP )
  22.102 + { PREnvHolder *envHolder;
  22.103 +   PRProcess   *process;
  22.104 +
  22.105 +   process   = seedVP->process;
  22.106 +   envHolder = process->semEnvHolder;
  22.107 +   
  22.108 +   insert( magicNumber, semEnv, envHolder );
  22.109 + }
  22.110 +
  22.111 +
  22.112 +/*TODO: finish implementing
  22.113 + *This function returns information about the version of PR, the language
  22.114 + * the program is being run in, its version, and information on the 
  22.115 + * hardware.
  22.116 + */
  22.117 +/*
  22.118 +char *
  22.119 +PR_App__give_environment_string()
  22.120 + {
  22.121 +   //--------------------------
  22.122 +    fprintf(output, "#\n# >> Build information <<\n");
  22.123 +    fprintf(output, "# GCC VERSION: %d.%d.%d\n",__GNUC__,__GNUC_MINOR__,__GNUC_PATCHLEVEL__);
  22.124 +    fprintf(output, "# Build Date: %s %s\n", __DATE__, __TIME__);
  22.125 +    
  22.126 +    fprintf(output, "#\n# >> Hardware information <<\n");
  22.127 +    fprintf(output, "# Hardware Architecture: ");
  22.128 +   #ifdef __x86_64
  22.129 +    fprintf(output, "x86_64");
  22.130 +   #endif //__x86_64
  22.131 +   #ifdef __i386
  22.132 +    fprintf(output, "x86");
  22.133 +   #endif //__i386
  22.134 +    fprintf(output, "\n");
  22.135 +    fprintf(output, "# Number of Cores: %d\n", NUM_CORES);
  22.136 +   //--------------------------
  22.137 +    
  22.138 +   //PR Plugins
  22.139 +    fprintf(output, "#\n# >> PR Plugins <<\n");
  22.140 +    fprintf(output, "# Language : ");
  22.141 +    fprintf(output, _LANG_NAME_);
  22.142 +    fprintf(output, "\n");
  22.143 +       //Meta info gets set by calls from the language during its init,
  22.144 +       // and info registered by calls from inside the application
  22.145 +    fprintf(output, "# Assigner: %s\n", _PRMasterEnv->metaInfo->assignerInfo);
  22.146 +
  22.147 +   //--------------------------
  22.148 +   //Application
  22.149 +    fprintf(output, "#\n# >> Application <<\n");
  22.150 +    fprintf(output, "# Name: %s\n", _PRMasterEnv->metaInfo->appInfo);
  22.151 +    fprintf(output, "# Data Set:\n%s\n",_PRMasterEnv->metaInfo->inputSet);
  22.152 +    
  22.153 +   //--------------------------
  22.154 + }
  22.155 + */
  22.156 + 
  22.157 +
  22.158 +/*A pointer to the startup-function for the language is given as the last
  22.159 + * argument to the call.  Use this to initialize a program in the language.
  22.160 + * This creates a data structure that encapsulates the bookkeeping info
  22.161 + * PR uses to track and schedule a program run.
  22.162 + */
  22.163 +PRProcess *
  22.164 +PR__spawn_program_on_data_in_Lang( TopLevelFnPtr seed_fn, void *data )
  22.165 + { PRProcess *newProcess;
  22.166 +   newProcess = malloc( sizeof(PRProcess) );
  22.167 +   
  22.168 +   newProcess->doneLock = PTHREAD_MUTEX_INITIALIZER;
  22.169 +   newProcess->doneCond = PTHREAD_COND_INITIALIZER;
  22.170 +   newProcess->executionIsComplete = FALSE;
  22.171 +   newProcess->numSlavesLive = 0;
  22.172 +   
  22.173 +   newProcess->dataForSeed = data;
  22.174 +   newProcess->seedFnPtr   = prog_seed_fn;
  22.175 +   
  22.176 +      //The language's spawn-process function fills in the plugin function-ptrs in
  22.177 +      // the PRProcess struct, gives the struct to PR, which then makes and
  22.178 +      // queues the seed SlaveVP, which starts processors made from the code being
  22.179 +      // animated.
  22.180 +    
  22.181 +   (*langInitFnPtr)( newProcess );  
  22.182 +   
  22.183 +   return newProcess;
  22.184 + }
  22.185 +
  22.186 +
  22.187 +/*When all SlaveVPs owned by the program-run associated to the process have
  22.188 + * dissipated, then return from this call.  There is no language to cleanup,
  22.189 + * and PR does not shutdown..  but the process bookkeeping structure,
  22.190 + * which is used by PR to track and schedule the program, is freed.
  22.191 + *The PRProcess structure is kept until this call collects the results from it,
  22.192 + * then freed.  If the process is not done yet when PR gets this
  22.193 + * call, then this call waits..  the challenge here is that this call comes from
  22.194 + * a live OS thread that's outside PR..  so, inside here, it waits on a 
  22.195 + * condition..  then it's a PR thread that signals this to wake up..
  22.196 + *First checks whether the process is done, if yes, calls the clean-up fn then
  22.197 + * returns the result extracted from the PRProcess struct.
  22.198 + *If process not done yet, then performs a wait (in a loop to be sure the
  22.199 + * wakeup is not spurious, which can happen).  PR registers the wait, and upon
  22.200 + * the process ending (last SlaveVP owned by it dissipates), then PR signals
  22.201 + * this to wakeup.  This then calls the cleanup fn and returns the result.
  22.202 + */
  22.203 +/*
  22.204 +void *
  22.205 +PR_App__give_results_when_done_for( PRProcess *process )
  22.206 + { void *result;
  22.207 +   
  22.208 +   pthread_mutex_lock( process->doneLock );
  22.209 +   while( !(process->executionIsComplete) )
  22.210 +    {
  22.211 +      pthread_cond_wait( process->doneCond,
  22.212 +                         process->doneLock );
  22.213 +    }
  22.214 +   pthread_mutex_unlock( process->doneLock );
  22.215 +   
  22.216 +   result = process->resultToReturn;
  22.217 +   
  22.218 +   PR_int__cleanup_process_after_done( process );
  22.219 +   free( process );  //was malloc'd above, so free it here
  22.220 +   
  22.221 +   return result;
  22.222 + }
  22.223 +*/
  22.224 +
  22.225 +/*Turns off the PR system, and frees all data associated with it.  Does this
  22.226 + * by creating shutdown SlaveVPs and inserting them into animation slots.
  22.227 + * Will probably have to wake up sleeping cores as part of this -- the fn that
  22.228 + * inserts the new SlaveVPs should handle the wakeup..
  22.229 + */
  22.230 +/*
  22.231 +void
  22.232 +PR_SS__shutdown(); //already defined -- look at it
  22.233 +
  22.234 +void
  22.235 +PR_App__shutdown()
  22.236 + {
  22.237 +   for( cores )
  22.238 +    { slave = PR_int__create_new_SlaveVP( endOSThreadFn, NULL );
  22.239 +      PR_int__insert_slave_onto_core( SlaveVP *slave, coreNum );
  22.240 +    }
  22.241 + }
  22.242 +*/
  22.243 +
  22.244 +/* PR_App__start_PR_running();
  22.245 +
  22.246 +   PRProcess matrixMultProcess;
  22.247 +   
  22.248 +   matrixMultProcess =
  22.249 +    PR_App__spawn_program_on_data_in_Lang( &prog_seed_fn, data, Vthread_lang );
  22.250 +   
  22.251 +   resMatrix = PR_App__give_results_when_done_for( matrixMultProcess );
  22.252 +   
  22.253 +   PR_App__shutdown();
  22.254 + */
  22.255 +
  22.256 +void
  22.257 +create_masterEnv()
  22.258 + { MasterEnv       *masterEnv;
  22.259 +   PRQueueStruc  **readyToAnimateQs;
  22.260 +   int              coreIdx;
  22.261 +   SlaveVP        **masterVPs;
  22.262 +   AnimSlot     ***allAnimSlots; //ptr to array of ptrs
  22.263 +
  22.264 +
  22.265 +      //Make the master env, which holds everything else
  22.266 +   _PRMasterEnv = malloc( sizeof(MasterEnv) );
  22.267 +
  22.268 +        //Very first thing put into the master env is the free-list, seeded
  22.269 +        // with a massive initial chunk of memory.
  22.270 +        //After this, all other mallocs are PR__malloc.
  22.271 +   _PRMasterEnv->freeLists        = PR_ext__create_free_list();
  22.272 +   
  22.273 +   
  22.274 +   //===================== Only PR__malloc after this ====================
  22.275 +   masterEnv     = (MasterEnv*)_PRMasterEnv;
  22.276 +   
  22.277 +      //Make a readyToAnimateQ for each core controller
  22.278 +   readyToAnimateQs = PR_int__malloc( NUM_CORES * sizeof(PRQueueStruc *) );
  22.279 +   masterVPs        = PR_int__malloc( NUM_CORES * sizeof(SlaveVP *) );
  22.280 +
  22.281 +      //One array for each core, several in array, core's masterVP scheds all
  22.282 +   allAnimSlots    = PR_int__malloc( NUM_CORES * sizeof(AnimSlot *) );
  22.283 +
  22.284 +   _PRMasterEnv->numSlavesAlive = 0;  //used to detect shut-down condition
  22.285 +
  22.286 +//========================================
  22.287 +   semEnv->shutdownInitiated = FALSE;
  22.288 +   semEnv->coreIsDone = PR_int__malloc( NUM_CORES * sizeof( bool32 ) );
  22.289 +   
  22.290 +      //For each animation slot, there is an idle slave, and an initial
  22.291 +      // slave assigned as the current-task-slave.  Create them here.
  22.292 +   SlaveVP *idleSlv, *slotTaskSlv;
  22.293 +   for( coreNum = 0; coreNum < NUM_CORES; coreNum++ )
  22.294 +    { semEnv->coreIsDone[coreNum] = FALSE; //use during shutdown
  22.295 +    
  22.296 +      for( slotNum = 0; slotNum < NUM_ANIM_SLOTS; ++slotNum )
  22.297 +       { idleSlv = VSs__create_slave_helper( &idle_fn, NULL, semEnv, 0);
  22.298 +         idleSlv->coreAnimatedBy                = coreNum;
  22.299 +         idleSlv->animSlotAssignedTo            =
  22.300 +                               _PRMasterEnv->allAnimSlots[coreNum][slotNum];
  22.301 +         semEnv->idleSlv[coreNum][slotNum] = idleSlv;
  22.302 +         
  22.303 +         slotTaskSlv = VSs__create_slave_helper( &idle_fn, NULL, semEnv, 0);
  22.304 +         slotTaskSlv->coreAnimatedBy            = coreNum;
  22.305 +         slotTaskSlv->animSlotAssignedTo        = 
  22.306 +                               _PRMasterEnv->allAnimSlots[coreNum][slotNum];
  22.307 +         
  22.308 +         semData                    = slotTaskSlv->semanticData;
  22.309 +         semData->needsTaskAssigned = TRUE;
  22.310 +         semData->slaveType         = SlotTaskSlv;
  22.311 +         semEnv->slotTaskSlvs[coreNum][slotNum] = slotTaskSlv;
  22.312 +       }
  22.313 +    }
  22.314 +
  22.315 +      //create the recycle queue where free task slaves are put after their task ends
  22.316 +   semEnv->freeTaskSlvRecycleQ  = makePRQ();
  22.317 +   
  22.318 +
  22.319 +   semEnv->numLiveExtraTaskSlvs   = 0;
  22.320 +   semEnv->numLiveThreadSlvs      = 0; //none existent yet.. "create process" creates the seeds  
  22.321 +//==================================================================
  22.322 +   
  22.323 +   _PRMasterEnv->numSlavesCreated = 0;  //used by create slave to set slave ID
  22.324 +   for( coreIdx = 0; coreIdx < NUM_CORES; coreIdx++ )
  22.325 +    {    
  22.326 +      readyToAnimateQs[ coreIdx ] = makePRQ();
  22.327 +      
  22.328 +         //Q: should give masterVP core-specific info as its init data?
  22.329 +      masterVPs[ coreIdx ] = PR_int__create_slaveVP( (TopLevelFnPtr)&animationMaster, (void*)masterEnv );
  22.330 +      masterVPs[ coreIdx ]->coreAnimatedBy = coreIdx;
  22.331 +      masterVPs[ coreIdx ]->typeOfVP = Master;
  22.332 +      allAnimSlots[ coreIdx ] = create_anim_slots( coreIdx ); //makes for one core
  22.333 +    }
  22.334 +   _PRMasterEnv->masterVPs        = masterVPs;
  22.335 +   _PRMasterEnv->masterLock       = UNLOCKED;
  22.336 +   _PRMasterEnv->seed1 = rand()%1000; // init random number generator
  22.337 +   _PRMasterEnv->seed2 = rand()%1000; // init random number generator
  22.338 +   _PRMasterEnv->allAnimSlots    = allAnimSlots;
  22.339 +   _PRMasterEnv->measHistsInfo = NULL; 
  22.340 +
  22.341 +   //============================= MEASUREMENT STUFF ========================
  22.342 +      
  22.343 +         MEAS__Make_Meas_Hists_for_Susp_Meas;
  22.344 +         MEAS__Make_Meas_Hists_for_Master_Meas;
  22.345 +         MEAS__Make_Meas_Hists_for_Master_Lock_Meas;
  22.346 +         MEAS__Make_Meas_Hists_for_Malloc_Meas;
  22.347 +         MEAS__Make_Meas_Hists_for_Plugin_Meas;
  22.348 +         MEAS__Make_Meas_Hists_for_Language;
  22.349 +
  22.350 +         PROBES__Create_Probe_Bookkeeping_Vars;
  22.351 +         
  22.352 +         HOLISTIC__Setup_Perf_Counters;
  22.353 +         
  22.354 +   //========================================================================
  22.355 + }
  22.356 +
  22.357 +AnimSlot **
  22.358 +create_anim_slots( int32 coreSlotsAreOn )
  22.359 + { AnimSlot  **animSlots;
  22.360 +   int i;
  22.361 +
  22.362 +   animSlots  = PR_int__malloc( NUM_ANIM_SLOTS * sizeof(AnimSlot *) );
  22.363 +
  22.364 +   for( i = 0; i < NUM_ANIM_SLOTS; i++ )
  22.365 +    {
  22.366 +      animSlots[i] = PR_int__malloc( sizeof(AnimSlot) );
  22.367 +
  22.368 +         //Set state to mean "handling requests done, slot needs filling"
  22.369 +      animSlots[i]->workIsDone         = FALSE;
  22.370 +      animSlots[i]->needsSlaveAssigned = TRUE;
  22.371 +      animSlots[i]->slotIdx            = i; //quick retrieval of slot pos
  22.372 +      animSlots[i]->coreSlotIsOn       = coreSlotsAreOn;
  22.373 +    }
  22.374 +   return animSlots;
  22.375 + }
  22.376 +
  22.377 +
  22.378 +void
  22.379 +freeAnimSlots( AnimSlot **animSlots )
  22.380 + { int i;
  22.381 +   for( i = 0; i < NUM_ANIM_SLOTS; i++ )
  22.382 +    {
  22.383 +      PR_int__free( animSlots[i] );
  22.384 +    }
  22.385 +   PR_int__free( animSlots );
  22.386 + }
  22.387 +
  22.388 +
  22.389 +void
  22.390 +create_the_coreCtlr_OS_threads()
  22.391 + {
  22.392 +   //========================================================================
  22.393 +   //                      Create the Threads
  22.394 +   int coreIdx, retCode;
  22.395 +
  22.396 +      //Need the threads to be created suspended, and wait for a signal
  22.397 +      // before proceeding -- gives time after creating to initialize other
  22.398 +      // stuff before the coreCtlrs set off.
  22.399 +   _PRMasterEnv->setupComplete = 0;
  22.400 +   
  22.401 +      //initialize the cond used to make the new threads wait and sync up
  22.402 +      //must do this before *creating* the threads..
  22.403 +   pthread_mutex_init( &suspendLock, NULL );
  22.404 +   pthread_cond_init( &suspendCond, NULL );
  22.405 +
  22.406 +      //Make the threads that animate the core controllers
  22.407 +   for( coreIdx=0; coreIdx < NUM_CORES; coreIdx++ )
  22.408 +    { coreCtlrThdParams[coreIdx]          = PR_int__malloc( sizeof(ThdParams) );
  22.409 +      coreCtlrThdParams[coreIdx]->coreNum = coreIdx;
  22.410 +
  22.411 +      retCode =
  22.412 +      pthread_create( &(coreCtlrThdHandles[coreIdx]),
  22.413 +                        thdAttrs,
  22.414 +                       &coreController,
  22.415 +               (void *)(coreCtlrThdParams[coreIdx]) );
  22.416 +      if(retCode){printf("ERROR creating thread: %d\n", retCode); exit(1);}
  22.417 +    }
  22.418 + }
  22.419 +
  22.420 +
  22.421 +/*This is what causes the PR system to initialize.. then waits for it to
  22.422 + * exit.
  22.423 + * 
  22.424 + *Wrapper lib layer calls this when it wants the system to start running..
  22.425 + */
  22.426 +/*
  22.427 +void
  22.428 +PR_SS__start_the_work_then_wait_until_done()
  22.429 + { 
  22.430 +#ifdef DEBUG__TURN_ON_SEQUENTIAL_MODE
  22.431 +   //Only difference between version with an OS thread pinned to each core and
  22.432 +   // the sequential version of PR is PR__init_Seq, this, and coreCtlr_Seq.
  22.433 +   //
  22.434 +         //Instead of un-suspending threads, just call the one and only
  22.435 +         // core ctlr (sequential version), in the main thread.
  22.436 +      coreCtlr_Seq( NULL );
  22.437 +      flushRegisters();
  22.438 +#else
  22.439 +   int coreIdx;
  22.440 +      //Start the core controllers running
  22.441 +   
  22.442 +      //tell the core controller threads that setup is complete
  22.443 +      //get lock, to lock out any threads still starting up -- they'll see
  22.444 +      // that setupComplete is true before entering while loop, and so never
  22.445 +      // wait on the condition
  22.446 +   pthread_mutex_lock(     &suspendLock );
  22.447 +   _PRMasterEnv->setupComplete = 1;
  22.448 +   pthread_mutex_unlock(   &suspendLock );
  22.449 +   pthread_cond_broadcast( &suspendCond );
  22.450 +   
  22.451 +   
  22.452 +      //wait for all to complete
  22.453 +   for( coreIdx=0; coreIdx < NUM_CORES; coreIdx++ )
  22.454 +    {
  22.455 +      pthread_join( coreCtlrThdHandles[coreIdx], NULL );
  22.456 +    }
  22.457 +   
  22.458 +      //NOTE: do not clean up PR env here -- semantic layer has to have
  22.459 +      // a chance to clean up its environment first, then do a call to free
  22.460 +      // the Master env and rest of PR locations
  22.461 +#endif
  22.462 + }
  22.463 +*/
  22.464 +
  22.465 +SlaveVP* PR_SS__create_shutdown_slave(){
  22.466 +    SlaveVP* shutdownVP;
  22.467 +    
  22.468 +    shutdownVP = PR_int__create_slaveVP( &endOSThreadFn, NULL );
  22.469 +    shutdownVP->typeOfVP = Shutdown;
  22.470 +    
  22.471 +    return shutdownVP;
  22.472 +}
  22.473 +
  22.474 +//TODO: look at architecting cleanest separation between request handler
  22.475 +// and animation master, for dissipate, create, shutdown, and other non-semantic
  22.476 +// requests.  Issue is chain: one removes requests from AppSlv, one dispatches
  22.477 +// on type of request, and one handles each type..  but some types require
  22.478 +// action from both request handler and animation master -- maybe just give the
  22.479 +// request handler calls like:  PR__handle_X_request_type
  22.480 +
  22.481 +
  22.482 +/*This is called by the semantic layer's request handler when it decides its
  22.483 + * time to shut down the PR system.  Calling this causes the core controller OS
  22.484 + * threads to exit, which unblocks the entry-point function that started up
  22.485 + * PR, and allows it to grab the result and return to the original single-
  22.486 + * threaded application.
  22.487 + * 
  22.488 + *The _PRMasterEnv is needed by this shut down function, so the create-seed-
  22.489 + * and-wait function has to free a bunch of stuff after it detects the
  22.490 + * threads have all died: the masterEnv, the thread-related locations,
  22.491 + * masterVP any AppSlvs that might still be allocated and sitting in the
  22.492 + * semantic environment, or have been orphaned in the _PRWorkQ.
  22.493 + * 
  22.494 + *NOTE: the semantic plug-in is expected to use PR__malloc to get all the
  22.495 + * locations it needs, and give ownership to masterVP.  Then, they will be
  22.496 + * automatically freed.
  22.497 + *
  22.498 + *In here,create one core-loop shut-down processor for each core controller and put
  22.499 + * them all directly into the readyToAnimateQ.
  22.500 + *Note, this function can ONLY be called after the semantic environment no
  22.501 + * longer cares if AppSlvs get animated after the point this is called.  In
  22.502 + * other words, this can be used as an abort, or else it should only be
  22.503 + * called when all AppSlvs have finished dissipate requests -- only at that
  22.504 + * point is it sure that all results have completed.
  22.505 + */
  22.506 +void
  22.507 +PR_SS__shutdown()
  22.508 + { int32       coreIdx;
  22.509 +   SlaveVP    *shutDownSlv;
  22.510 +   AnimSlot **animSlots;
  22.511 +      //create the shutdown processors, one for each core controller -- put them
  22.512 +      // directly into the Q -- each core will die when gets one
  22.513 +   for( coreIdx = 0; coreIdx < NUM_CORES; coreIdx++ )
  22.514 +    {    //Note, this is running in the master
  22.515 +      shutDownSlv = PR_SS__create_shutdown_slave();
  22.516 +         //last slave has dissipated, so no more in slots, so write
  22.517 +         // shut down slave into first animulng slot.
  22.518 +      animSlots = _PRMasterEnv->allAnimSlots[ coreIdx ];
  22.519 +      animSlots[0]->slaveAssignedToSlot = shutDownSlv;
  22.520 +      animSlots[0]->needsSlaveAssigned = FALSE;
  22.521 +      shutDownSlv->coreAnimatedBy = coreIdx;
  22.522 +      shutDownSlv->animSlotAssignedTo = animSlots[ 0 ];
  22.523 +    }
  22.524 + }
  22.525 +
  22.526 +
  22.527 +/*Am trying to be cute, avoiding IF statement in coreCtlr that checks for
  22.528 + * a special shutdown slaveVP.  Ended up with extra-complex shutdown sequence.
  22.529 + *This function has the sole purpose of setting the stack and framePtr
  22.530 + * to the coreCtlr's stack and framePtr.. it does that then jumps to the
  22.531 + * core ctlr's shutdown point -- might be able to just call Pthread_exit
  22.532 + * from here, but am going back to the pthread's stack and setting everything
  22.533 + * up just as if it never jumped out, before calling pthread_exit.
  22.534 + *The end-point of core ctlr will free the stack and so forth of the
  22.535 + * processor that animates this function, (this fn is transfering the
  22.536 + * animator of the AppSlv that is in turn animating this function over
  22.537 + * to core controller function -- note that this slices out a level of virtual
  22.538 + * processors).
  22.539 + */
  22.540 +void
  22.541 +endOSThreadFn( void *initData, SlaveVP *animatingSlv )
  22.542 + { 
  22.543 +   #ifdef DEBUG__TURN_ON_SEQUENTIAL_MODE
  22.544 +    asmTerminateCoreCtlrSeq(animatingSlv);
  22.545 +   #else
  22.546 +    asmTerminateCoreCtlr(animatingSlv);
  22.547 +   #endif
  22.548 + }
  22.549 +
  22.550 +
  22.551 +/*This is called from the startup & shutdown
  22.552 + */
  22.553 +void
  22.554 +PR_SS__cleanup_at_end_of_shutdown()
  22.555 + { 
  22.556 +      //Before getting rid of everything, print out any measurements made
  22.557 +   if( _PRMasterEnv->measHistsInfo != NULL )
  22.558 +    { forAllInDynArrayDo( _PRMasterEnv->measHistsInfo, (DynArrayFnPtr)&printHist );
  22.559 +      forAllInDynArrayDo( _PRMasterEnv->measHistsInfo, (DynArrayFnPtr)&saveHistToFile);
  22.560 +      forAllInDynArrayDo( _PRMasterEnv->measHistsInfo, (DynArrayFnPtr)&freeHist );
  22.561 +    }
  22.562 +   
  22.563 +   MEAS__Print_Hists_for_Susp_Meas;
  22.564 +   MEAS__Print_Hists_for_Master_Meas;
  22.565 +   MEAS__Print_Hists_for_Master_Lock_Meas;
  22.566 +   MEAS__Print_Hists_for_Malloc_Meas;
  22.567 +   MEAS__Print_Hists_for_Plugin_Meas;
  22.568 +   
  22.569 +
  22.570 +      //All the environment data has been allocated with PR__malloc, so just
  22.571 +      // free its internal big-chunk and all inside it disappear.
  22.572 +/*
  22.573 +   readyToAnimateQs = _PRMasterEnv->readyToAnimateQs;
  22.574 +   masterVPs        = _PRMasterEnv->masterVPs;
  22.575 +   allAnimSlots    = _PRMasterEnv->allAnimSlots;
  22.576 +   
  22.577 +   for( coreIdx = 0; coreIdx < NUM_CORES; coreIdx++ )
  22.578 +    {
  22.579 +      freePRQ( readyToAnimateQs[ coreIdx ] );
  22.580 +         //master Slvs were created external to PR, so use external free
  22.581 +      PR_int__dissipate_slaveVP( masterVPs[ coreIdx ] );
  22.582 +      
  22.583 +      freeAnimSlots( allAnimSlots[ coreIdx ] );
  22.584 +    }
  22.585 +   
  22.586 +   PR_int__free( _PRMasterEnv->readyToAnimateQs );
  22.587 +   PR_int__free( _PRMasterEnv->masterVPs );
  22.588 +   PR_int__free( _PRMasterEnv->allAnimSlots );
  22.589 +   
  22.590 +   //============================= MEASUREMENT STUFF ========================
  22.591 +   #ifdef PROBES__TURN_ON_STATS_PROBES
  22.592 +   freeDynArrayDeep( _PRMasterEnv->dynIntervalProbesInfo, &PR_WL__free_probe);
  22.593 +   #endif
  22.594 +   //========================================================================
  22.595 +*/
  22.596 +      //These are the only two that use system free 
  22.597 +   PR_ext__free_free_list( _PRMasterEnv->freeLists );
  22.598 +   free( (void *)_PRMasterEnv );
  22.599 + }
  22.600 +
  22.601 +
  22.602 +//================================
  22.603 +
  22.604 +