1.1 --- a/Defines/VMS_defs.h	Mon Sep 10 01:26:51 2012 -0700
     1.2 +++ b/Defines/VMS_defs.h	Fri Nov 09 04:20:31 2012 -0800
     1.3 @@ -30,6 +30,7 @@
     1.4  
     1.5  //======================  Hardware Constants ============================
     1.6  #include "VMS_defs__HW_constants.h"
     1.7 +#include "../HW_Dependent_Primitives/VMS__comm_description.h"
     1.8  
     1.9  //======================  Macros  ======================
    1.10     //for turning macros and other VMS features on and off

     2.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     2.2 +++ b/HW_Dependent_Primitives/VMS__comm_description.c	Fri Nov 09 04:20:31 2012 -0800
     2.3 @@ -0,0 +1,72 @@
     2.4 +/*
     2.5 + * This File contains all hardware dependent C code.
     2.6 + */
     2.7 +
     2.8 +
     2.9 +#include "../VMS.h"
    2.10 +#include "VMS__comm_description.h"
    2.11 +
    2.12 +
    2.13 +/*
    2.14 + */
    2.15 +VMSCommNode *
    2.16 +VMS_SS__create_comm_system()
    2.17 + { VMSCommNode      *systemNode, *tempNode1, *tempNode2, *tempNode3;
    2.18 +   VMSMainMemNode   *mainMemContents;
    2.19 +   VMSCacheNode     *cacheContents;
    2.20 +   VMSProcessorNode *processorContents;
    2.21 +   
    2.22 +   systemNode              = VMS_int__malloc( sizeof(VMSCommNode) );
    2.23 +   systemNode->nodeType    = SystemNode;
    2.24 +   systemNode->numParents  = 0;
    2.25 +   systemNode->parents     = NULL;
    2.26 +   systemNode->numChildren = 1;
    2.27 +   systemNode->children    = VMS_int__malloc( 1 * sizeof(VMSCommNode *) );
    2.28 +   systemNode->contents    = NULL;
    2.29 +   
    2.30 +   tempNode1               = VMS_int__malloc( sizeof(VMSCommNode) );
    2.31 +   tempNode1->nodeType     = MainMemNode;
    2.32 +   tempNode1->numParents   = 1;
    2.33 +   tempNode1->parents      = VMS_int__malloc( 1 * sizeof(VMSCommNode *) );
    2.34 +   tempNode1->parents[0]   = systemNode;
    2.35 +   tempNode1->numChildren  = 1;
    2.36 +   tempNode1->children     = VMS_int__malloc( 1 * sizeof(VMSCommNode *) );
    2.37 +   mainMemContents         = VMS_int__malloc( sizeof(VMSMainMemNode) );
    2.38 +   mainMemContents->cyclesToFillRequest = 60;
    2.39 +   tempNode1->contents     = mainMemContents;
    2.40 +   
    2.41 +   systemNode->children[0] = tempNode1;
    2.42 +
    2.43 +   
    2.44 +   tempNode2               = VMS_int__malloc( sizeof(VMSCommNode) );
    2.45 +   tempNode2->nodeType     = CacheNode;
    2.46 +   tempNode2->numParents   = 1;
    2.47 +   tempNode2->parents      = VMS_int__malloc( 1 * sizeof(VMSCommNode *) );
    2.48 +   tempNode2->parents[0]   = tempNode1;
    2.49 +   tempNode2->numChildren  = 1;
    2.50 +   tempNode2->children     = VMS_int__malloc( 1 * sizeof(VMSCommNode *) );
    2.51 +   cacheContents           = VMS_int__malloc( sizeof(VMSCacheNode) );
    2.52 +   cacheContents->HitCycles = 10;
    2.53 +   cacheContents->cacheSize = 8; //k-bytes
    2.54 +   cacheContents->lineSize = 64; //bytes
    2.55 +   tempNode2->contents     = cacheContents;
    2.56 +   
    2.57 +   tempNode1->children[0]  = tempNode2;
    2.58 +
    2.59 +   tempNode3               = VMS_int__malloc( sizeof(VMSCommNode) );
    2.60 +   tempNode3->nodeType     = ProcessorNode;
    2.61 +   tempNode3->numParents   = 1;
    2.62 +   tempNode3->parents      = VMS_int__malloc( 1 * sizeof(VMSCommNode *) );
    2.63 +   tempNode3->parents[0]   = tempNode2;
    2.64 +   tempNode3->numChildren  = 0;
    2.65 +   tempNode3->children     = NULL;
    2.66 +   processorContents       = VMS_int__malloc( sizeof(VMSMainMemNode) );
    2.67 +   processorContents->coreNum = 1;
    2.68 +   tempNode3->contents     = processorContents;
    2.69 +   
    2.70 +   tempNode2->children[0]  = tempNode3;
    2.71 +   
    2.72 +   return systemNode;
    2.73 + }
    2.74 +
    2.75 +

     3.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     3.2 +++ b/HW_Dependent_Primitives/VMS__comm_description.h	Fri Nov 09 04:20:31 2012 -0800
     3.3 @@ -0,0 +1,150 @@
     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  _VMS__COMM_H
    3.13 +#define	_VMS__COMM_H
    3.14 +
    3.15 +#include "../VMS_primitive_data_types.h"
    3.16 +
    3.17 +/*These data structures encode information about the communication hardware
    3.18 + * present in the system.
    3.19 + *
    3.20 + *The idea is for the VMS system to construct a graph of these data structures
    3.21 + * and pass it to the assigner, which then uses it while making decisions,
    3.22 + * about where to place work (data).
    3.23 + * 
    3.24 + *The information important in assignment decisions is:
    3.25 + * 1) The location of each portion of data used by a work-unit
    3.26 + * 2) The path from the starting place of data to the location it's used
    3.27 + * 3) The latency and bandwidth along each segment of that path
    3.28 + * 
    3.29 + * In order to determine the location of data, it must be tracked.  To track
    3.30 + * location, the information needed is:
    3.31 + * 1) size of cache at each point in the cache hierarchy
    3.32 + * 2) possibly some indication of likelihood of replacement of data
    3.33 + * 
    3.34 + *These data structures are available to the plugin by asking VMS, which
    3.35 + * returns a graph:
    3.36 + *Its root is a node representing the  system, which has a 
    3.37 + * "main memory" child for each main-memory port in the system.  
    3.38 + *A main memory node is not completely defined yet (as of Nov 2012). It will
    3.39 + * eventually contain some means for determining which allocated chunks 
    3.40 + * of data reside in which physical memory ports.  However, it has a child
    3.41 + * for each cache directly connected to it.  At some point it will also have 
    3.42 + * some way to determine expected contention when multiple caches connect
    3.43 + * directly to the same main-memory port.  At the moment it has a fixed
    3.44 + * time to fulfill a cache request.
    3.45 + *A cache node has the size of its line, and the 
    3.46 + * expected time to fulfill a miss request.  It also has the size of the
    3.47 + * cache.  Once experience is gained, some indication will be added for
    3.48 + * the efficiency of the cache -- IE, fully-associative is more efficient
    3.49 + * than direct-mapped.  This will help estimate how long data remains in
    3.50 + * a given cache before being overwritten.  A cache node has a set of
    3.51 + * pointers to the nodes above it, and separate set of pointers to the
    3.52 + * nodes below it.
    3.53 + *At the leaves are processor nodes, which contain the coreNum of that
    3.54 + * core.  The coreNum is stored inside animation slots, and inside slaves.
    3.55 + * 
    3.56 + *The assigner is given an animation slot, and can take the coreNum out of
    3.57 + * it, and then use that to trace where in the hierarchy the data resides
    3.58 + * for each work-unit it has available to assign to that animation slot.
    3.59 + * 
    3.60 + *As experience is gained, the interface to the assigner may change, to 
    3.61 + * give it more control over the animation slots, and more predictability
    3.62 + * over when each animation slots will become free, so that it can plan
    3.63 + * ahead.
    3.64 + * 
    3.65 + *NOTE: these data structs are read-only!!  They may be shared with multiple
    3.66 + * plugins at the same time.  Any tracking of cache behavior should be done
    3.67 + * inside copies created by the plugin.
    3.68 + */
    3.69 +enum VMSCommNodeType   
    3.70 + {                     
    3.71 +   SystemNode = 1,
    3.72 +   MainMemNode,
    3.73 +   CacheNode,
    3.74 +   ProcessorNode
    3.75 + };
    3.76 +
    3.77 +/*This is the common node, which contains a list of pointers to the
    3.78 + * parents (above in the hierarchy), and a list of pointers to children.
    3.79 + *It also has its own type, and a payload that holds the information for
    3.80 + * that type of node.  The payload has to be cast to the appropriate
    3.81 + * version of the structures defined below.
    3.82 + */
    3.83 +typedef struct _VMSCommNode VMSCommNode;
    3.84 +struct _VMSCommNode
    3.85 + { enum VMSCommNodeType nodeType;
    3.86 +   VMSCommNode **parents;
    3.87 +   int32         numParents;
    3.88 +   VMSCommNode **children;
    3.89 +   int32         numChildren;
    3.90 +   void         *contents;
    3.91 + };
    3.92 +
    3.93 +/*A system node has a "main memory" child for each main-memory port in
    3.94 + * the system.  Therefore, the payload is empty for a system node.  But
    3.95 + * a system node type is defined here just for the sake of completeness and
    3.96 + * future changes.
    3.97 + */
    3.98 +typedef struct
    3.99 + {
   3.100 +    
   3.101 + }
   3.102 +VMSSystemNode;
   3.103 +
   3.104 +/*A main memory node is not completely defined yet (as of Nov 2012). It will
   3.105 + * eventually contain some means for determining which allocated chunks 
   3.106 + * of data reside in which physical memory ports.  However, it has a child
   3.107 + * for each cache directly connected to it.  At some point it will also have 
   3.108 + * some way to determine expected contention when multiple caches connect
   3.109 + * directly to the same main-memory port.
   3.110 + *Hence, at the moment, a main-memory node only has time to fulfill an
   3.111 + * incoming request.
   3.112 + */
   3.113 +typedef struct
   3.114 + { 
   3.115 +   int32 cyclesToFillRequest;
   3.116 + }
   3.117 +VMSMainMemNode;
   3.118 +
   3.119 +/*A cache node has the size of its line, and the 
   3.120 + * expected time to fulfill a miss request.  It also has the size of the
   3.121 + * cache.  Once experience is gained, some indication will be added for
   3.122 + * the efficiency of the cache -- IE, fully-associative is more efficient
   3.123 + * than direct-mapped.  This will help estimate how long data remains in
   3.124 + * a given cache before being overwritten.  A cache node has a set of
   3.125 + * pointers to the nodes above it, and separate set of pointers to the
   3.126 + * nodes below it.
   3.127 + *The node contains the hit time.
   3.128 + *The miss time is determined by the ancestor nodes.
   3.129 + */
   3.130 +typedef struct
   3.131 + {
   3.132 +   int32 lineSize;
   3.133 +   int32 cacheSize;
   3.134 +   int32 HitCycles;
   3.135 + }
   3.136 +VMSCacheNode;
   3.137 +
   3.138 +/*At the leaves are processor nodes, which contain the coreNum of that
   3.139 + * core.  The coreNum is stored inside animation slots, and inside slaves.
   3.140 + *This is the same coreNum saved inside an animation slot.  So, if the
   3.141 + * coreNum in one of these nodes matches the coreNum in an animation slot,
   3.142 + * then the ancestors of the node determine the connections from the
   3.143 + * animation slot to the cores attached to other animation slots that 
   3.144 + * previous work was assigned to.
   3.145 + */
   3.146 +typedef struct
   3.147 + {
   3.148 +   int32 coreNum;
   3.149 + }
   3.150 +VMSProcessorNode;
   3.151 +
   3.152 +#endif	/* _VMS__HW_DEPENDENT_H */
   3.153 +

     4.1 --- a/Services_Offered_by_VMS/Memory_Handling/vmalloc.c	Mon Sep 10 01:26:51 2012 -0700
     4.2 +++ b/Services_Offered_by_VMS/Memory_Handling/vmalloc.c	Fri Nov 09 04:20:31 2012 -0800
     4.3 @@ -206,7 +206,7 @@
     4.4  
     4.5  /*
     4.6   * This is sequential code, meant to only be called from the Master, not from
     4.7 - * any slave Slvs.
     4.8 + * any slave.
     4.9   * 
    4.10   *May 2012
    4.11   *ToDo: Improve speed, by using built-in leading 1 detector to calc free-list
    4.12 @@ -322,6 +322,7 @@
    4.13           MEAS__Capture_Pre_Free_Point;
    4.14           
    4.15     MallocArrays* freeLists = _VMSMasterEnv->freeLists;
    4.16 +      //decrease addr, to point to the prolog
    4.17     MallocProlog *chunkToFree = (MallocProlog*)ptrToFree - 1;
    4.18     uint32 containerIdx;
    4.19     

     5.1 --- a/VMS.h	Mon Sep 10 01:26:51 2012 -0700
     5.2 +++ b/VMS.h	Fri Nov 09 04:20:31 2012 -0800
     5.3 @@ -174,6 +174,7 @@
     5.4     SlaveAssigner    slaveAssigner;
     5.5     RequestHandler   requestHandler;
     5.6     void            *semanticEnv;
     5.7 +   VMSCommNode     *commSystemTopNode; //performance info for assigner
     5.8     
     5.9        //Slave creation
    5.10     int32            numSlavesCreated;  //gives ordering to processor creation

     6.1 --- a/VMS__startup_and_shutdown.c	Mon Sep 10 01:26:51 2012 -0700
     6.2 +++ b/VMS__startup_and_shutdown.c	Fri Nov 09 04:20:31 2012 -0800
     6.3 @@ -88,185 +88,11 @@
     6.4   }
     6.5  
     6.6  
     6.7 -/*TODO: finish implementing
     6.8 - *This function returns information about the version of VMS, the language
     6.9 - * the program is being run in, its version, and information on the 
    6.10 - * hardware.
    6.11 - */
    6.12 -/*
    6.13 -char *
    6.14 -VMS_App__give_environment_string()
    6.15 +VMSCommNode *
    6.16 +VMS_SS__give_comm_hierarchy()
    6.17   {
    6.18 -   //--------------------------
    6.19 -    fprintf(output, "#\n# >> Build information <<\n");
    6.20 -    fprintf(output, "# GCC VERSION: %d.%d.%d\n",__GNUC__,__GNUC_MINOR__,__GNUC_PATCHLEVEL__);
    6.21 -    fprintf(output, "# Build Date: %s %s\n", __DATE__, __TIME__);
    6.22 -    
    6.23 -    fprintf(output, "#\n# >> Hardware information <<\n");
    6.24 -    fprintf(output, "# Hardware Architecture: ");
    6.25 -   #ifdef __x86_64
    6.26 -    fprintf(output, "x86_64");
    6.27 -   #endif //__x86_64
    6.28 -   #ifdef __i386
    6.29 -    fprintf(output, "x86");
    6.30 -   #endif //__i386
    6.31 -    fprintf(output, "\n");
    6.32 -    fprintf(output, "# Number of Cores: %d\n", NUM_CORES);
    6.33 -   //--------------------------
    6.34 -    
    6.35 -   //VMS Plugins
    6.36 -    fprintf(output, "#\n# >> VMS Plugins <<\n");
    6.37 -    fprintf(output, "# Language : ");
    6.38 -    fprintf(output, _LANG_NAME_);
    6.39 -    fprintf(output, "\n");
    6.40 -       //Meta info gets set by calls from the language during its init,
    6.41 -       // and info registered by calls from inside the application
    6.42 -    fprintf(output, "# Assigner: %s\n", _VMSMasterEnv->metaInfo->assignerInfo);
    6.43 -
    6.44 -   //--------------------------
    6.45 -   //Application
    6.46 -    fprintf(output, "#\n# >> Application <<\n");
    6.47 -    fprintf(output, "# Name: %s\n", _VMSMasterEnv->metaInfo->appInfo);
    6.48 -    fprintf(output, "# Data Set:\n%s\n",_VMSMasterEnv->metaInfo->inputSet);
    6.49 -    
    6.50 -   //--------------------------
    6.51 +   return _VMSMasterEnv->commSystemTopNode;
    6.52   }
    6.53 - */
    6.54 - 
    6.55 -/*This structure holds all the information VMS needs to manage a program.  VMS
    6.56 - * stores information about what percent of CPU time the program is getting, what
    6.57 - * language it uses, the request handlers to call for its slaves, and so on.
    6.58 - */
    6.59 -/*
    6.60 -typedef struct
    6.61 - { void               *semEnv;
    6.62 -   RequestHdlrFnPtr    requestHandler;
    6.63 -   SlaveAssignerFnPtr  slaveAssigner;
    6.64 -   int32               numSlavesLive;
    6.65 -   void               *resultToReturn;
    6.66 -  
    6.67 -   TopLevelFnPtr   seedFnPtr;
    6.68 -   void           *dataForSeed;
    6.69 -   bool32          executionIsComplete;
    6.70 -   pthread_mutex_t doneLock;
    6.71 -   pthread_cond_t  doneCond;
    6.72 - }
    6.73 -VMSProcess;
    6.74 -*/
    6.75 -
    6.76 -         
    6.77 -/*
    6.78 -void
    6.79 -VMS_App__start_VMS_running()
    6.80 - {
    6.81 -   create_masterEnv();
    6.82 -   
    6.83 -   #ifdef DEBUG__TURN_ON_SEQUENTIAL_MODE
    6.84 -      //Nothing else to create for sequential mode
    6.85 -   #else
    6.86 -      create_the_coreCtlr_OS_threads();
    6.87 -   #endif    
    6.88 - }
    6.89 -*/
    6.90 -
    6.91 -/*A pointer to the startup-function for the language is given as the last
    6.92 - * argument to the call.  Use this to initialize a program in the language.
    6.93 - * This creates a data structure that encapsulates the bookkeeping info
    6.94 - * VMS uses to track and schedule a program run.
    6.95 - */
    6.96 -/*
    6.97 -VMSProcess *
    6.98 -VMS_App__spawn_program_on_data_in_Lang( TopLevelFnPtr prog_seed_fn, void *data,
    6.99 -                                    LangInitFnPtr langInitFnPtr )
   6.100 - { VMSProcess *newProcess;
   6.101 -   newProcess = malloc( sizeof(VMSProcess) );
   6.102 -   newProcess->doneLock = PTHREAD_MUTEX_INITIALIZER;
   6.103 -   newProcess->doneCond = PTHREAD_COND_INITIALIZER;
   6.104 -   newProcess->executionIsComplete = FALSE;
   6.105 -   newProcess->numSlavesLive = 0;
   6.106 -   
   6.107 -   newProcess->dataForSeed = data;
   6.108 -   newProcess->seedFnPtr   = prog_seed_fn;
   6.109 -   
   6.110 -      //The language's spawn-process function fills in the plugin function-ptrs in
   6.111 -      // the VMSProcess struct, gives the struct to VMS, which then makes and
   6.112 -      // queues the seed SlaveVP, which starts processors made from the code being
   6.113 -      // animated.
   6.114 -    
   6.115 -   (*langInitFnPtr)( newProcess );  
   6.116 -   
   6.117 -   return newProcess;
   6.118 - }
   6.119 -*/
   6.120 -
   6.121 -/*When all SlaveVPs owned by the program-run associated to the process have
   6.122 - * dissipated, then return from this call.  There is no language to cleanup,
   6.123 - * and VMS does not shutdown..  but the process bookkeeping structure,
   6.124 - * which is used by VMS to track and schedule the program, is freed.
   6.125 - *The VMSProcess structure is kept until this call collects the results from it,
   6.126 - * then freed.  If the process is not done yet when VMS gets this
   6.127 - * call, then this call waits..  the challenge here is that this call comes from
   6.128 - * a live OS thread that's outside VMS..  so, inside here, it waits on a 
   6.129 - * condition..  then it's a VMS thread that signals this to wake up..
   6.130 - *First checks whether the process is done, if yes, calls the clean-up fn then
   6.131 - * returns the result extracted from the VMSProcess struct.
   6.132 - *If process not done yet, then performs a wait (in a loop to be sure the
   6.133 - * wakeup is not spurious, which can happen).  VMS registers the wait, and upon
   6.134 - * the process ending (last SlaveVP owned by it dissipates), then VMS signals
   6.135 - * this to wakeup.  This then calls the cleanup fn and returns the result.
   6.136 - */
   6.137 -/*
   6.138 -void *
   6.139 -VMS_App__give_results_when_done_for( VMSProcess *process )
   6.140 - { void *result;
   6.141 -   
   6.142 -   pthread_mutex_lock( process->doneLock );
   6.143 -   while( !(process->executionIsComplete) )
   6.144 -    {
   6.145 -      pthread_cond_wait( process->doneCond,
   6.146 -                         process->doneLock );
   6.147 -    }
   6.148 -   pthread_mutex_unlock( process->doneLock );
   6.149 -   
   6.150 -   result = process->resultToReturn;
   6.151 -   
   6.152 -   VMS_int__cleanup_process_after_done( process );
   6.153 -   free( process );  //was malloc'd above, so free it here
   6.154 -   
   6.155 -   return result;
   6.156 - }
   6.157 -*/
   6.158 -
   6.159 -/*Turns off the VMS system, and frees all data associated with it.  Does this
   6.160 - * by creating shutdown SlaveVPs and inserting them into animation slots.
   6.161 - * Will probably have to wake up sleeping cores as part of this -- the fn that
   6.162 - * inserts the new SlaveVPs should handle the wakeup..
   6.163 - */
   6.164 -/*
   6.165 -void
   6.166 -VMS_SS__shutdown(); //already defined -- look at it
   6.167 -
   6.168 -void
   6.169 -VMS_App__shutdown()
   6.170 - {
   6.171 -   for( cores )
   6.172 -    { slave = VMS_int__create_new_SlaveVP( endOSThreadFn, NULL );
   6.173 -      VMS_int__insert_slave_onto_core( SlaveVP *slave, coreNum );
   6.174 -    }
   6.175 - }
   6.176 -*/
   6.177 -
   6.178 -/* VMS_App__start_VMS_running();
   6.179 -
   6.180 -   VMSProcess matrixMultProcess;
   6.181 -   
   6.182 -   matrixMultProcess =
   6.183 -    VMS_App__spawn_program_on_data_in_Lang( &prog_seed_fn, data, Vthread_lang );
   6.184 -   
   6.185 -   resMatrix = VMS_App__give_results_when_done_for( matrixMultProcess );
   6.186 -   
   6.187 -   VMS_App__shutdown();
   6.188 - */
   6.189  
   6.190  void
   6.191  create_masterEnv()
   6.192 @@ -316,6 +142,8 @@
   6.193     _VMSMasterEnv->allAnimSlots    = allAnimSlots;
   6.194     _VMSMasterEnv->measHistsInfo = NULL; 
   6.195  
   6.196 +   _VMSMasterEnv->commSystemTopNode = VMS_SS__create_comm_system();
   6.197 +      
   6.198     //============================= MEASUREMENT STUFF ========================
   6.199        
   6.200           MEAS__Make_Meas_Hists_for_Susp_Meas;

     7.1 --- a/__brch__Common_ancestor	Mon Sep 10 01:26:51 2012 -0700
     7.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
     7.3 @@ -1,34 +0,0 @@
     7.4 -A HW branch for:
     7.5 -
     7.6 -generic MultiCore machines with x86 64bit instruction set
     7.7 -
     7.8 -This branch shouldn't be used, except as a lazy fall-back.  Instead, try out other branches tuned to specific hardware platforms to find the one that performs best on your machine.  Use the "exe_time_vs_task_size" project to generate curves of overhead, and compare result from various branches.
     7.9 -
    7.10 -Note, if this branch is used, then NUM_CORES in VMS_HW_specific_defs.h file has to be updated with the number of cores in your machine
    7.11 -
    7.12 -
    7.13 -========  Background on branch naming  =========
    7.14 -
    7.15 -There are two kinds of branchs: ones used to develop features, and ones tuned to particular hardware.  A given HW branch may combine features from several feature-branches, picking and choosing among them.
    7.16 -
    7.17 -After Feb 2012, branches are named by the scheme:
    7.18 -
    7.19 -feat__<feat_descr>__<HW_feat_dev_on>
    7.20 -
    7.21 -HW__<desc_of_HW_brch_tuned_for>
    7.22 -
    7.23 -where <HW_feat_dev_on> and <desc_of_HW_brch_tuned_for> follow the pattern:
    7.24 -
    7.25 -<num_socket> x <num_cores>_<Manuf>_<special_features>
    7.26 -
    7.27 -Examples:
    7.28 -
    7.29 -feat__exp_array_malloc
    7.30 -
    7.31 -feat__rand_backoff__4x10_Intel_WestmereEx
    7.32 -
    7.33 -HW__1x4_Intel_SandyBridge
    7.34 -
    7.35 -HW__4x10_Intel_WestmereEx
    7.36 -
    7.37 -HW__1x4_AMD_mobile

     8.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     8.2 +++ b/__brch__Dev__comm_system	Fri Nov 09 04:20:31 2012 -0800
     8.3 @@ -0,0 +1,27 @@
     8.4 +A branch for developing the communication system information, which is given by VMS to the plugin during startup.  The assigner uses the info to make decisions about which animation slot to assign work to.
     8.5 +
     8.6 +========  Background on branch naming  =========
     8.7 +
     8.8 +There are two kinds of branchs: ones used to develop features, and ones tuned to particular hardware.  A given HW branch may combine features from several feature-branches, picking and choosing among them.
     8.9 +
    8.10 +After Feb 2012, branches are named by the scheme:
    8.11 +
    8.12 +feat__<feat_descr>__<HW_feat_dev_on>
    8.13 +
    8.14 +HW__<desc_of_HW_brch_tuned_for>
    8.15 +
    8.16 +where <HW_feat_dev_on> and <desc_of_HW_brch_tuned_for> follow the pattern:
    8.17 +
    8.18 +<num_socket> x <num_cores>_<Manuf>_<special_features>
    8.19 +
    8.20 +Examples:
    8.21 +
    8.22 +feat__exp_array_malloc
    8.23 +
    8.24 +feat__rand_backoff__4x10_Intel_WestmereEx
    8.25 +
    8.26 +HW__1x4_Intel_SandyBridge
    8.27 +
    8.28 +HW__4x10_Intel_WestmereEx
    8.29 +
    8.30 +HW__1x4_AMD_mobile