#include "InfoStream.h"
#include "main.h"
#include "BOCgroup.h"
#include "ProxyMgr.decl.h"
#include "ProxyMgr.h"
#include "PatchMap.inl"
#include "ProxyPatch.h"
#include "ComputeMap.h"
#include "HomePatch.h"
#include <string.h>
#include "ProcessorPrivate.h"
#include "packmsg.h"
#include "Priorities.h"
#include <alloca.h>
#include <malloc.h>
#include <map>
#include <vector>
#include <algorithm>
#include "ComputeNonbondedMICKernel.h"
#include "SimParameters.h"
#include "Node.h"
#include "Debug.h"
#include "ProxyMgr.def.h"

Macros
#define	MIN_DEBUG_LEVEL 2

#define	ALLOCA(TYPE, NAME, SIZE) TYPE NAME = (TYPE ) alloca((SIZE)*sizeof(TYPE))

#define	MAX_INTERNODE 1

#define	HOMEPATCH_TREE_BRFACTOR 2

Functions
	PACK_MSG (ProxySpanningTreeMsg, PACK(patch);PACK(node);PACK_RESIZE(tree);)

static void	outputProxyTree (ProxyTree &ptree, int np)

static int	compLoad (const void a, const void b)

static void	processCpuLoad ()

static int	noInterNode (int p)

Variables
int	proxySendSpanning = 0

int	proxyRecvSpanning = 0

int	proxySpanDim = 4

int	inNodeProxySpanDim = 16

double *	cpuloads

static int *	procidx = NULL

static double	averageLoad = 0.0

Macro Definition Documentation

#define ALLOCA	(	TYPE,
		NAME,
		SIZE
	)	TYPE NAME = (TYPE ) alloca((SIZE)*sizeof(TYPE))

Definition at line 43 of file ProxyMgr.C.

Referenced by ProxyMgr::recvNodeAwareSpanningTree().

#define HOMEPATCH_TREE_BRFACTOR 2

Definition at line 1921 of file ProxyMgr.C.

Referenced by NodeProxyMgr::createSTForHomePatches().

#define MAX_INTERNODE 1

Definition at line 609 of file ProxyMgr.C.

Referenced by ProxyMgr::buildSpanningTree0().

#define MIN_DEBUG_LEVEL 2

Definition at line 40 of file ProxyMgr.C.

Function Documentation

static int compLoad	(	const void *	a,
		const void *	b
	)

static

Definition at line 698 of file ProxyMgr.C.

Referenced by processCpuLoad().

 {
   int i1 = *(int *)a;
   int i2 = *(int *)b;
   double d1 = cpuloads[i1];
   double d2 = cpuloads[i2];
   if (d1 < d2) 
     return 1;
   else if (d1 == d2) 
     return 0;
   else 
     return -1;
   // sort from high to low
 }

static int noInterNode ( int p )

static

Definition at line 729 of file ProxyMgr.C.

Referenced by ProxyMgr::buildSpanningTree0().

 {
   int exclude = 0;
   if(CkNumPes()<1025)
     exclude = 5;
   else if(CkNumPes()<4097)
     exclude = 10;
   else if(CkNumPes()<8193)
     exclude = 40;
   else if(CkNumPes()<16385)
     exclude = 40;
   else
     exclude = 80;
   for (int i=0; i<exclude; i++) if (procidx[i] == p) return 1;
 //  if (cpuloads[p] > averageLoad) return 1;
   return 0;
 }

static void outputProxyTree	(	ProxyTree &	ptree,
		int	np
	)

static

Definition at line 612 of file ProxyMgr.C.

References plist, ProxyTree::proxylist, ResizeArray< T >::size(), and sort.

                                                      {
         FILE *ofp = fopen("patch_proxylist.txt", "w");
         std::vector<int> plist;
         for(int i=0; i<np; i++) {
                 fprintf(ofp, "%d: ", i);
                 int listlen = ptree.proxylist[i].size();
                 fprintf(ofp, "#%d ", listlen);
                 plist.clear();
                 for(int j=0; j<listlen; j++) {
                         plist.push_back(ptree.proxylist[i][j]);
                 }
                 std::sort(plist.begin(), plist.end());
                 for(int j=0; j<listlen; j++) {
                         fprintf(ofp, "%d ", plist[j]);
                 }
                 fprintf(ofp, "\n");
         }
         fclose(ofp);
 }

PACK_MSG	(	ProxySpanningTreeMsg	,
		PACK(patch);PACK(node);PACK_RESIZE(tree);
	)

Definition at line 51 of file ProxyMgr.C.

                                               {
 
   int msg_size = 0;
   msg_size += sizeof(msg->node);
   msg_size += sizeof(msg->patch);
 
   int j;
   for ( j = 0; j < Results::maxNumForces; ++j ) {
     int array_size = msg->forceList[j]->size();
     msg_size += sizeof(array_size);
     msg_size += array_size * sizeof(char);    
     msg_size = ALIGN_8 (msg_size);
     Force* f = msg->forceList[j]->begin();
     int nonzero_count = 0;
     for ( int i = 0; i < array_size; ++i ) {
       if ( f[i].x != 0. || f[i].y != 0. || f[i].z != 0. ) { ++nonzero_count; }
     }
     msg_size += nonzero_count * sizeof(Vector);
   }
 
   void *msg_buf = CkAllocBuffer(msg,msg_size);
   char *msg_cur = (char *)msg_buf;
 
   CmiMemcpy((void*)msg_cur,(void*)(&(msg->node)),sizeof(msg->node));
   msg_cur += sizeof(msg->node);
   CmiMemcpy((void*)msg_cur,(void*)(&(msg->patch)),sizeof(msg->patch));
   msg_cur += sizeof(msg->patch);
   for ( j = 0; j < Results::maxNumForces; ++j ) {
     int array_size = msg->forceList[j]->size();
     *(int *) msg_cur = array_size;
     msg_cur += sizeof(int);
     char *nonzero = msg_cur;
     msg_cur += array_size * sizeof(char);
     msg_cur = (char *)ALIGN_8 (msg_cur);
     Vector *farr = (Vector *)msg_cur;
     Force* f = msg->forceList[j]->begin();
 
     for ( int i = 0; i < array_size; ++i ) {
       if ( f[i].x != 0. || f[i].y != 0. || f[i].z != 0. ) {
         nonzero[i] = 1;
         farr->x = f[i].x;
         farr->y = f[i].y;
         farr->z = f[i].z;
         farr ++;
       } else {
         nonzero[i] = 0;
       }
     }
     msg_cur = (char *) farr;      
   }
 
   delete msg;
   return msg_buf;
 }

static void processCpuLoad ( )

static

Definition at line 713 of file ProxyMgr.C.

References compLoad().

Referenced by ProxyMgr::buildSpanningTree0().

 {
   int i;
   if (!procidx) {
     procidx = new int[CkNumPes()];
   }
   for (i=0; i<CkNumPes(); i++) procidx[i] = i;
   qsort(procidx, CkNumPes(), sizeof(int), compLoad);
 
   double averageLoad = 0.0;
   for (i=0; i<CkNumPes(); i++) averageLoad += cpuloads[i];
   averageLoad /= CkNumPes();
 //  iout << "buildSpanningTree1: no intermediate node on " << procidx[0] << " " << procidx[1] << endi;
 
 }