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

annotate VMS.c @ 167:981acd1db6af

find changesets by author, revision, files, or words in the commit message
Separate UCC recording from VMS core and put it into SSR plugin
author Nina Engelhardt
date Mon, 05 Dec 2011 18:59:48 +0100
parents aefd87f9d12f
children 3bd35fc83c61
rev   line source
Me@0 1 /*
Me@38 2 * Copyright 2010 OpenSourceStewardshipFoundation
Me@0 3 *
Me@0 4 * Licensed under BSD
Me@0 5 */
Me@0 6
Me@0 7 #include <stdio.h>
Me@0 8 #include <stdlib.h>
Me@50 9 #include <string.h>
Me@0 10 #include <malloc.h>
msach@76 11 #include <inttypes.h>
Me@50 12 #include <sys/time.h>
Me@0 13
Me@0 14 #include "VMS.h"
msach@77 15 #include "ProcrContext.h"
Me@0 16 #include "Queue_impl/BlockingQueue.h"
Me@38 17 #include "Histogram/Histogram.h"
Me@0 18
Nina@109 19 #include <unistd.h>
Nina@109 20 #include <fcntl.h>
Nina@109 21 #include <linux/types.h>
engelhardt@108 22 #include <linux/perf_event.h>
Nina@109 23 #include <errno.h>
Nina@109 24 #include <sys/syscall.h>
Nina@109 25 #include <linux/prctl.h>
Nina@109 26
Me@0 27
Me@26 28 #define thdAttrs NULL
Me@26 29
Me@22 30 //===========================================================================
Me@22 31 void
Me@22 32 shutdownFn( void *dummy, VirtProcr *dummy2 );
Me@22 33
Me@31 34 SchedSlot **
Me@31 35 create_sched_slots();
Me@22 36
Me@28 37 void
Me@28 38 create_masterEnv();
Me@28 39
Me@28 40 void
Me@28 41 create_the_coreLoop_OS_threads();
Me@28 42
Me@50 43 MallocProlog *
Me@50 44 create_free_list();
Me@50 45
Me@53 46 void
Me@53 47 endOSThreadFn( void *initData, VirtProcr *animatingPr );
Me@50 48
Me@26 49 pthread_mutex_t suspendLock = PTHREAD_MUTEX_INITIALIZER;
Me@26 50 pthread_cond_t suspend_cond = PTHREAD_COND_INITIALIZER;
Me@26 51
Me@22 52 //===========================================================================
Me@22 53
Me@0 54 /*Setup has two phases:
Me@0 55 * 1) Semantic layer first calls init_VMS, which creates masterEnv, and puts
Me@8 56 * the master virt procr into the work-queue, ready for first "call"
Me@8 57 * 2) Semantic layer then does its own init, which creates the seed virt
Me@8 58 * procr inside the semantic layer, ready to schedule it when
Me@0 59 * asked by the first run of the masterLoop.
Me@0 60 *
Me@0 61 *This part is bit weird because VMS really wants to be "always there", and
Me@0 62 * have applications attach and detach.. for now, this VMS is part of
Me@0 63 * the app, so the VMS system starts up as part of running the app.
Me@0 64 *
Me@8 65 *The semantic layer is isolated from the VMS internals by making the
Me@8 66 * semantic layer do setup to a state that it's ready with its
Me@8 67 * initial virt procrs, ready to schedule them to slots when the masterLoop
Me@0 68 * asks. Without this pattern, the semantic layer's setup would
Me@8 69 * have to modify slots directly to assign the initial virt-procrs, and put
Me@31 70 * them into the readyToAnimateQ itself, breaking the isolation completely.
Me@0 71 *
Me@0 72 *
Me@8 73 *The semantic layer creates the initial virt procr(s), and adds its
Me@8 74 * own environment to masterEnv, and fills in the pointers to
Me@0 75 * the requestHandler and slaveScheduler plug-in functions
Me@8 76 */
Me@8 77
Me@8 78 /*This allocates VMS data structures, populates the master VMSProc,
Me@0 79 * and master environment, and returns the master environment to the semantic
Me@0 80 * layer.
Me@0 81 */
Me@8 82 void
Me@8 83 VMS__init()
Me@28 84 {
Me@28 85 create_masterEnv();
Me@28 86 create_the_coreLoop_OS_threads();
Me@28 87 }
Me@28 88
msach@71 89 #ifdef SEQUENTIAL
msach@71 90
Me@28 91 /*To initialize the sequential version, just don't create the threads
Me@28 92 */
Me@28 93 void
Me@28 94 VMS__init_Seq()
Me@28 95 {
Me@28 96 create_masterEnv();
Me@28 97 }
Me@28 98
msach@71 99 #endif
msach@71 100
Me@28 101 void
Me@28 102 create_masterEnv()
Me@31 103 { MasterEnv *masterEnv;
Me@55 104 VMSQueueStruc **readyToAnimateQs;
Me@31 105 int coreIdx;
Me@31 106 VirtProcr **masterVPs;
Me@31 107 SchedSlot ***allSchedSlots; //ptr to array of ptrs
Me@53 108
Me@53 109
Me@31 110 //Make the master env, which holds everything else
Me@1 111 _VMSMasterEnv = malloc( sizeof(MasterEnv) );
Me@53 112
Me@53 113 //Very first thing put into the master env is the free-list, seeded
Me@53 114 // with a massive initial chunk of memory.
Me@53 115 //After this, all other mallocs are VMS__malloc.
Me@53 116 _VMSMasterEnv->freeListHead = VMS_ext__create_free_list();
Me@53 117
Me@65 118
Me@65 119 //============================= MEASUREMENT STUFF ========================
Me@65 120 #ifdef MEAS__TIME_MALLOC
msach@84 121 _VMSMasterEnv->mallocTimeHist = makeFixedBinHistExt( 100, 0, 100,
msach@79 122 "malloc_time_hist");
msach@84 123 _VMSMasterEnv->freeTimeHist = makeFixedBinHistExt( 80, 0, 100,
msach@79 124 "free_time_hist");
Me@65 125 #endif
Me@68 126 #ifdef MEAS__TIME_PLUGIN
msach@84 127 _VMSMasterEnv->reqHdlrLowTimeHist = makeFixedBinHistExt( 1000, 0, 100,
msach@79 128 "plugin_low_time_hist");
msach@84 129 _VMSMasterEnv->reqHdlrHighTimeHist = makeFixedBinHistExt( 1000, 0, 100,
msach@79 130 "plugin_high_time_hist");
Me@68 131 #endif
Me@65 132 //========================================================================
Me@65 133
Me@53 134 //===================== Only VMS__malloc after this ====================
msach@69 135 masterEnv = (MasterEnv*)_VMSMasterEnv;
Me@31 136
Me@31 137 //Make a readyToAnimateQ for each core loop
Me@55 138 readyToAnimateQs = VMS__malloc( NUM_CORES * sizeof(VMSQueueStruc *) );
Me@53 139 masterVPs = VMS__malloc( NUM_CORES * sizeof(VirtProcr *) );
Me@0 140
Me@31 141 //One array for each core, 3 in array, core's masterVP scheds all
Me@53 142 allSchedSlots = VMS__malloc( NUM_CORES * sizeof(SchedSlot *) );
Me@0 143
Me@53 144 _VMSMasterEnv->numProcrsCreated = 0; //used by create procr
Me@31 145 for( coreIdx = 0; coreIdx < NUM_CORES; coreIdx++ )
Me@53 146 {
Me@55 147 readyToAnimateQs[ coreIdx ] = makeVMSQ();
Me@31 148
Me@50 149 //Q: should give masterVP core-specific info as its init data?
msach@76 150 masterVPs[ coreIdx ] = VMS__create_procr( (VirtProcrFnPtr)&masterLoop, (void*)masterEnv );
Me@31 151 masterVPs[ coreIdx ]->coreAnimatedBy = coreIdx;
Me@31 152 allSchedSlots[ coreIdx ] = create_sched_slots(); //makes for one core
Me@53 153 _VMSMasterEnv->numMasterInARow[ coreIdx ] = 0;
Me@55 154 _VMSMasterEnv->workStealingGates[ coreIdx ] = NULL;
Me@31 155 }
Me@31 156 _VMSMasterEnv->readyToAnimateQs = readyToAnimateQs;
Me@31 157 _VMSMasterEnv->masterVPs = masterVPs;
Me@50 158 _VMSMasterEnv->masterLock = UNLOCKED;
Me@31 159 _VMSMasterEnv->allSchedSlots = allSchedSlots;
Me@55 160 _VMSMasterEnv->workStealingLock = UNLOCKED;
Me@28 161
Me@12 162
Me@31 163 //Aug 19, 2010: no longer need to place initial masterVP into queue
Me@31 164 // because coreLoop now controls -- animates its masterVP when no work
Me@31 165
Me@30 166
Me@50 167 //============================= MEASUREMENT STUFF ========================
Me@50 168 #ifdef STATS__TURN_ON_PROBES
Me@50 169 _VMSMasterEnv->dynIntervalProbesInfo =
msach@69 170 makePrivDynArrayOfSize( (void***)&(_VMSMasterEnv->intervalProbes), 200);
Me@30 171
Me@53 172 _VMSMasterEnv->probeNameHashTbl = makeHashTable( 1000, &VMS__free );
Me@53 173
Me@53 174 //put creation time directly into master env, for fast retrieval
Me@50 175 struct timeval timeStamp;
Me@50 176 gettimeofday( &(timeStamp), NULL);
Me@50 177 _VMSMasterEnv->createPtInSecs =
Me@50 178 timeStamp.tv_sec +(timeStamp.tv_usec/1000000.0);
Me@50 179 #endif
Me@65 180 #ifdef MEAS__TIME_MASTER_LOCK
Me@65 181 _VMSMasterEnv->masterLockLowTimeHist = makeFixedBinHist( 50, 0, 2,
Me@65 182 "master lock low time hist");
Me@68 183 _VMSMasterEnv->masterLockHighTimeHist = makeFixedBinHist( 50, 0, 100,
Me@65 184 "master lock high time hist");
Me@65 185 #endif
Me@68 186
msach@76 187 MakeTheMeasHists();
engelhardt@108 188
Nina@166 189
Nina@166 190 #ifdef DETECT_LOOP_GRAPH
Nina@166 191 _VMSMasterEnv->loop_graph = VMS__malloc(10*sizeof(void*));
Nina@166 192 _VMSMasterEnv->loop_graph_array_info = makePrivDynArrayInfoFrom((void***)&(_VMSMasterEnv->loop_graph),10);
Nina@166 193 int loop_i;
Nina@166 194 for(loop_i=0;loop_i<NUM_CORES;loop_i++){
Nina@166 195 _VMSMasterEnv->loop_counter[loop_i]=0;
Nina@166 196 }
Nina@129 197
Nina@166 198 #endif
Nina@166 199
Nina@109 200 #ifdef MEAS__PERF_COUNTERS
Nina@131 201 _VMSMasterEnv->counter_history = VMS__malloc(10*sizeof(void*));
Nina@131 202 _VMSMasterEnv->counter_history_array_info = makePrivDynArrayInfoFrom((void***)&(_VMSMasterEnv->counter_history),10);
Nina@110 203 //printf("Creating HW counters...");
Nina@110 204 FILE* output;
Nina@110 205 int n;
Nina@110 206 char filename[255];
Nina@110 207 for(n=0;n<255;n++)
Nina@110 208 {
Nina@113 209 sprintf(filename, "./counters/Counters.%d.csv",n);
Nina@110 210 output = fopen(filename,"r");
Nina@110 211 if(output)
Nina@110 212 {
Nina@110 213 fclose(output);
Nina@110 214 }else{
Nina@110 215 break;
Nina@110 216 }
Nina@110 217 }
Nina@110 218 printf("Saving Counter measurements to File: %s ...\n", filename);
Nina@110 219 output = fopen(filename,"w+");
Nina@110 220 _VMSMasterEnv->counteroutput = output;
Nina@110 221
engelhardt@108 222 struct perf_event_attr hw_event;
Nina@109 223 memset(&hw_event,0,sizeof(hw_event));
engelhardt@108 224 hw_event.type = PERF_TYPE_HARDWARE;
Nina@109 225 hw_event.size = sizeof(hw_event);
engelhardt@108 226 hw_event.disabled = 1;
Nina@109 227 hw_event.freq = 0;
engelhardt@108 228 hw_event.inherit = 1; /* children inherit it */
engelhardt@108 229 hw_event.pinned = 1; /* must always be on PMU */
engelhardt@108 230 hw_event.exclusive = 0; /* only group on PMU */
engelhardt@108 231 hw_event.exclude_user = 0; /* don't count user */
engelhardt@108 232 hw_event.exclude_kernel = 1; /* ditto kernel */
engelhardt@108 233 hw_event.exclude_hv = 1; /* ditto hypervisor */
engelhardt@108 234 hw_event.exclude_idle = 0; /* don't count when idle */
engelhardt@108 235 hw_event.mmap = 0; /* include mmap data */
engelhardt@108 236 hw_event.comm = 0; /* include comm data */
engelhardt@108 237
Nina@109 238
engelhardt@108 239 for( coreIdx = 0; coreIdx < NUM_CORES; coreIdx++ )
engelhardt@108 240 {
Nina@109 241 hw_event.config = 0x0000000000000000; //cycles
engelhardt@108 242 _VMSMasterEnv->cycles_counter_fd[coreIdx] = syscall(__NR_perf_event_open, &hw_event,
engelhardt@108 243 0,//pid_t pid,
Nina@167 244 coreIdx,//int cpu,
engelhardt@108 245 -1,//int group_fd,
engelhardt@108 246 0//unsigned long flags
engelhardt@108 247 );
Nina@109 248 if (_VMSMasterEnv->cycles_counter_fd[coreIdx]<0){
Nina@109 249 fprintf(stderr,"On core %d: ",coreIdx);
Nina@109 250 perror("Failed to open cycles counter");
Nina@109 251 }
Nina@109 252 hw_event.config = 0x0000000000000001; //instrs
engelhardt@108 253 _VMSMasterEnv->instrs_counter_fd[coreIdx] = syscall(__NR_perf_event_open, &hw_event,
engelhardt@108 254 0,//pid_t pid,
Nina@167 255 coreIdx,//int cpu,
engelhardt@108 256 -1,//int group_fd,
engelhardt@108 257 0//unsigned long flags
engelhardt@108 258 );
Nina@109 259 if (_VMSMasterEnv->instrs_counter_fd[coreIdx]<0){
Nina@109 260 fprintf(stderr,"On core %d: ",coreIdx);
Nina@109 261 perror("Failed to open instrs counter");
Nina@109 262 }
engelhardt@108 263 }
engelhardt@108 264 prctl(PR_TASK_PERF_EVENTS_ENABLE);
Nina@109 265 uint64 tmpc,tmpi;
Nina@109 266 saveCyclesAndInstrs(0,tmpc,tmpi);
Nina@130 267 printf("Start: cycles = %llu, instrs = %llu\n",tmpc,tmpi);
engelhardt@108 268 #endif
engelhardt@108 269
Me@50 270 //========================================================================
Me@38 271
Me@0 272 }
Me@0 273
Me@31 274 SchedSlot **
Me@31 275 create_sched_slots()
Me@31 276 { SchedSlot **schedSlots;
Me@0 277 int i;
Me@0 278
Me@53 279 schedSlots = VMS__malloc( NUM_SCHED_SLOTS * sizeof(SchedSlot *) );
Me@8 280
Me@1 281 for( i = 0; i < NUM_SCHED_SLOTS; i++ )
Me@0 282 {
Me@53 283 schedSlots[i] = VMS__malloc( sizeof(SchedSlot) );
Me@8 284
Me@1 285 //Set state to mean "handling requests done, slot needs filling"
Me@8 286 schedSlots[i]->workIsDone = FALSE;
Me@8 287 schedSlots[i]->needsProcrAssigned = TRUE;
Me@0 288 }
Me@31 289 return schedSlots;
Me@31 290 }
Me@31 291
Me@31 292
Me@31 293 void
Me@31 294 freeSchedSlots( SchedSlot **schedSlots )
Me@31 295 { int i;
Me@31 296 for( i = 0; i < NUM_SCHED_SLOTS; i++ )
Me@31 297 {
Me@53 298 VMS__free( schedSlots[i] );
Me@31 299 }
Me@53 300 VMS__free( schedSlots );
Me@0 301 }
Me@0 302
Me@8 303
Me@28 304 void
Me@28 305 create_the_coreLoop_OS_threads()
Me@28 306 {
Me@28 307 //========================================================================
Me@28 308 // Create the Threads
Me@28 309 int coreIdx, retCode;
Me@28 310
Me@28 311 //Need the threads to be created suspended, and wait for a signal
Me@28 312 // before proceeding -- gives time after creating to initialize other
Me@28 313 // stuff before the coreLoops set off.
Me@28 314 _VMSMasterEnv->setupComplete = 0;
Me@28 315
Me@28 316 //Make the threads that animate the core loops
Me@28 317 for( coreIdx=0; coreIdx < NUM_CORES; coreIdx++ )
Me@53 318 { coreLoopThdParams[coreIdx] = VMS__malloc( sizeof(ThdParams) );
Me@28 319 coreLoopThdParams[coreIdx]->coreNum = coreIdx;
Me@28 320
Me@28 321 retCode =
Me@28 322 pthread_create( &(coreLoopThdHandles[coreIdx]),
Me@28 323 thdAttrs,
Me@28 324 &coreLoop,
Me@28 325 (void *)(coreLoopThdParams[coreIdx]) );
Me@50 326 if(retCode){printf("ERROR creating thread: %d\n", retCode); exit(1);}
Me@28 327 }
Me@28 328 }
Me@28 329
Me@0 330 /*Semantic layer calls this when it want the system to start running..
Me@0 331 *
Me@24 332 *This starts the core loops running then waits for them to exit.
Me@0 333 */
Me@12 334 void
Me@24 335 VMS__start_the_work_then_wait_until_done()
Me@12 336 { int coreIdx;
Me@24 337 //Start the core loops running
Me@25 338
Me@25 339 //tell the core loop threads that setup is complete
Me@25 340 //get lock, to lock out any threads still starting up -- they'll see
Me@25 341 // that setupComplete is true before entering while loop, and so never
Me@25 342 // wait on the condition
Me@26 343 pthread_mutex_lock( &suspendLock );
Me@25 344 _VMSMasterEnv->setupComplete = 1;
Me@26 345 pthread_mutex_unlock( &suspendLock );
Me@26 346 pthread_cond_broadcast( &suspend_cond );
Me@25 347
Me@25 348
Me@24 349 //wait for all to complete
Me@8 350 for( coreIdx=0; coreIdx < NUM_CORES; coreIdx++ )
Me@8 351 {
Me@25 352 pthread_join( coreLoopThdHandles[coreIdx], NULL );
Me@24 353 }
Me@25 354
Me@24 355 //NOTE: do not clean up VMS env here -- semantic layer has to have
Me@24 356 // a chance to clean up its environment first, then do a call to free
Me@24 357 // the Master env and rest of VMS locations
Me@8 358 }
Me@0 359
msach@70 360 #ifdef SEQUENTIAL
Me@28 361 /*Only difference between version with an OS thread pinned to each core and
Me@28 362 * the sequential version of VMS is VMS__init_Seq, this, and coreLoop_Seq.
Me@28 363 */
Me@28 364 void
Me@28 365 VMS__start_the_work_then_wait_until_done_Seq()
Me@28 366 {
Me@28 367 //Instead of un-suspending threads, just call the one and only
Me@28 368 // core loop (sequential version), in the main thread.
Me@28 369 coreLoop_Seq( NULL );
msach@75 370 flushRegisters();
Me@28 371
Me@28 372 }
msach@70 373 #endif
Me@28 374
Me@50 375 inline VirtProcr *
Me@50 376 VMS__create_procr( VirtProcrFnPtr fnPtr, void *initialData )
Me@50 377 { VirtProcr *newPr;
msach@76 378 void *stackLocs;
Me@50 379
Me@50 380 newPr = VMS__malloc( sizeof(VirtProcr) );
Me@50 381 stackLocs = VMS__malloc( VIRT_PROCR_STACK_SIZE );
Me@50 382 if( stackLocs == 0 )
Me@50 383 { perror("VMS__malloc stack"); exit(1); }
Me@50 384
msach@69 385 return create_procr_helper( newPr, fnPtr, initialData, stackLocs );
Me@50 386 }
Me@50 387
Me@50 388 /* "ext" designates that it's for use outside the VMS system -- should only
Me@50 389 * be called from main thread or other thread -- never from code animated by
Me@50 390 * a VMS virtual processor.
Me@50 391 */
Me@50 392 inline VirtProcr *
Me@50 393 VMS_ext__create_procr( VirtProcrFnPtr fnPtr, void *initialData )
Me@50 394 { VirtProcr *newPr;
Me@50 395 char *stackLocs;
Me@50 396
Me@50 397 newPr = malloc( sizeof(VirtProcr) );
Me@50 398 stackLocs = malloc( VIRT_PROCR_STACK_SIZE );
Me@50 399 if( stackLocs == 0 )
Me@50 400 { perror("malloc stack"); exit(1); }
Me@50 401
msach@69 402 return create_procr_helper( newPr, fnPtr, initialData, stackLocs );
Me@50 403 }
Me@50 404
Me@8 405
Me@64 406 /*Anticipating multi-tasking
Me@64 407 */
Me@64 408 void *
Me@64 409 VMS__give_sem_env_for( VirtProcr *animPr )
Me@64 410 {
Me@64 411 return _VMSMasterEnv->semanticEnv;
Me@64 412 }
Me@64 413 //===========================================================================
Me@26 414 /*there is a label inside this function -- save the addr of this label in
Me@0 415 * the callingPr struc, as the pick-up point from which to start the next
Me@0 416 * work-unit for that procr. If turns out have to save registers, then
Me@0 417 * save them in the procr struc too. Then do assembly jump to the CoreLoop's
Me@0 418 * "done with work-unit" label. The procr struc is in the request in the
Me@0 419 * slave that animated the just-ended work-unit, so all the state is saved
Me@0 420 * there, and will get passed along, inside the request handler, to the
Me@0 421 * next work-unit for that procr.
Me@0 422 */
Me@8 423 void
Me@38 424 VMS__suspend_procr( VirtProcr *animatingPr )
Me@55 425 {
Me@30 426
Me@30 427 //The request to master will cause this suspended virt procr to get
Me@30 428 // scheduled again at some future point -- to resume, core loop jumps
Me@30 429 // to the resume point (below), which causes restore of saved regs and
Me@30 430 // "return" from this call.
msach@71 431 //animatingPr->nextInstrPt = &&ResumePt;
Me@30 432
Me@30 433 //return ownership of the virt procr and sched slot to Master virt pr
Me@38 434 animatingPr->schedSlot->workIsDone = TRUE;
Me@1 435
Me@41 436 //=========================== Measurement stuff ========================
Me@38 437 #ifdef MEAS__TIME_STAMP_SUSP
Me@41 438 //record time stamp: compare to time-stamp recorded below
Me@38 439 saveLowTimeStampCountInto( animatingPr->preSuspTSCLow );
Me@38 440 #endif
Me@41 441 //=======================================================================
Me@30 442
msach@71 443 switchToCoreLoop(animatingPr);
msach@71 444 flushRegisters();
Me@55 445
Me@55 446 //=======================================================================
Me@30 447
Me@38 448 #ifdef MEAS__TIME_STAMP_SUSP
Me@41 449 //NOTE: only take low part of count -- do sanity check when take diff
Me@38 450 saveLowTimeStampCountInto( animatingPr->postSuspTSCLow );
Me@38 451 #endif
Me@30 452
Me@0 453 return;
Me@0 454 }
Me@0 455
Me@22 456
Me@22 457
Me@50 458 /*For this implementation of VMS, it may not make much sense to have the
Me@50 459 * system of requests for creating a new processor done this way.. but over
Me@50 460 * the scope of single-master, multi-master, mult-tasking, OS-implementing,
Me@50 461 * distributed-memory, and so on, this gives VMS implementation a chance to
Me@50 462 * do stuff before suspend, in the AppVP, and in the Master before the plugin
Me@50 463 * is called, as well as in the lang-lib before this is called, and in the
Me@50 464 * plugin. So, this gives both VMS and language implementations a chance to
Me@50 465 * intercept at various points and do order-dependent stuff.
Me@50 466 *Having a standard VMSNewPrReqData struc allows the language to create and
Me@50 467 * free the struc, while VMS knows how to get the newPr if it wants it, and
Me@50 468 * it lets the lang have lang-specific data related to creation transported
Me@50 469 * to the plugin.
Me@50 470 */
Nina@110 471 __attribute__ ((noinline)) void
Nina@110 472 VMS__send_create_procr_req( void *semReqData, VirtProcr *reqstingPr )
Nina@109 473
Me@50 474 { VMSReqst req;
Me@50 475
Me@50 476 req.reqType = createReq;
Me@50 477 req.semReqData = semReqData;
Me@50 478 req.nextReqst = reqstingPr->requests;
Me@50 479 reqstingPr->requests = &req;
Me@50 480
Me@50 481 VMS__suspend_procr( reqstingPr );
Me@50 482 }
Me@50 483
Me@22 484
Me@38 485 /*
Me@22 486 *This adds a request to dissipate, then suspends the processor so that the
Me@22 487 * request handler will receive the request. The request handler is what
Me@22 488 * does the work of freeing memory and removing the processor from the
Me@22 489 * semantic environment's data structures.
Me@22 490 *The request handler also is what figures out when to shutdown the VMS
Me@22 491 * system -- which causes all the core loop threads to die, and returns from
Me@22 492 * the call that started up VMS to perform the work.
Me@22 493 *
Me@22 494 *This form is a bit misleading to understand if one is trying to figure out
Me@22 495 * how VMS works -- it looks like a normal function call, but inside it
Me@22 496 * sends a request to the request handler and suspends the processor, which
Me@22 497 * jumps out of the VMS__dissipate_procr function, and out of all nestings
Me@22 498 * above it, transferring the work of dissipating to the request handler,
Me@22 499 * which then does the actual work -- causing the processor that animated
Me@22 500 * the call of this function to disappear and the "hanging" state of this
Me@22 501 * function to just poof into thin air -- the virtual processor's trace
Me@22 502 * never returns from this call, but instead the virtual processor's trace
Me@22 503 * gets suspended in this call and all the virt processor's state disap-
Me@22 504 * pears -- making that suspend the last thing in the virt procr's trace.
Me@8 505 */
Nina@110 506 __attribute__ ((noinline)) void
Nina@110 507 VMS__send_dissipate_req( VirtProcr *procrToDissipate )
Me@50 508 { VMSReqst req;
Me@22 509
Me@50 510 req.reqType = dissipate;
Me@50 511 req.nextReqst = procrToDissipate->requests;
Me@50 512 procrToDissipate->requests = &req;
Me@50 513
Me@22 514 VMS__suspend_procr( procrToDissipate );
Me@50 515 }
Me@50 516
Me@50 517
Me@50 518 /* "ext" designates that it's for use outside the VMS system -- should only
Me@50 519 * be called from main thread or other thread -- never from code animated by
Me@50 520 * a VMS virtual processor.
Me@50 521 *
Me@50 522 *Use this version to dissipate VPs created outside the VMS system.
Me@50 523 */
Me@50 524 void
Me@50 525 VMS_ext__dissipate_procr( VirtProcr *procrToDissipate )
Me@50 526 {
Me@50 527 //NOTE: initialData was given to the processor, so should either have
Me@50 528 // been alloc'd with VMS__malloc, or freed by the level above animPr.
Me@50 529 //So, all that's left to free here is the stack and the VirtProcr struc
Me@50 530 // itself
Me@50 531 //Note, should not stack-allocate initial data -- no guarantee, in
Me@50 532 // general that creating processor will outlive ones it creates.
Me@50 533 free( procrToDissipate->startOfStack );
Me@50 534 free( procrToDissipate );
Me@50 535 }
Me@50 536
Me@22 537
Me@22 538
Me@53 539 /*This call's name indicates that request is malloc'd -- so req handler
Me@53 540 * has to free any extra requests tacked on before a send, using this.
Me@53 541 *
Me@53 542 * This inserts the semantic-layer's request data into standard VMS carrier
Me@53 543 * request data-struct that is mallocd. The sem request doesn't need to
Me@53 544 * be malloc'd if this is called inside the same call chain before the
Me@53 545 * send of the last request is called.
Me@53 546 *
Me@53 547 *The request handler has to call VMS__free_VMSReq for any of these
Me@22 548 */
Me@22 549 inline void
Me@53 550 VMS__add_sem_request_in_mallocd_VMSReqst( void *semReqData,
Me@53 551 VirtProcr *callingPr )
Me@53 552 { VMSReqst *req;
Me@22 553
Me@53 554 req = VMS__malloc( sizeof(VMSReqst) );
Me@53 555 req->reqType = semantic;
Me@53 556 req->semReqData = semReqData;
Me@53 557 req->nextReqst = callingPr->requests;
Me@53 558 callingPr->requests = req;
Me@22 559 }
Me@22 560
Me@50 561 /*This inserts the semantic-layer's request data into standard VMS carrier
Me@50 562 * request data-struct is allocated on stack of this call & ptr to it sent
Me@50 563 * to plugin
Me@50 564 *Then it does suspend, to cause request to be sent.
Me@50 565 */
Nina@110 566 /*inline*/__attribute__ ((noinline)) void
Nina@110 567 VMS__send_sem_request( void *semReqData, VirtProcr *callingPr )
Me@50 568 { VMSReqst req;
Me@22 569
Me@50 570 req.reqType = semantic;
Me@50 571 req.semReqData = semReqData;
Me@50 572 req.nextReqst = callingPr->requests;
Me@50 573 callingPr->requests = &req;
Me@50 574
Me@50 575 VMS__suspend_procr( callingPr );
Me@50 576 }
Me@50 577
Me@50 578
Nina@110 579 /*inline*/ __attribute__ ((noinline)) void
Nina@110 580 VMS__send_VMSSem_request( void *semReqData, VirtProcr *callingPr )
Nina@109 581
Me@50 582 { VMSReqst req;
Me@50 583
Me@50 584 req.reqType = VMSSemantic;
Me@50 585 req.semReqData = semReqData;
Me@50 586 req.nextReqst = callingPr->requests; //gab any other preceeding
Me@50 587 callingPr->requests = &req;
Me@50 588
Me@50 589 VMS__suspend_procr( callingPr );
Me@50 590 }
Me@50 591
Me@50 592
Me@50 593 /*
Me@38 594 */
Me@24 595 VMSReqst *
Me@50 596 VMS__take_next_request_out_of( VirtProcr *procrWithReq )
Me@31 597 { VMSReqst *req;
Me@31 598
Me@31 599 req = procrWithReq->requests;
Me@38 600 if( req == NULL ) return NULL;
Me@31 601
Me@31 602 procrWithReq->requests = procrWithReq->requests->nextReqst;
Me@50 603 return req;
Me@24 604 }
Me@22 605
Me@24 606
Me@24 607 inline void *
Me@24 608 VMS__take_sem_reqst_from( VMSReqst *req )
Me@24 609 {
Me@24 610 return req->semReqData;
Me@24 611 }
Me@24 612
Me@24 613
Me@24 614
Me@50 615 /* This is for OS requests and VMS infrastructure requests, such as to create
Me@50 616 * a probe -- a probe is inside the heart of VMS-core, it's not part of any
Me@50 617 * language -- but it's also a semantic thing that's triggered from and used
Me@50 618 * in the application.. so it crosses abstractions.. so, need some special
Me@50 619 * pattern here for handling such requests.
Me@52 620 * Doing this just like it were a second language sharing VMS-core.
Me@52 621 *
Me@50 622 * This is called from the language's request handler when it sees a request
Me@50 623 * of type VMSSemReq
Me@52 624 *
Me@52 625 * TODO: Later change this, to give probes their own separate plugin & have
Me@52 626 * VMS-core steer the request to appropriate plugin
Me@52 627 * Do the same for OS calls -- look later at it..
Me@50 628 */
Me@50 629 void inline
Me@50 630 VMS__handle_VMSSemReq( VMSReqst *req, VirtProcr *requestingPr, void *semEnv,
Me@50 631 ResumePrFnPtr resumePrFnPtr )
Me@50 632 { VMSSemReq *semReq;
Me@50 633 IntervalProbe *newProbe;
Me@24 634
Me@50 635 semReq = req->semReqData;
Me@24 636
Me@50 637 newProbe = VMS__malloc( sizeof(IntervalProbe) );
Me@65 638 newProbe->nameStr = VMS__strDup( semReq->nameStr );
Me@50 639 newProbe->hist = NULL;
Me@50 640 newProbe->schedChoiceWasRecorded = FALSE;
Me@53 641
Me@53 642 //This runs in masterVP, so no race-condition worries
Me@50 643 newProbe->probeID =
Me@50 644 addToDynArray( newProbe, _VMSMasterEnv->dynIntervalProbesInfo );
Me@50 645
Me@53 646 requestingPr->dataRetFromReq = newProbe;
Me@50 647
Me@50 648 (*resumePrFnPtr)( requestingPr, semEnv );
Me@22 649 }
Me@22 650
Me@22 651
Me@22 652
Me@24 653 /*This must be called by the request handler plugin -- it cannot be called
Me@24 654 * from the semantic library "dissipate processor" function -- instead, the
Me@50 655 * semantic layer has to generate a request, and the plug-in calls this
Me@24 656 * function.
Me@24 657 *The reason is that this frees the virtual processor's stack -- which is
Me@24 658 * still in use inside semantic library calls!
Me@24 659 *
Me@24 660 *This frees or recycles all the state owned by and comprising the VMS
Me@24 661 * portion of the animating virtual procr. The request handler must first
Me@24 662 * free any semantic data created for the processor that didn't use the
Me@24 663 * VMS_malloc mechanism. Then it calls this, which first asks the malloc
Me@24 664 * system to disown any state that did use VMS_malloc, and then frees the
Me@24 665 * statck and the processor-struct itself.
Me@24 666 *If the dissipated processor is the sole (remaining) owner of VMS__malloc'd
Me@24 667 * state, then that state gets freed (or sent to recycling) as a side-effect
Me@24 668 * of dis-owning it.
Me@24 669 */
Me@24 670 void
Me@53 671 VMS__dissipate_procr( VirtProcr *animatingPr )
Me@24 672 {
Me@24 673 //dis-own all locations owned by this processor, causing to be freed
Me@24 674 // any locations that it is (was) sole owner of
Me@29 675 //TODO: implement VMS__malloc system, including "give up ownership"
Me@24 676
Me@24 677
Me@24 678 //NOTE: initialData was given to the processor, so should either have
Me@24 679 // been alloc'd with VMS__malloc, or freed by the level above animPr.
Me@24 680 //So, all that's left to free here is the stack and the VirtProcr struc
Me@24 681 // itself
Me@50 682 //Note, should not stack-allocate initial data -- no guarantee, in
Me@50 683 // general that creating processor will outlive ones it creates.
Me@50 684 VMS__free( animatingPr->startOfStack );
Me@50 685 VMS__free( animatingPr );
Me@24 686 }
Me@24 687
Me@24 688
Me@53 689 //TODO: look at architecting cleanest separation between request handler
Me@29 690 // and master loop, for dissipate, create, shutdown, and other non-semantic
Me@29 691 // requests. Issue is chain: one removes requests from AppVP, one dispatches
Me@29 692 // on type of request, and one handles each type.. but some types require
Me@29 693 // action from both request handler and master loop -- maybe just give the
Me@29 694 // request handler calls like: VMS__handle_X_request_type
Me@24 695
Me@29 696
Me@29 697 /*This is called by the semantic layer's request handler when it decides its
Me@29 698 * time to shut down the VMS system. Calling this causes the core loop OS
Me@29 699 * threads to exit, which unblocks the entry-point function that started up
Me@29 700 * VMS, and allows it to grab the result and return to the original single-
Me@29 701 * threaded application.
Me@22 702 *
Me@29 703 *The _VMSMasterEnv is needed by this shut down function, so the create-seed-
Me@29 704 * and-wait function has to free a bunch of stuff after it detects the
Me@29 705 * threads have all died: the masterEnv, the thread-related locations,
Me@29 706 * masterVP any AppVPs that might still be allocated and sitting in the
Me@29 707 * semantic environment, or have been orphaned in the _VMSWorkQ.
Me@29 708 *
Me@53 709 *NOTE: the semantic plug-in is expected to use VMS__malloc to get all the
Me@29 710 * locations it needs, and give ownership to masterVP. Then, they will be
Me@53 711 * automatically freed.
Me@22 712 *
Me@29 713 *In here,create one core-loop shut-down processor for each core loop and put
Me@31 714 * them all directly into the readyToAnimateQ.
Me@29 715 *Note, this function can ONLY be called after the semantic environment no
Me@29 716 * longer cares if AppVPs get animated after the point this is called. In
Me@29 717 * other words, this can be used as an abort, or else it should only be
Me@29 718 * called when all AppVPs have finished dissipate requests -- only at that
Me@29 719 * point is it sure that all results have completed.
Me@22 720 */
Me@22 721 void
Me@53 722 VMS__shutdown()
Me@8 723 { int coreIdx;
Me@14 724 VirtProcr *shutDownPr;
Me@22 725
Me@29 726 //create the shutdown processors, one for each core loop -- put them
Me@31 727 // directly into the Q -- each core will die when gets one
Me@8 728 for( coreIdx=0; coreIdx < NUM_CORES; coreIdx++ )
Me@50 729 { //Note, this is running in the master
Me@29 730 shutDownPr = VMS__create_procr( &endOSThreadFn, NULL );
Me@55 731 writeVMSQ( shutDownPr, _VMSMasterEnv->readyToAnimateQs[coreIdx] );
Me@8 732 }
Nina@109 733 #ifdef MEAS__PERF_COUNTERS
Nina@109 734 uint64 tmpc,tmpi;
Nina@109 735 saveCyclesAndInstrs(0,tmpc,tmpi);
Nina@130 736 printf("End: cycles = %llu, instrs = %llu\n",tmpc,tmpi);
Nina@109 737 prctl(PR_TASK_PERF_EVENTS_DISABLE);
Nina@109 738 /*
Nina@109 739 for( coreIdx=0; coreIdx < NUM_CORES; coreIdx++ ){
Nina@109 740 close(_VMSMasterEnv->cycles_counter_fd[coreIdx]);
Nina@109 741 close(_VMSMasterEnv->instrs_counter_fd[coreIdx]);
Nina@109 742 }
Nina@109 743 */
Nina@109 744 #endif
Me@12 745 }
Me@12 746
Me@12 747
Me@29 748 /*Am trying to be cute, avoiding IF statement in coreLoop that checks for
Me@29 749 * a special shutdown procr. Ended up with extra-complex shutdown sequence.
Me@29 750 *This function has the sole purpose of setting the stack and framePtr
Me@29 751 * to the coreLoop's stack and framePtr.. it does that then jumps to the
Me@29 752 * core loop's shutdown point -- might be able to just call Pthread_exit
Me@30 753 * from here, but am going back to the pthread's stack and setting everything
Me@29 754 * up just as if it never jumped out, before calling pthread_exit.
Me@29 755 *The end-point of core loop will free the stack and so forth of the
Me@29 756 * processor that animates this function, (this fn is transfering the
Me@29 757 * animator of the AppVP that is in turn animating this function over
Me@29 758 * to core loop function -- note that this slices out a level of virtual
Me@29 759 * processors).
Me@29 760 */
Me@29 761 void
Me@29 762 endOSThreadFn( void *initData, VirtProcr *animatingPr )
msach@71 763 {
msach@75 764 #ifdef SEQUENTIAL
msach@75 765 asmTerminateCoreLoopSeq(animatingPr);
msach@75 766 #else
msach@71 767 asmTerminateCoreLoop(animatingPr);
msach@75 768 #endif
Me@30 769 }
Me@29 770
Me@29 771
Me@53 772 /*This is called from the startup & shutdown
Me@24 773 */
Me@24 774 void
Me@53 775 VMS__cleanup_at_end_of_shutdown()
Me@31 776 {
msach@78 777 //unused
msach@78 778 //VMSQueueStruc **readyToAnimateQs;
msach@78 779 //int coreIdx;
msach@78 780 //VirtProcr **masterVPs;
msach@78 781 //SchedSlot ***allSchedSlots; //ptr to array of ptrs
Me@31 782
Me@65 783 //Before getting rid of everything, print out any measurements made
Nina@109 784 //forAllInDynArrayDo( _VMSMasterEnv->measHistsInfo, (DynArrayFnPtr)&printHist );
Nina@109 785 //forAllInDynArrayDo( _VMSMasterEnv->measHistsInfo, (DynArrayFnPtr)&saveHistToFile);
Me@68 786 //forAllInDynArrayDo( _VMSMasterEnv->measHistsInfo, &freeHistExt );
Nina@167 787
Nina@166 788 #ifdef DETECT_LOOP_GRAPH
Nina@166 789 FILE* loop_output;
Nina@166 790 int loop_n;
Nina@166 791 char loop_filename[255];
Nina@166 792 for(loop_n=0;loop_n<255;loop_n++)
Nina@166 793 {
Nina@166 794 sprintf(loop_filename, "./counters/LoopGraph.%d.dot",loop_n);
Nina@166 795 loop_output = fopen(loop_filename,"r");
Nina@166 796 if(loop_output)
Nina@166 797 {
Nina@166 798 fclose(loop_output);
Nina@166 799 }else{
Nina@166 800 break;
Nina@166 801 }
Nina@166 802 }
Nina@166 803 if(loop_n<255){
Nina@166 804 printf("Saving Loop Graph to File: %s ...\n", loop_filename);
Nina@166 805 loop_output = fopen(loop_filename,"w+");
Nina@166 806 if(loop_output!=NULL){
Nina@166 807 set_dependency_file(loop_output);
Nina@166 808 fprintf(loop_output,"digraph Loop {\n");
Nina@166 809 set_loop_file(loop_output);
Nina@166 810 forAllInDynArrayDo(_VMSMasterEnv->counter_history_array_info, &print_dot_node_info );
Nina@166 811 forAllInDynArrayDo( _VMSMasterEnv->loop_graph_array_info, &print_per_slot_to_file );
Nina@166 812 //int coreIdx;
Nina@166 813 //for(coreIdx=0;coreIdx<NUM_CORES;coreIdx++){
Nina@166 814 // fprintf(loop_output,"sync%d_%d [shape=rect,label=\"Sync\"];\n",coreIdx,_VMSMasterEnv->loop_counter[coreIdx]);
Nina@166 815 //}
Nina@166 816 fprintf(loop_output,"}\n");
Nina@166 817 } else
Nina@166 818 printf("Opening Loop Graph file failed. Please check that folder \"counters\" exists in run directory.\n");
Nina@166 819 } else {
Nina@166 820 printf("Could not open Loop Graph file, please clean \"counters\" folder. (Must contain less than 255 files.)\n");
Nina@166 821 }
Nina@166 822 #endif
Me@65 823 #ifdef MEAS__TIME_PLUGIN
Me@68 824 printHist( _VMSMasterEnv->reqHdlrLowTimeHist );
msach@84 825 saveHistToFile( _VMSMasterEnv->reqHdlrLowTimeHist );
Me@68 826 printHist( _VMSMasterEnv->reqHdlrHighTimeHist );
msach@79 827 saveHistToFile( _VMSMasterEnv->reqHdlrHighTimeHist );
Me@68 828 freeHistExt( _VMSMasterEnv->reqHdlrLowTimeHist );
Me@68 829 freeHistExt( _VMSMasterEnv->reqHdlrHighTimeHist );
Me@65 830 #endif
Me@65 831 #ifdef MEAS__TIME_MALLOC
Me@65 832 printHist( _VMSMasterEnv->mallocTimeHist );
msach@79 833 saveHistToFile( _VMSMasterEnv->mallocTimeHist );
Me@65 834 printHist( _VMSMasterEnv->freeTimeHist );
msach@79 835 saveHistToFile( _VMSMasterEnv->freeTimeHist );
Me@65 836 freeHistExt( _VMSMasterEnv->mallocTimeHist );
Me@65 837 freeHistExt( _VMSMasterEnv->freeTimeHist );
Me@65 838 #endif
Me@65 839 #ifdef MEAS__TIME_MASTER_LOCK
Me@65 840 printHist( _VMSMasterEnv->masterLockLowTimeHist );
Me@65 841 printHist( _VMSMasterEnv->masterLockHighTimeHist );
Me@65 842 #endif
Me@65 843 #ifdef MEAS__TIME_MASTER
Me@65 844 printHist( _VMSMasterEnv->pluginTimeHist );
Me@65 845 for( coreIdx = 0; coreIdx < NUM_CORES; coreIdx++ )
Me@65 846 {
Me@65 847 freeVMSQ( readyToAnimateQs[ coreIdx ] );
Me@65 848 //master VPs were created external to VMS, so use external free
Me@65 849 VMS__dissipate_procr( masterVPs[ coreIdx ] );
Me@65 850
Me@65 851 freeSchedSlots( allSchedSlots[ coreIdx ] );
Me@65 852 }
Me@65 853 #endif
Me@65 854 #ifdef MEAS__TIME_STAMP_SUSP
Me@65 855 printHist( _VMSMasterEnv->pluginTimeHist );
Me@65 856 for( coreIdx = 0; coreIdx < NUM_CORES; coreIdx++ )
Me@65 857 {
Me@65 858 freeVMSQ( readyToAnimateQs[ coreIdx ] );
Me@65 859 //master VPs were created external to VMS, so use external free
Me@65 860 VMS__dissipate_procr( masterVPs[ coreIdx ] );
Me@65 861
Me@65 862 freeSchedSlots( allSchedSlots[ coreIdx ] );
Me@65 863 }
Me@65 864 #endif
Me@65 865
Me@53 866 //All the environment data has been allocated with VMS__malloc, so just
Me@53 867 // free its internal big-chunk and all inside it disappear.
Me@53 868 /*
Me@31 869 readyToAnimateQs = _VMSMasterEnv->readyToAnimateQs;
Me@31 870 masterVPs = _VMSMasterEnv->masterVPs;
Me@31 871 allSchedSlots = _VMSMasterEnv->allSchedSlots;
Me@31 872
Me@31 873 for( coreIdx = 0; coreIdx < NUM_CORES; coreIdx++ )
Me@24 874 {
Me@55 875 freeVMSQ( readyToAnimateQs[ coreIdx ] );
Me@50 876 //master VPs were created external to VMS, so use external free
Me@53 877 VMS__dissipate_procr( masterVPs[ coreIdx ] );
Me@31 878
Me@31 879 freeSchedSlots( allSchedSlots[ coreIdx ] );
Me@24 880 }
Me@31 881
Me@53 882 VMS__free( _VMSMasterEnv->readyToAnimateQs );
Me@53 883 VMS__free( _VMSMasterEnv->masterVPs );
Me@53 884 VMS__free( _VMSMasterEnv->allSchedSlots );
Me@50 885
Me@50 886 //============================= MEASUREMENT STUFF ========================
Me@50 887 #ifdef STATS__TURN_ON_PROBES
Me@53 888 freeDynArrayDeep( _VMSMasterEnv->dynIntervalProbesInfo, &VMS__free_probe);
Me@50 889 #endif
Me@50 890 //========================================================================
Me@53 891 */
Me@53 892 //These are the only two that use system free
Me@53 893 VMS_ext__free_free_list( _VMSMasterEnv->freeListHead );
Me@53 894 free( (void *)_VMSMasterEnv );
Me@24 895 }
Me@24 896
Me@54 897
Me@54 898 //================================
Me@54 899
Me@54 900
Me@54 901 /*Later, improve this -- for now, just exits the application after printing
Me@54 902 * the error message.
Me@54 903 */
Me@54 904 void
Me@54 905 VMS__throw_exception( char *msgStr, VirtProcr *reqstPr, VMSExcp *excpData )
Me@54 906 {
msach@69 907 printf("%s",msgStr);
Me@54 908 fflush(stdin);
Me@54 909 exit(1);
Me@54 910 }
Me@54 911