Example #1
0
int getEdgeID(int node1, int node2, int nodesPerElem, int dim) {
  switch(dim){
  case 2: {
    switch(nodesPerElem){
    case 3:
      {
	static int edgeFromNode[3][3]={{-1,0,2},{0,-1,1},{2,1,-1}};
	return edgeFromNode[node1][node2];
      }
      break;
    default:
      CkAbort("This shape is not yet implemented");
    };
    break;
  }
  case 3: {
    switch(nodesPerElem){
    case 4:
      {
	static int edgeFromNode[4][4]={{-1,0,1,2},{0,-1,3,4},{1,3,-1,5},{2,4,5,-1}};
	return edgeFromNode[node1][node2];
      }
      break;
    default:
      CkAbort("This shape is not yet implemented");
    };
    break;
  }
  default:
    CkAbort("This dimension not yet implemented");
  };
  return -1;
}
Example #2
0
CDECL int IDXL_Get_source(IDXL_t l_t,int localNo) {
	const char *caller="IDXL_Get_source"; IDXLAPI(caller); 
	IDXL &l=IDXL_Chunk::get(caller)->lookup(l_t,caller);
	const IDXL_Rec *rec=l.getRecv().getRec(localNo);
	if (rec==NULL) CkAbort("IDXL_Get_source called on non-ghost entity!");
	if (rec->getShared()>1) CkAbort("IDXL_Get_source called on multiply-shared entity!");
	return rec->getChk(0);
}
Example #3
0
  Main(CkArgMsg* m) {
    if ( (m->argc<3) || (m->argc>8) ) {
      CkPrintf("%s [array_size] [block_size]\n", m->argv[0]);
      CkPrintf("OR %s [array_size] [block_size] maxiterations\n", m->argv[0]);
      CkPrintf("OR %s [array_size_X] [array_size_Y] [array_size_Z] [block_size_X] [block_size_Y] [block_size_Z]\n", m->argv[0]);
      CkPrintf("OR %s [array_size_X] [array_size_Y] [array_size_Z] [block_size_X] [block_size_Y] [block_size_Z] maxiterations\n", m->argv[0]);
      CkAbort("Abort");
    }

    iterations = 0;
    // store the main proxy
    mainProxy = thisProxy;

    if(m->argc <=4 ) {
      arrayDimX = arrayDimY = arrayDimZ = atoi(m->argv[1]);
      blockDimX = blockDimY = blockDimZ = atoi(m->argv[2]); 
    }
    else if (m->argc <=8) {
      arrayDimX = atoi(m->argv[1]);
      arrayDimY = atoi(m->argv[2]);
      arrayDimZ = atoi(m->argv[3]);
      blockDimX = atoi(m->argv[4]); 
      blockDimY = atoi(m->argv[5]); 
      blockDimZ = atoi(m->argv[6]);
    }

    maxiterations = MAX_ITER;
    if(m->argc==4)
      maxiterations = atoi(m->argv[3]); 
    if(m->argc==8)
      maxiterations = atoi(m->argv[7]); 

    if (arrayDimX < blockDimX || arrayDimX % blockDimX != 0)
      CkAbort("array_size_X % block_size_X != 0!");
    if (arrayDimY < blockDimY || arrayDimY % blockDimY != 0)
      CkAbort("array_size_Y % block_size_Y != 0!");
    if (arrayDimZ < blockDimZ || arrayDimZ % blockDimZ != 0)
      CkAbort("array_size_Z % block_size_Z != 0!");

    numChareX = arrayDimX / blockDimX;
    numChareY = arrayDimY / blockDimY;
    numChareZ = arrayDimZ / blockDimZ;

    // print info
    CkPrintf("\nSTENCIL COMPUTATION WITH NO BARRIERS\n");
    CkPrintf("Running Jacobi on %d processors with (%d, %d, %d) chares\n", CkNumPes(), numChareX, numChareY, numChareZ);
    CkPrintf("Array Dimensions: %d %d %d\n", arrayDimX, arrayDimY, arrayDimZ);
    CkPrintf("Block Dimensions: %d %d %d\n", blockDimX, blockDimY, blockDimZ);

    // Create new array of worker chares
    array = CProxy_Jacobi::ckNew(numChareX, numChareY, numChareZ);

    //Start the computation
    array.run();
    startTime = CkWallTimer();
  }
Example #4
0
void alignmentTest(std::vector<TestMessage*> &allMsgs, const std::string &identifier) {

  int alignHdr = std::numeric_limits<int>::max();
  int alignEnv = std::numeric_limits<int>::max();
  int alignUsr = std::numeric_limits<int>::max();
  int alignVar1 = std::numeric_limits<int>::max();
  int alignVar2 = std::numeric_limits<int>::max();
  int alignPrio = std::numeric_limits<int>::max();

  for (int i = 0; i < allMsgs.size(); i++) {
    TestMessage *msg = allMsgs[i];
    envelope *env = UsrToEnv(msg);

#if CMK_USE_IBVERBS | CMK_USE_IBUD
    intptr_t startHdr = (intptr_t) &(((infiCmiChunkHeader *) env)[-1]);
#else
    intptr_t startHdr = (intptr_t) BLKSTART(env);
#endif
    intptr_t startEnv = (intptr_t) env;
    intptr_t startUsr = (intptr_t) msg;
    intptr_t startVar1 = (intptr_t) msg->varArray1;
    intptr_t startVar2 = (intptr_t) msg->varArray2;
    intptr_t startPrio = (intptr_t) env->getPrioPtr();

    if (! (startHdr < startEnv && startEnv < startUsr &&
           startUsr <= startVar1 && startVar1 < startVar2 &&
           startVar2 < startPrio)) {
      CkAbort("Charm++ fatal error. Pointers to component fields "
              "of a message do not follow an increasing order.\n");
    }
    alignHdr = std::min(alignCheck(startHdr), alignHdr);
    alignEnv = std::min(alignCheck(startEnv), alignEnv);
    alignUsr = std::min(alignCheck(startUsr), alignUsr);
    alignVar1 = std::min(alignCheck(startVar1), alignVar1);
    alignVar2 = std::min(alignCheck(startVar2), alignVar2);
    alignPrio = std::min(alignCheck(startPrio), alignPrio);
  }

  CkPrintf("Alignment information at the %s:\n", identifier.c_str());
  CkPrintf("Chunk header aligned to %d bytes\n", alignHdr);
  CkPrintf("Envelope aligned to %d bytes\n", alignEnv);
  CkPrintf("Start of user data aligned to %d bytes\n", alignUsr);
  CkPrintf("First varsize array aligned to %d bytes\n", alignVar1);
  CkPrintf("Second varsize array aligned to %d bytes\n", alignVar2);
  CkPrintf("Priority field aligned to %d bytes\n", alignPrio);

  if (alignEnv >= ALIGN_BYTES && alignUsr >= ALIGN_BYTES &&
      alignVar1 >= ALIGN_BYTES && alignVar2 >= ALIGN_BYTES &&
      alignHdr >= ALIGN_BYTES && alignPrio >= ALIGN_BYTES) {
    CkPrintf("All passed.\n");
  }
  else {
    CkAbort("Alignment requirements failed.\n");
  }

}
Example #5
0
void marshall_init(void)
{
  if (marshallInitVal!=0x1234567)
	CkAbort("initcall marshallInit never got called!\n");
  if (eltInitVal!=0x54321)
	CkAbort("initcall marshallElt::eltInit never got called!\n");
  reflector++;
  for (int i=0;i<numElements;i++)
  	arrayProxy[(i+reflector)%numElements].reflectMarshall(i);
  arrayProxy[0].done();
}
    Main(CkArgMsg* m) {
	totalTime = new float[CkNumPes()];
	totalObjs = new int[CkNumPes()];
	for(int i=0;i<CkNumPes();i++) 
	{
		totalTime[i] = 0.0;
		totalObjs[i] = 0;
	}
        if (m->argc < 3) {
          CkPrintf("%s [array_size] [block_size]\n", m->argv[0]);
          CkAbort("Abort");
        }
        totalIterTime = 0.0;
        lbdOverhead = 0.0;

        // set iteration counter to zero
        iterations=0;

        // store the main proxy
        mainProxy = thisProxy;

        array_height = atoi(m->argv[1]);
	      array_width = atoi(m->argv[2]);
        block_height = atoi(m->argv[3]);
	block_width = atoi(m->argv[4]);
        if (array_width < block_width || array_width % block_width != 0)
          CkAbort("array_size % block_size != 0!");

        num_chare_rows = array_height / block_height;
        num_chare_cols = array_width / block_width;
        // print info
        //CkPrintf("Running Jacobi on %d processors with (%d,%d) elements\n", CkNumPes(), num_chare_rows, num_chare_cols);

	total_iterations = 200;
	if (m->argc > 5) {
	  total_iterations = atoi(m->argv[5]);
	}

        // Create new array of worker chares
        array = CProxy_Jacobi::ckNew(num_chare_cols, num_chare_rows);

        // save the total number of worker chares we have in this simulation
        num_chares = num_chare_rows*num_chare_cols;


        //Start the computation
        perIterStartTime = CkWallTimer();
        progStartTime = CkWallTimer();
        recieve_count = 0;
        array.begin_iteration();


    }
Example #7
0
void
FEMchunk::readField(int fid, void *nodes, const char *fname)
{
  const IDXL_Layout &dt = IDXL_Layout_List::get().get(fid,"FEM_Read_field");
  int type = dt.type;
  int width = dt.width;
  int offset = dt.offset;
  int distance = dt.distance;
  int skew = dt.skew;
  FILE *fp = fopen(fname, "r");
  if(fp==0) {
    CkError("Cannot open file %s for reading.\n", fname);
    CkAbort("Exiting");
  }
  char str[80];
  char* pos;
  const char* fmt;
  int i, j, curline;
#if FEM_FORTRAN
  curline = 1;
#else
  curline = 0;
#endif
  switch(type) {
    case FEM_INT: fmt = "%d%n"; break;
    case FEM_REAL: fmt = "%f%n"; break;
    case FEM_DOUBLE: fmt = "%lf%n"; break;
    default: CkAbort("FEM_Read_field doesn't support that data type");
  }
  FEM_Mesh *cur_mesh=getMesh("FEM_Read_field");
  int nNodes=cur_mesh->node.size();
  for(i=0;i<nNodes;i++) {
    // skip lines to the next local node 
    // (FIXME: assumes nodes are in ascending global order, which they ain't)
    int target=cur_mesh->node.getGlobalno(i);
    for(j=curline;j<target;j++)
      fgets(str,80,fp);
    curline = target+1;
    fgets(str,80,fp);
    int curnode, numchars;
    sscanf(str,"%d%n",&curnode,&numchars);
    pos = str + numchars;
    if(curnode != target) {
      CkError("Expecting info for node %d, got %d\n", target, curnode);
      CkAbort("Exiting");
    }
    for(j=0;j<width;j++) {
      sscanf(pos, fmt, &IDXL_LAYOUT_DEREF(unsigned char,nodes,i,j), &numchars);
      pos += numchars;
    }
  }
  fclose(fp);
}
Example #8
0
// Check the quality of triangle i
void checkTriangle(myGlobals &g, int i)
{
  double area=calcArea(g,i);
  if (area<0) {
    CkError("Triangle %d of chunk %d is inverted! (area=%g)\n",
	    i,FEM_My_partition(),area);
    CkAbort("Inverted triangle");
  }
  if (area<1.0e-15) {
    CkError("Triangle %d of chunk %d is a sliver!\n",i,FEM_My_partition());
    CkAbort("Sliver triangle");
  }
}
Example #9
0
    void start_test()
    {
        inline_group *gl = g.ckLocalBranch();
        if (gl->called)
            CkAbort("Inline test was called already?\n");

        g[CkMyPe()].try_inline();

        if (!gl->called)
            CkAbort("Inline test should have been called by now!\n");

        gl->called = false;
        megatest_finish();
    }
Example #10
0
// This is a local function.
// AMPI_Win_put will act as a wrapper: pack the input parameters, copy the
//   remote data to local, and call this function of the involved WIN object
int win_obj::put(void *orgaddr, int orgcnt, int orgunit,
                 MPI_Aint targdisp, int targcnt, int targunit) {
    if(initflag == 0) {
        CkAbort("Put to non-existing MPI_Win\n");
        return WIN_ERROR;
    }
    int totalsize = targdisp+targcnt*targunit;
    if(totalsize > (winSize)) {
        CkAbort("Put size exceeds MPI_Win size\n");
        return WIN_ERROR;
    }

    return WIN_SUCCESS;
}
Example #11
0
int win_obj::iget(int orgcnt, int orgunit,
                  MPI_Aint targdisp, int targcnt, int targunit) {
    if(initflag == 0) {
        CkAbort("Get from non-existing MPI_Win\n");
        return WIN_ERROR;
    }

    if((targdisp+targcnt*targunit) > (winSize)) {
        CkAbort("Get size exceeds MPI_Win size\n");
        return WIN_ERROR;
    }
    // Call the RMA operation here!!!

    return WIN_SUCCESS;
}
Example #12
0
/**
 Create a stencil with this number of elements, 
  and these adjacent elements.
 
 In C, userEnds[i] is the 0-based one-past-last element;
 in F90, userEnds[i] is the 1-based last element, which
 amounts to the same thing!
  
 In C, userAdj is 0-based; in F90, the even elType fields
 are 0-based, and the odd elemNum fields are 1-based.
*/
FEM_Ghost_Stencil::FEM_Ghost_Stencil(int elType_, int n_,bool addNodes_,
	const int *userEnds,
	const int *userAdj,
	int idxBase)
	:elType(elType_), n(n_), addNodes(addNodes_),  
	 ends(new int[n]), adj(new int[2*userEnds[n-1]])
{
	int i;
	int lastEnd=0;
	for (i=0;i<n;i++) {
		ends[i]=userEnds[i];
		if (ends[i]<lastEnd) {
			CkError("FEM_Ghost_Stencil> ends array not monotonic!\n"
				"   ends[%d]=%d < previous value %d\n",
				i,ends[i],lastEnd);
			CkAbort("FEM_Ghost_Stencil> ends array not monotonic");
		}
		lastEnd=ends[i];
	}
	int m=ends[n-1];
	for (i=0;i<m;i++) {
		adj[2*i+0]=userAdj[2*i+0];
		adj[2*i+1]=userAdj[2*i+1]-idxBase;
	}
}
Example #13
0
  TestDriver(CkArgMsg* args) {
    N = atoi(args->argv[1]);
    numElementsPerPe = atoll(args->argv[2]);
    localTableSize = (1l << N) / numElementsPerPe;
		if (!localTableSize)
			CkAbort("Table size is too small, or number of chares is too large\n");
    tableSize = localTableSize * CkNumPes() * numElementsPerPe;

    CkPrintf("Global table size   = 2^%d * %d = %lld words\n",
             N, CkNumPes(), tableSize);
    CkPrintf("Number of processors = %d\nNumber of updates = %lld\n",
             CkNumPes(), 4 * tableSize);

    driverProxy = thishandle;
    // Create the chares storing and updating the global table
    updater_array   = CProxy_Updater::ckNew(CkNumPes() * numElementsPerPe);
    int dims[2] = {CkNumNodes(), CkNumPes() / CkNumNodes()};
    CkPrintf("Aggregation topology: %d %d\n", dims[0], dims[1]);

    // Instantiate communication library group with a handle to the client
    //aggregator =
    //  CProxy_ArrayMeshStreamer<dtype, int, Updater, SimpleMeshRouter>
    //  ::ckNew(numMsgsBuffered, 2, dims, updater_array, 1);

    delete args;
  }
Example #14
0
	//Compute the face closest to this location
	// FIXME: this uses an O(nFaces) algorithm; using boxes it could be made O(1)
	int getLocFace(const CkVector3d &loc,double minTol) const {
		double minTolSq=minTol*minTol;
		int min=-1;
		for (int f=0;f<nFaces;f++) {
			double distSq=loc.distSqr(faceCen[f]);
			if (distSq<minTolSq) {
				//return f;
				if (min!=-1) 
					CkAbort("FEM_Linear_Periodicity> Several 'closest' faces found!");
				min=f;
			}
		}
		if (min==-1)
			CkAbort("FEM_Linear_Periodicity> No matching face found!");
		return min;
	}
Example #15
0
void* CkPriorityPtr(void *msg)
{
#if CMK_ERROR_CHECKING
  if (UsrToEnv(msg)->getPriobits() == 0) CkAbort("Trying to access priority bits, but none was allocated");
#endif
  return UsrToEnv(msg)->getPrioPtr();
}
Example #16
0
int BulkAdapt::lock_3D_region(int elemID, int elemType, int edgeID, double prio, RegionID *lockRegionID)
{ // Lock region defined by all elements surrounding edgeID, i.e. the "star"
  int numElemsToLock=0, success=-1;
  adaptAdj *elemsToLock;
  adaptAdj startElem(partitionID, elemID, elemType);

  BULK_DEBUG(CkPrintf("[%d] BulkAdapt::lock_3D_region acquiring list of elements to build locked region.\n",
		      partitionID));
  get_elemsToLock(startElem, &elemsToLock, edgeID, &numElemsToLock);

  success = localShadow->lockRegion(numElemsToLock, elemsToLock, lockRegionID, prio);
  free(elemsToLock);
  if (success==2) { // got the lock free and clear; refine the element
    BULK_DEBUG(CkPrintf("[%d] BulkAdapt::lock_3D_region: Lock (%d,%d,%6.4f) obtained.\n", partitionID,
			lockRegionID->chunkID, lockRegionID->localID, lockRegionID->prio));
  }
  else if (success==1) { // lock is pending
    BULK_DEBUG(CkPrintf("[%d] BulkAdapt::lock_3D_region: Lock (%d,%d,%6.4f) pending.\n", partitionID,
			lockRegionID->chunkID, lockRegionID->localID, lockRegionID->prio));
  }
  else if (success==0) { // lock failed
    BULK_DEBUG(CkPrintf("[%d] BulkAdapt::edge_bisect_3D: Lock (%d,%d,%6.4f) not obtained.\n", partitionID,
			lockRegionID->chunkID, lockRegionID->localID, lockRegionID->prio));
  }
  else {
    CkPrintf("Lock status=%d\n", success);
    CkAbort("Invalid lock return status!\n");
  }
  return success;
}
Example #17
0
main::main(CkArgMsg * m)
{ 
  if(m->argc != 3)
  {
    CkPrintf("Usage: pgm <nsamples> <nchares>\n");
    CkAbort("");
  }

  ns = atoi(m->argv[1]);
  nc = atoi(m->argv[2]);
  delete m;

  starttime = CkWallTimer();

  //FIXME
  //CkGroupID gid = CkCreatePropMap();
  //CProxy_piPart  arr = CProxy_piPart::ckNew(nc, gid);
  CProxy_piPart  arr = CProxy_piPart::ckNew(nc);

  CkPrintf("At time %lf, array created.\n", (CkWallTimer()-starttime));

#if USE_REDUCTION
  arr.setReductionClient(reductionHandler,(void *)NULL);
#endif
  arr.compute(ns);
  responders = nc;
  count = 0;
  mainhandle = thishandle; // readonly initialization
  CkPrintf("At time %lf, main exits.\n", (CkWallTimer()-starttime));
}
Example #18
0
	//Compute the node on this face closest to this location
	// This is O(nPer), but nPer is tiny (<10) so it's quite fast enough.
	int getLocNode(int faceNo,const CkVector3d &loc,double minTol) const {
		double minTolSq=minTol*minTol;
		int min=-1;
		for (int n=0;n<nPer;n++) {
			double distSq=loc.distSqr(getNodeLoc(getNode(faceNo,n)));
			if (distSq<minTolSq) {
				//return n;
				if (min!=-1) 
					CkAbort("FEM_Linear_Periodicity> Several 'closest' nodes found!");
				min=n;
			}
		}
		if (min==-1)
			CkAbort("FEM_Linear_Periodicity> No matching node found!");
		return getNode(faceNo,min);
	}
Example #19
0
void
processExceptionCharm()
//******************************************************************************
//  Process an exception from the Charm++ runtime system
//! \details See Josuttis, The C++ Standard Library - A Tutorial and Reference,
//!    2nd Edition, 2012.
//! \author J. Bakosi
//******************************************************************************
{
    try {
        throw;      // rethrow exception to deal with it here
    }
    // Catch tk::Exception
    catch ( tk::Exception& qe ) {
        if (!CkMyPe()) qe.handleException();
    }
    // Catch std::exception and transform it into tk::Exception without
    // file:line:func information
    catch ( std::exception& se ) {
        tk::Exception qe( se.what() );
        if (!CkMyPe()) qe.handleException();
    }
    // Catch uncaught exception
    catch (...) {
        tk::Exception qe( "Non-standard exception" );
        if (!CkMyPe()) qe.handleException();
    }

    // Tell the runtime system to exit with a message
    CkAbort( "Exception caught" );
}
Example #20
0
main::main(CkArgMsg *msg)
{
  CmiPrintf("Megatest is running on %d nodes %d processors. \n", CkNumNodes(), CkNumPes());
  int argc = msg->argc;
  char **argv = msg->argv;
  int numtests, i;
  delete msg;
  mainhandle = thishandle;
  if (nTests<=0)
    CkAbort("Megatest: No tests registered-- is MEGATEST_REGISTER_TEST malfunctioning?");
  for (i=0; i<nTests; i++)
    (tests[i].initializer)();
  test_bank_size = nTests;
  next_test_index = 0;
  next_test_number = 0;
  test_negate_skip=0;
  test_repeat = 0;
  for (i=1; i<argc; i++) {
    if (strcmp(argv[i],"-only")==0)
      test_negate_skip = 1;
    if (strcmp(argv[i],"-repeat")==0)
      test_repeat = 1;
  }
  num_tests_to_skip = argc;
  tests_to_skip = argv;
  CProxy_main(thishandle).start();
}
Example #21
0
void
tempotest_UserClass::doSendRecv(void)
{
  CkChareID otherid;
  char inbuf[11], outbuf[11];
  
  IdMsg *idmsg = new IdMsg(thishandle);
  CProxy_tempotest_main mainproxy(mainid);
  mainproxy.getid(idmsg);

  ckTempoRecv(1, &otherid, sizeof(CkChareID));
  
  for (int i=0; i<10; i++) {
    sprintf(outbuf, "UserClass!");
    sprintf(inbuf, "");
    ckTempoSend(i+2, outbuf, strlen(outbuf)+1, otherid);
    ckTempoRecv(i+2, inbuf, 11);
    if(strcmp(inbuf, "UserClass!")) {
      CkAbort("tempotest: Message corrupted!\n");
      mainproxy.Finish();
      return;
    }
  }
  mainproxy.Finish();
  delete this;
}
Example #22
0
/** A node is added inside a volume; interpolate from nodes of element; this
   uses n, nodes[4] or more, and coord 
*/
void FEM_Interpolate::FEM_InterpolateNodeInElement(NodalArgs args)
{
  if (nodeElementFnPtr) { // default is overridden
    nodeElementFnPtr(args, theMesh);
    return;
  }
  // do default interpolation
  // DEFAULT BEHAVIOR: Interpolate whatever user data is available, positioning
  // new point at coordinate average of surrounding element nodes

  CkVec<FEM_Attribute *>*attrs = (theMesh->node).getAttrVec();
  for (int i=0; i<attrs->size(); i++) {
    FEM_Attribute *a = (FEM_Attribute *)(*attrs)[i];
    if (a->getAttr() < FEM_ATTRIB_TAG_MAX) {
      FEM_DataAttribute *d = (FEM_DataAttribute *)a;
      if ((args.nNbrs >= 4) && (args.nNbrs <= 8)) {
	d->interpolate(args.nodes, args.n, args.nNbrs);
      }
      else {
	CkPrintf("ERROR: %d node elements not supported for node data interpolation.\n", args.nNbrs);
	CkAbort("ERROR: FEM_InterpolateNodeInElement\n");
      }
    }
  }
  return;
}
void RectMulticastStrategy::handleMessageForward(void *msg){
  
    envelope *env = (envelope *)msg;
    RECORD_RECV_STATS(getInstance(), env->getTotalsize(), env->getSrcPe());

    //Section multicast base message
    CkMcastBaseMsg *cbmsg = (CkMcastBaseMsg *)EnvToUsr(env);
    
    int status = cbmsg->_cookie.sInfo.cInfo.status;
    ComlibPrintf("[%d] In handleMessageForward %d\n", CkMyPe(), status);
    
    if(status == COMLIB_MULTICAST_NEW_SECTION)
        handleNewMulticastMessage(env);
    else {
        //status == COMLIB_MULTICAST_OLD_SECTION, use the cached section id
        ComlibSectionHashKey key(cbmsg->_cookie.pe, 
                                 cbmsg->_cookie.sInfo.cInfo.id);    
        
        ComlibRectSectionHashObject *obj;
        obj = sec_ht.get(key);
        
        if(obj == NULL)
            CkAbort("Destination indices is NULL\n");
#ifndef LOCAL_MULTI_OFF                
        localMulticast(env, obj);
#endif
        remoteMulticast(env, obj);
    }
}
Example #24
0
void edge::sanityCheck(chunk *c,edgeRef shouldRef)
{
  if (myRef!=shouldRef)
    CkAbort("REFINE2D edge has wrong ref");
  
  int nonNullElements=0;
  for (int i=0;i<2;i++) {
    // nodes[i].sanityCheck(c);
    if (!elements[i].isNull()) {
      elements[i].sanityCheck(c);
      nonNullElements++;
    }
  }
  if (!(nonNullElements==1 || nonNullElements==2))
    CkAbort("REFINE2D edge has unexpected number of neighbors!");
}
Example #25
0
void chunk::sanityCheck(void)
{
  int i;
  if (numElements<0 || (int)theElements.size()<numElements)
  	CkAbort("REFINE2D chunk elements insane!");
  if (numEdges<0 || (int)theEdges.size()<numEdges)
  	CkAbort("REFINE2D chunk edges insane!");
  if (numNodes<0 || (int)theNodes.size()<numNodes)
  	CkAbort("REFINE2D chunk nodes insane!");
  for (i=0;i<numElements;i++) {
    theElements[i].sanityCheck(this,elemRef(cid,i));
  }
  for (i=0;i<numEdges;i++) {
    theEdges[i].sanityCheck(this,edgeRef(cid,i));
  }
}
Example #26
0
void chunk::updateNodeCoords(int nNode, double *coord, int nEl)
{
  int i;

#if 1
  // do some error checking
  if (nEl != numElements || nNode != numNodes) {
    CkPrintf("ERROR: inconsistency in REFINE2D's updateNodeCoords on chunk %d:\n"
       "  your nEl (%d); my numElements (%d)\n"
       "  your nNode (%d); my numNodes (%d)\n",
       cid, nEl, numElements, nNode,numNodes);
    CkAbort("User code/library numbering inconsistency in REFINE2D");
  }
#endif  
  
  // update node coordinates from coord
  for (i=0; i<numNodes; i++){
    theNodes[i].init(coord[2*i], coord[2*i + 1]);
    CkPrintf("[tmr] Chunk %d Node %d %.8lf %.8lf \n",cid,i,theNodes[i].X(),theNodes[i].Y());
  }  
    
  // recalculate and cache new areas for each element
  for (i=0; i<numElements; i++){
    theElements[i].calculateArea();
    CkPrintf("[tmr] Chunk %d Element %d area = %.8lf \n",cid,i, theElements[i].getArea());
  }	
  sanityCheck();
}
Example #27
0
void rotest_group::start(void)
{
  if(rotest_check())
    CkAbort("rotest failed");
  CProxy_rotest_group rog(rotest_groupid);
  rog[0].done();
}
Example #28
0
/**
  Return a binary string containing the JPEG-compressed data of 
  this raster image, which is wid x ht pixels, and 
  each pixel bpp bytes (must be either 1, for greyscale; or 3, for RGB).
  
  quality controls the compression rate, from
  	quality == 0, tiny compressed image, very low quality
	quality == 100, huge compressed image, very high quality
  
  This code derived from the "example.c" that ships with libjpeg; 
  see that file for comments.
*/
std::string JPEGcompressImage(int wid,int ht,int bpp, const byte *image_data, int quality) {
  struct jpeg_compress_struct cinfo;
  JSAMPROW row_pointer[1];	/* pointer to JSAMPLE row[s] */
  int row_stride;		/* physical row width in image buffer */

  struct jpeg_error_mgr jerr;
  cinfo.err = jpeg_std_error(&jerr);
  /* Now we can initialize the JPEG compression object. */
  jpeg_create_compress(&cinfo);
  
  std::string ret;
  jpeg_stl_dest(&cinfo,&ret);

  cinfo.image_width = wid; 	/* image width and height, in pixels */
  cinfo.image_height = ht;
  
  while (cinfo.image_height>65000) {
  /* FUNKY HACK: 
  	JPEG library can't support images over 64K pixels.
	But we want tall-skinny images for 3D volume impostors.
	So we just *lie* to the JPEG library, and it'll interpret
	the image data as several side-by-side interleaved scanlines.
	The decompressor doesn't (necessarily!) need to change either...
  */
  	if (cinfo.image_height&1) {
		CkError("liveViz0 JPEGlib WARNING: cannot shrink odd image height %d\n",cinfo.image_height);
	}
  	cinfo.image_height/=2;
	cinfo.image_width*=2;
  }
  
  
  switch (bpp) {
  case 1:
  	cinfo.input_components = 1;		/* # of color components per pixel */
  	cinfo.in_color_space = JCS_GRAYSCALE; 	/* colorspace of input image */
	break;
  case 3:
  	cinfo.input_components = 3;		/* # of color components per pixel */
  	cinfo.in_color_space = JCS_RGB; 	/* colorspace of input image */
	break;
  default:
  	CkError("liveViz0's JPEGcompressImage: JPEGlib can only handle 1 or 3 bytes per pixel, not %d bpp\n",bpp);
	CkAbort("liveViz0's JPEGcompressImage: JPEGlib can only handle 1 or 3 bytes per pixel");
	break;
  }
  
  jpeg_set_defaults(&cinfo);
  jpeg_set_quality(&cinfo, quality, TRUE /* limit to baseline-JPEG values */);
  jpeg_start_compress(&cinfo, TRUE);
  row_stride = cinfo.image_width * bpp;	/* JSAMPLEs per row in image_buffer */
  while (cinfo.next_scanline < cinfo.image_height) {
    row_pointer[0] = (JSAMPLE *)(& image_data[cinfo.next_scanline * row_stride]);
    (void) jpeg_write_scanlines(&cinfo, row_pointer, 1);
  }
  jpeg_finish_compress(&cinfo);
  jpeg_destroy_compress(&cinfo);
  return ret;
}
Example #29
0
// handle GroupTable and data
void CkPupGroupData(PUP::er &p, CmiBool create)
{
	int numGroups, i;

	if (!p.isUnpacking()) {
	  numGroups = CkpvAccess(_groupIDTable)->size();
	}
	p|numGroups;
	if (p.isUnpacking()) {
	  if(CkMyPe()==0)  
            CkpvAccess(_numGroups) = numGroups+1; 
          else 
	    CkpvAccess(_numGroups) = 1;
	}
	DEBCHK("[%d] CkPupGroupData %s: numGroups = %d\n", CkMyPe(),p.typeString(),numGroups);

	GroupInfo *tmpInfo = new GroupInfo [numGroups];
	if (!p.isUnpacking()) {
	  for(i=0;i<numGroups;i++) {
		tmpInfo[i].gID = (*CkpvAccess(_groupIDTable))[i];
		TableEntry ent = CkpvAccess(_groupTable)->find(tmpInfo[i].gID);
		tmpInfo[i].MigCtor = _chareTable[ent.getcIdx()]->migCtor;
		tmpInfo[i].DefCtor = _chareTable[ent.getcIdx()]->defCtor;
		strncpy(tmpInfo[i].name,_chareTable[ent.getcIdx()]->name,255);
		//CkPrintf("[%d] CkPupGroupData: %s group %s \n", CkMyPe(), p.typeString(), tmpInfo[i].name);

		if(tmpInfo[i].MigCtor==-1) {
			char buf[512];
			sprintf(buf,"Group %s needs a migration constructor and PUP'er routine for restart.\n", tmpInfo[i].name);
			CkAbort(buf);
		}
	  }
  	}
	for (i=0; i<numGroups; i++) p|tmpInfo[i];

	for(i=0;i<numGroups;i++) 
	{
	  CkGroupID gID = tmpInfo[i].gID;
	  if (p.isUnpacking()) {
	    //CkpvAccess(_groupIDTable)->push_back(gID);
	    int eIdx = tmpInfo[i].MigCtor;
	    // error checking
	    if (eIdx == -1) {
	      CkPrintf("[%d] ERROR> Group %s's migration constructor is not defined!\n", CkMyPe(), tmpInfo[i].name); CkAbort("Abort");
	    }
	    void *m = CkAllocSysMsg();
	    envelope* env = UsrToEnv((CkMessage *)m);
		if(create)
		    CkCreateLocalGroup(gID, eIdx, env);
	  }   // end of unPacking
	  IrrGroup *gobj = CkpvAccess(_groupTable)->find(gID).getObj();
	  // if using migration constructor, you'd better have a pup
	  	if(!create)
			gobj->mlogData->teamRecoveryFlag = 1;
          gobj->pup(p);
         // CkPrintf("Group PUP'ed: gid = %d, name = %s\n",gobj->ckGetGroupID().idx, tmpInfo[i].name);
	}
	delete [] tmpInfo;
}
Example #30
0
void varsizetest_main::exit(varsizetest_Msg *m)
{
  if(!m->check())
    CkAbort("varsizetest failed!\n");
  delete m;
  delete this;
  megatest_finish();
}