102 static inline void hit_tileUpdateAcumCards(
void *newVarP) {
110 cardinality = cardinality * newVar->card[i];
111 newVar->origAcumCard[i] = cardinality;
113 newVar->acumCard = newVar->origAcumCard[0];
122 static inline size_t hit_tileOffset(
const void *varP) {
128 offset = offset + (
size_t)
hit_shapeSig(v->shape,i).begin * (size_t)v->origAcumCard[i+1];
140 result->shape =
hit_shape( 1, hit_sigStd(1) );
143 result->acumCard = 1;
144 result->origAcumCard[0] = 1;
145 result->origAcumCard[1] = 1;
146 result->qstride[0] = 1;
149 result->memStatus = HIT_MS_NOT_OWNER;
153 result->baseExtent =
size;
154 result->hierDepth = 0;
165 HitPTile newVar = (HitPTile)newVarP;
169 fprintf(stderr,
"CTRL DomainInternal, baseExtent: %d, hierDepth: %d, numDims: %d\n", (
unsigned int)baseExtent, hierDepth, numDims);
174 newVar->baseExtent = baseExtent;
175 newVar->memStatus = HIT_MS_NOMEM;
176 newVar->hierDepth = (char)hierDepth;
179 newVar->memPtr = NULL;
182 va_start(ap, numDims);
183 for(i=0; i<numDims; i++) {
184 newVar->card[i] = va_arg(ap,
int);
186 if ( newVar->card[i] < 1 ) { *newVar =
HIT_TILE_NULL;
return; }
190 newVar->qstride[i] = 1;
195 hit_tileUpdateAcumCards(newVar);
202 HitPTile newVar = (HitPTile)newVarP;
206 fprintf(stderr,
"CTRL DomainShapeInternal, baseExtent: %d, hierDepth: %d\n", (
unsigned int)baseExtent, hierDepth);
210 newVar->shape =
shape;
211 newVar->baseExtent = baseExtent;
212 newVar->memStatus = HIT_MS_NOMEM;
213 newVar->hierDepth = (char)hierDepth;
216 newVar->memPtr = NULL;
223 newVar->qstride[i] = 1;
227 newVar->qstride[0] = 1;
231 hit_tileUpdateAcumCards(newVar);
244 HitPTile newVar = (HitPTile)newVarP;
248 if ( newVar->memStatus == HIT_MS_NULL || newVar->acumCard==0 )
return;
252 if ( newVar->memStatus == HIT_MS_OWNER ){
253 hit_errInternal(__FUNCTION__,
"Trying to reallocate a Tile: ",name,file,numLine);
258 fprintf(stderr,
"CTRL Alloc Internal: Mem size: %d x %d = %d\n", newVar->acumCard,
259 (
unsigned int)newVar->baseExtent,
260 (
unsigned int)newVar->acumCard * (
unsigned int)newVar->baseExtent);
265 hit_vmalloc(newVar->memPtr, (
size_t)newVar->acumCard * newVar->baseExtent);
266 newVar->data = newVar->memPtr;
269 if ( newVar->memStatus == HIT_MS_NOT_OWNER
270 || newVar->memStatus == HIT_MS_NOMEM ) {
273 for (i=0; i<
hit_shapeDims(newVar->shape); i++) newVar->qstride[i] = 1;
276 hit_tileUpdateAcumCards(newVar);
280 newVar->memStatus = HIT_MS_OWNER;
288 static inline int hit_sigBlockSizeInternal(
HitSig a ) {
306 displacement[dim] = coords[dim] * hit_sigBlockSizeInternal(
hit_tileDimSig(*root,dim) );
313 if ( root->hierDepth == HIT_NONHIERARCHICAL )
return;
317 memset(ind, 0, (
size_t)
hit_tileDims(*root)*
sizeof(
int));
320 for(i=0; i < root->acumCard; i++) {
324 offset += (
size_t)ind[j] * (size_t)root->qstride[j] * (
size_t)root->origAcumCard[j+1];
325 HitTile *child = (
HitTile *)( (
char *)root->data + offset * root->baseExtent );
333 ind[j] = (ind[j]+1) % (root->card[j]);
334 if ( ind[j] != 0 )
break;
354 if ( var->memStatus == HIT_MS_NULL || var->memStatus == HIT_MS_NOMEM )
return;
363 while ( ancestor->memStatus != HIT_MS_OWNER ) ancestor = ancestor->ref;
365 if ( ancestor != var ) {
370 var = &reducedDomainVar[0];
374 if ( var->memStatus == HIT_MS_NULL )
return;
377 if( var->hierDepth == HIT_NONHIERARCHICAL ) {
378 switch( var->memStatus ) {
381 ptr=(
char *)var->data;
382 for(i=0; i<var->acumCard; i++) {
383 memcpy(ptr, value, var->baseExtent);
384 ptr += var->baseExtent;
389 case HIT_MS_NOT_OWNER:
391 memset(ind,0, (
size_t)
hit_shapeDims(var->shape)*
sizeof(
int));
393 for(i=0;i<var->acumCard;i++) {
397 offset += (size_t)ind[j] * (
size_t)var->qstride[j] * (size_t)var->origAcumCard[j+1];
400 memcpy( (
char *)var->data+offset*var->baseExtent, value, var->baseExtent );
405 ind[j]=(ind[j]+1)% (var->card[j]);
406 if (ind[j]!=0)
break;
413 default:
hit_errInternal(
"tileFill",
"Unknown memory state in variable to fill:", name, file, numLine);
418 else if (var->hierDepth > 0) {
422 var->hierDepth = (char)((
int)(child -> hierDepth) + 1);
427 var->childSize[i] = hit_sigBlockSizeInternal(
hit_tileDimSig( *child, i ) );
431 if ( child->hierDepth ) var->childSize[i] *= child->childSize[i];
434 if ( child->hierDepth )
436 + child->childBegin[i];
442 switch( var->memStatus ) {
456 case HIT_MS_NOT_OWNER:
458 memset(ind,0, (
size_t)
hit_shapeDims(var->shape)*
sizeof(
int));
460 for(i=0;i<var->acumCard;i++) {
464 offset += (size_t)ind[j] * (
size_t)var->qstride[j] * (size_t)var->origAcumCard[j+1];
467 HitTile *pos = (
HitTile *)((
char *)var->data+offset*var->baseExtent);
471 pos->ancestor = (
HitTile*) varP;
485 ind[j]=(ind[j]+1)% (var->card[j]);
486 if (ind[j]!=0)
break;
493 default:
hit_errInternal(
"tileFill",
"Unknown memory state in variable to fill:", name, file, numLine);
498 else hit_errInternal(
"tileFill",
"Negative value in hierarchy-level of variable:", name, file, numLine);
508 if ( root->memStatus == HIT_MS_NULL || root->memStatus == HIT_MS_NOMEM )
return NULL;
514 int arrayCoord = (int)floor(( coords[dim] - root->childBegin[dim] ) / (double)root->childSize[dim]);
522 if ( root->hierDepth == HIT_NONHIERARCHICAL )
return root;
529 offset += (size_t)thisLevelTileCoords[j] * (
size_t)root->qstride[j] * (size_t)root->origAcumCard[j+1];
540 if ( root->memStatus == HIT_MS_NULL || root->memStatus == HIT_MS_NOMEM )
return NULL;
546 int arrayCoord = (int)floor(( coords[dim] - root->childBegin[dim] ) / (double)root->childSize[dim]);
558 offset += (size_t)thisLevelTileCoords[j] * (
size_t)root->qstride[j] * (size_t)root->origAcumCard[j+1];
562 if ( root->hierDepth == HIT_NONHIERARCHICAL )
return (
char *)root->data + offset * root->baseExtent;
574 const int fileFormat,
578 const int formatSize1,
const int formatSize2,
579 const char *fileName,
580 const char *debugVarName,
581 const char *debugCodeFile,
591 switch ( fileMode ) {
592 case HIT_FILE_READ:
break;
595 ok = open( fileName, O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR );
596 if (ok == -1)
hit_errInternal(__FUNCTION__,
"Creating file", fileName, debugCodeFile, debugCodeLine);
601 hit_errInternal(__FUNCTION__,
"Unknown file mode", debugVarName, debugCodeFile, debugCodeLine);
610 if ( var->memStatus == HIT_MS_NULL || var->memStatus == HIT_MS_NOMEM )
return 1;
617 char patternRead[32];
618 char patternWrite[32];
622 fich = fopen(fileName,
"r+");
624 hit_errInternal(__FUNCTION__,
"Fail opening file", fileName, debugCodeFile, debugCodeLine);
627 if ( fileFormat != HIT_FILE_BINARY ) {
630 sprintf( patternRead,
"%%0%dd\n", formatSize1 );
631 sprintf( patternWrite,
"%%0%dd\n", formatSize1 );
634 sprintf( patternRead,
"%%0%dld\n", formatSize1 );
635 sprintf( patternWrite,
"%%0%dld\n", formatSize1 );
638 sprintf( patternRead,
"%%0%df\n", formatSize1 );
639 sprintf( patternWrite,
"%%0%d.%df\n", formatSize1, formatSize2 );
642 sprintf( patternRead,
"%%0%dlf\n", formatSize1 );
643 sprintf( patternWrite,
"%%0%d.%dlf\n", formatSize1, formatSize2 );
646 hit_errInternal(__FUNCTION__,
"Unknown file type for variable", debugVarName, debugCodeFile, debugCodeLine);
661 for (rootTile = var; rootTile->ref != NULL; rootTile = rootTile->ref);
664 for ( ; rootTile->ancestor != NULL; rootTile = rootTile->ancestor);
669 for ( ; rootTile->ref != NULL; rootTile = rootTile->ref);
673 if ( var->unpadded != NULL ) var = var->unpadded;
677 int *rootAcumCard = rootTile->origAcumCard;
686 if ( var->memStatus == HIT_MS_OWNER ) ptr = var->data;
688 else for( i=0; i<
hit_shapeDims(var->shape); i++ ) ind[i] = 0;
691 for( i=0; i<var->acumCard; i++ ) {
693 if ( var->memStatus == HIT_MS_NOT_OWNER ) {
696 offset += (size_t)ind[j] * (
size_t)var->qstride[j] * (size_t)var->origAcumCard[j+1];
698 ptr = (
char *)var->data + offset * (
size_t)var->baseExtent;
705 file_offset += indsh[j] * rootAcumCard[j+1];
710 if ( fileFormat == HIT_FILE_BINARY )
711 ok = fseek( fich, file_offset * (
long)var->baseExtent, SEEK_SET );
714 ok = fseek( fich, file_offset * (formatSize1 + 1), SEEK_SET );
719 hit_errInternal(__FUNCTION__,
"Positioning in file", fileName, debugCodeFile, debugCodeLine);
726 if ( fileFormat == HIT_FILE_BINARY ) {
727 switch ( fileMode ) {
728 case HIT_FILE_READ: result = (int)fread( ptr, var->baseExtent, 1, fich );
730 case HIT_FILE_WRITE: result = (int)fwrite( ptr, var->baseExtent, 1, fich );
736 switch ( fileMode ) {
739 case HIT_FILE_INT: result = fscanf( fich, patternRead, (
int*)(ptr) );
741 case HIT_FILE_LONG: result = fscanf( fich, patternRead, (
long*)(ptr) );
743 case HIT_FILE_FLOAT: result = fscanf( fich, patternRead, (
float*)(ptr) );
745 case HIT_FILE_DOUBLE: result = fscanf( fich, patternRead, (
double*)(ptr) );
752 case HIT_FILE_INT: result = fprintf( fich, patternWrite, *(
int*)(ptr) );
754 case HIT_FILE_LONG: result = fprintf( fich, patternWrite, *(
long*)(ptr) );
756 case HIT_FILE_FLOAT: result = fprintf( fich, patternWrite, *(
float*)(ptr) );
758 case HIT_FILE_DOUBLE: result = fprintf( fich, patternWrite, *(
double*)(ptr) );
766 if ( fileMode == HIT_FILE_READ ) {
769 hit_errInternal(__FUNCTION__,
"Reading data in file", fileName, debugCodeFile, debugCodeLine);
772 else if ( fileFormat == HIT_FILE_BINARY ) {
775 hit_errInternal(__FUNCTION__,
"Writing binary data in file", fileName, debugCodeFile, debugCodeLine);
778 else if ( result != formatSize1+1 ) {
780 hit_errInternal(__FUNCTION__,
"Writing text data in file", fileName, debugCodeFile, debugCodeLine);
784 if ( var->memStatus == HIT_MS_OWNER ) ptr = (
char *)ptr + var->baseExtent;
787 if ( var->memStatus == HIT_MS_NOT_OWNER ) {
790 ind[j] = (ind[j]+1) % (var->card[j]);
792 if ( ind[j] != 0 )
break;
828 if ( oldVar->memStatus == HIT_MS_NULL )
return;
834 hit_vmalloc(newVar->memPtr, (
size_t)newVar->acumCard * newVar->baseExtent );
836 newVar->data = newVar->memPtr;
837 newVar->memStatus = HIT_MS_OWNER;
840 for (i=0; i<
hit_shapeDims(newVar->shape); i++) newVar->qstride[i] = 1;
843 hit_tileUpdateAcumCards(newVar);
846 if(oldVar->memStatus==HIT_MS_NOMEM)
return;
850 newVar->ref =
const_cast<HitTile*
>(oldVar);
852 newVar->ref = oldVar;
856 if( oldVar->hierDepth > 0 ) {
857 switch( oldVar->memStatus ) {
859 case HIT_MS_NOMEM:
return;
863 for(i=0;i<oldVar->acumCard;i++) {
864 hit_tileCloneInternal( (
char *)newVar->data+(
size_t)i*newVar->baseExtent, (
char *)oldVar->data+(
size_t)i*oldVar->baseExtent, name, file, numLine);
869 case HIT_MS_NOT_OWNER:
877 default:
hit_errInternal(
"tileClone",
"Unknown memory state in source variable:", name, file, numLine);
882 else if( oldVar->hierDepth == HIT_NONHIERARCHICAL ) {
883 switch( oldVar->memStatus ) {
885 case HIT_MS_NOMEM:
return;
888 case HIT_MS_OWNER: memcpy(newVar->memPtr, oldVar->memPtr,
889 newVar->baseExtent * (
size_t)newVar->acumCard);
893 case HIT_MS_NOT_OWNER:
901 default:
hit_errInternal(
"tileClone",
"Unknown memory state in source variable:", name, file, numLine);
906 else hit_errInternal(
"tileClone",
"Negative value in hierarchy-level field of variable:", name, file, numLine);
914 switch( oldVar->memStatus ) {
924 newVar->ref =
const_cast<HitTile*
>(oldVar);
926 newVar->ref = oldVar;
930 case HIT_MS_NOT_OWNER:
931 newVar->ref = oldVar->ref;
935 hit_errInternal(
"tileSelectInternal",
"Unknown memory state in source tile.",
"", __FILE__, __LINE__);
957 if (oldVar->memStatus == HIT_MS_NULL)
return 1;
962 memcpy(newVarP, oldVarP,
sizeof(
HitTile));
964 if ( oldVar->memStatus != HIT_MS_NOMEM ) newVar->memStatus = HIT_MS_NOT_OWNER;
971 newVar->hierDepth=oldVar->hierDepth;
972 memcpy(newVar->childSize, oldVar->childSize,
HIT_MAXDIMS*
sizeof(
int));
973 memcpy(newVar->childBegin, oldVar->childBegin,
HIT_MAXDIMS*
sizeof(
int));
986 if ( out == HIT_OUTOFBOUNDS_CHECK
991 || newSig.
end > oldVar->card[i]
996 fprintf(stderr,
"CTRL tileSelect: Out of bounds in signature %d: (%d,%d,%d) -> (%d,%d,%d)\n", i, newSig.
begin, newSig.
end, newSig.
stride,
hit_shapeSig(oldVar->shape,i).begin,
hit_shapeSig(oldVar->shape,i).end,
hit_shapeSig(oldVar->shape,i).stride);
1006 offset = offset + (size_t)(newSig.
begin * oldVar->qstride[i]) * (size_t)(oldVar->origAcumCard[i+1]);
1017 newVar->qstride[i] = newSig.
stride*oldVar->qstride[i];
1023 newVar->card[i] = oldVar->card[i];
1024 newVar->qstride[i] = oldVar->qstride[i];
1029 newVar->baseExtent = oldVar->baseExtent;
1032 hit_tileUpdateAcumCards(newVar);
1035 memcpy(newVar->origAcumCard,
1036 oldVar->origAcumCard,
1037 (
size_t)(hit_shapeDims(newVar->shape)+1)*
sizeof(
int)
1047 if ( oldVar->memStatus == HIT_MS_NOMEM ) {
1048 newVar->data = NULL;
1049 newVar->memStatus = HIT_MS_NOMEM;
1052 newVar->data = (
char*)(oldVar->data) + offset * oldVar->baseExtent;
1053 newVar->memStatus = HIT_MS_NOT_OWNER;
1086 return HIT_OUTOFBOUNDS_CHECK;
1089 return HIT_NO_OUTOFBOUNDS_CHECK;
1105 || newSig.
end >= tile->card[i]){
1107 return HIT_OUTOFBOUNDS_CHECK;
1110 return HIT_NO_OUTOFBOUNDS_CHECK;
1131 if (oldVar->memStatus == HIT_MS_NULL)
return 1;
1135 memcpy(newVarP, oldVarP,
sizeof(
HitTile));
1137 if ( oldVar->memStatus != HIT_MS_NOMEM ) newVar->memStatus = HIT_MS_NOT_OWNER;
1145 if( out == HIT_OUTOFBOUNDS_CHECK
1149 printf(
"---- TileSelect, Out of Bounds Check! CTRL 1\n");
1153 if( out == HIT_OUTOFBOUNDS_CHECK
1157 printf(
"---- TileSelect, Out of Bounds Check! CTRL 2: %d in [%d:%d:%d] is false\n",
1168 printf(
"---- TileSelect, Out of Bounds Check! CTRL 3\n");
1176 newVar->hierDepth=oldVar->hierDepth;
1177 memcpy(newVar->childSize, oldVar->childSize,
HIT_MAXDIMS*
sizeof(
int));
1178 memcpy(newVar->childBegin, oldVar->childBegin,
HIT_MAXDIMS*
sizeof(
int));
1187 #if ( __GNUC__ == 4 && __GNUC_MINOR__ == 6 )
1189 memcpy( &newSig, &
hit_shapeSig( sh, i ),
sizeof(newSig) );
1197 if ( out == HIT_OUTOFBOUNDS_CHECK
1214 fprintf(stderr,
"CTRL tileSelect: Out of bounds in global signature %d: (%d,%d,%d)\n", i, newSig.
begin, newSig.
end, newSig.
stride);
1215 fprintf(stderr,
"CTRL tileSelect: Old var signature %d: (%d,%d,%d)\n", i,
hit_shapeSig(oldVar->shape,i).begin,
hit_shapeSig(oldVar->shape,i).end,
hit_shapeSig(oldVar->shape,i).stride);
1231 offset = offset + (size_t)(newSig.
begin * oldVar->qstride[i]) * (size_t)(oldVar->origAcumCard[i+1]);
1243 newVar-> qstride[i] = newSig.
stride*oldVar->qstride[i];
1248 newVar->card[i] = oldVar->card[i];
1249 newVar->qstride[i] = oldVar->qstride[i];
1254 newVar->baseExtent = oldVar->baseExtent;
1257 hit_tileUpdateAcumCards(newVar);
1260 memcpy(newVar->origAcumCard,
1261 oldVar->origAcumCard,
1262 (
size_t)(hit_shapeDims(newVar->shape)+1)*
sizeof(
int)
1271 if ( oldVar->memStatus == HIT_MS_NOMEM ) {
1272 newVar->memStatus = HIT_MS_NOMEM;
1273 newVar->data = NULL;
1276 newVar->memStatus = HIT_MS_NOT_OWNER;
1277 newVar->data = (
char*)(oldVar->data) + offset * oldVar->baseExtent;
1307 for (i=0; i<numReductions; i++) {
1308 if (newVar->card[i] != 1) {
1315 for (i=numReductions; i<
hit_shapeDims(newVar->shape); i++) {
1317 newVar->card[i-numReductions] = newVar->card[i];
1318 newVar->origAcumCard[i-numReductions] = newVar->origAcumCard[i];
1319 newVar->qstride[i-numReductions] = newVar->qstride[i];
1321 newVar->origAcumCard[i-numReductions] = newVar->origAcumCard[i];
1322 hit_shapeDimsSet(newVar->shape,hit_shapeDims(newVar->shape) - numReductions);
1343 newVar->card[i+numExpansions] = newVar->card[i];
1344 newVar->origAcumCard[i+numExpansions] = newVar->origAcumCard[i];
1345 newVar->qstride[i+numExpansions] = newVar->qstride[i];
1350 for (i=0; i<numExpansions; i++) {
1351 newVar->card[i] = 1;
1352 newVar->origAcumCard[i] = 1;
1353 newVar->qstride[i] = 1;
1372 const char *name,
const char *file,
int numLine) {
1373 HitPTile shadow = (HitPTile)sh;
1374 HitPTile shadowOrig = shadow->ref;
1382 const char *strFromTo[2] = {
"FROM",
"TO" };
1383 fprintf(stderr,
"CTRL Starting UPDATE %s ANCESTOR\n", strFromTo[ fromTo ]);
1386 if ( shadow->memStatus == HIT_MS_NULL )
return;
1389 if ( shadow->memStatus != HIT_MS_OWNER
1391 ( shadowOrig->memStatus != HIT_MS_OWNER && shadowOrig->memStatus != HIT_MS_NOT_OWNER )
1408 fprintf(stderr,
"CTRL UPDATE %s ANCESTOR: Intersection detects an expanded tile, CREATING SELECTION\n", strFromTo[ fromTo ]);
1411 shadow = &reducedDomainShadow;
1424 chunkSize = (size_t)1;
1429 && shadow->card[dim] == shadowOrig->card[dim]
1431 && shadowOrig->qstride[dim] == 1 && shadow->qstride[dim] == 1
1433 && shadow->origAcumCard[dim+1] == shadowOrig->origAcumCard[dim+1]
1435 && shadow->origAcumCard[dim] == (int)chunkSize * shadow->card[dim]
1438 chunkSize = chunkSize * (size_t)shadow->card[ dim ];
1446 && shadowOrig->qstride[dim] == 1 ) {
1448 fprintf(stderr,
"CTRL UPDATE %s ANCESTOR: Contiguous after dimension %d\n", strFromTo[ fromTo ], dim);
1450 chunkSize = chunkSize * (size_t)shadow->card[ dim ];
1453 size_t chunkMemSize = shadow->baseExtent * chunkSize;
1456 fprintf(stderr,
"CTRL dim=%d, chunkSize=%d, Shadow: OrigAcumCard=%d\n", dim, (
unsigned int)chunkSize, shadow->origAcumCard[0]);
1460 for(i=0; i< dim+1; i++) ind[i] = 0;
1464 HitTile *sourceTile, *targetTile;
1468 int sourceStart, targetStart;
1469 int relativeBegin = 0;
1472 int *relativeStrideSource, *relativeStrideTarget;
1475 relativeBegin = relativeBegin +
1477 * shadowOrig->origAcumCard[i+1]
1483 relativeStride[ i ] = shadowOrig->qstride[i] *
1485 relativeNoStride[ i ] = 1;
1487 if ( fromTo == HIT_UPDATE_FROM ) {
1488 sourceTile = shadowOrig;
1489 targetTile = shadow;
1490 sourceStart = relativeBegin;
1492 relativeStrideSource = relativeStride;
1493 relativeStrideTarget = relativeNoStride;
1496 sourceTile = shadow;
1497 targetTile = shadowOrig;
1499 targetStart = relativeBegin;
1500 relativeStrideSource = relativeNoStride;
1501 relativeStrideTarget = relativeStride;
1507 if ( sourceTile->hierDepth == HIT_NONHIERARCHICAL ) {
1509 memcpy( (
char*)(targetTile->data) + (
size_t)targetStart * shadow->baseExtent,
1510 (
char*)(sourceTile->data) + (
size_t)sourceStart * shadow->baseExtent,
1511 shadow->baseExtent * chunkSize
1517 for(i=0; i< (int)((
size_t)shadow->acumCard/(
size_t)shadow->card[dim]/chunkSize); i++) {
1519 int sourcePos = sourceStart;
1520 int targetPos = targetStart;
1525 for(j=0; j< dim; j++) {
1530 sourcePos = sourcePos + ind[j] * relativeStrideSource[j] * sourceTile->origAcumCard[j+1];
1531 targetPos = targetPos + ind[j] * relativeStrideTarget[j] * targetTile->origAcumCard[j+1];
1534 fprintf(stderr,
"CTRL UPDATE-%s sourcePos=%d\n", strFromTo[ fromTo ], sourcePos);
1535 fprintf(stderr,
"CTRL UPDATE-%s targetPos=%d\n", strFromTo[ fromTo ], targetPos);
1538 char *sourcePointer = (
char *)(sourceTile->data)
1539 + (size_t)sourcePos * shadow->baseExtent;
1540 char *targetPointer = (
char *)(targetTile->data)
1541 + (
size_t)targetPos * shadow->baseExtent;
1543 size_t loopJumpSource = (size_t)( relativeStrideSource[dim] * sourceTile->origAcumCard[dim+1] ) * shadow->baseExtent;
1544 size_t loopJumpTarget = (size_t)( relativeStrideTarget[dim] * targetTile->origAcumCard[dim+1] ) * shadow->baseExtent;
1549 for ( innerLoopIdx = 0; innerLoopIdx < shadow->card[dim];
1551 sourcePointer += loopJumpSource,
1552 targetPointer += loopJumpTarget
1554 memcpy( targetPointer, sourcePointer, chunkMemSize );
1559 for(j=dim-1; j>=0; j--) {
1561 if (ind[j]==shadow->card[j]) ind[j]=0;
1568 else if ( shadowOrig->hierDepth > 0 ) {
1569 for(i=0; i< (int)((
size_t)shadow->acumCard/chunkSize); i++) {
1574 for(j=0; j< dim+1; j++) {
1575 sourcePos = sourcePos + ind[j] * sourceTile->qstride[dim] * sourceTile->origAcumCard[j+1];
1576 targetPos = targetPos + ind[j] * targetTile->qstride[dim] * targetTile->origAcumCard[j+1];
1579 fprintf(stderr,
"CTRL UPDATE-%s sourcePos=%d\n", strFromTo[ fromTo ], sourcePos);
1580 fprintf(stderr,
"CTRL UPDATE-%s targetPos=%d\n", strFromTo[ fromTo ], targetPos);
1584 for( k=0; k < chunkSize; k++ ) {
1586 (
char *)targetTile->data + (k+(
size_t)targetPos) * shadow->baseExtent,
1587 (
char *)sourceTile->data + (k+(
size_t)sourcePos) * shadow->baseExtent,
1588 name, file, numLine);
1592 for(j=dim; j>=0; j--) {
1594 if (ind[j]==shadow->card[j]) ind[j]=0;
1600 else hit_errInternal(__FUNCTION__,
"Negative value in hierarchy-level field of variable:", name, file, numLine);
1625 HitShape newShp=HIT_SHAPE_NULL_STATIC;
1643 HitShape newShp=HIT_SHAPE_NULL_STATIC;
1665 if ( var->memStatus == HIT_MS_OWNER) {
1667 for(i=0;i<var->acumCard;i++) {
1669 ptr = (
char *)ptr + var->baseExtent;
1724 hit_warnInternal(__FUNCTION__,
"Sorry, Glue for tiles with more than one dimension not yet implemented.",
"", __FILE__, __LINE__ );
1747 memcpy( out->data, inA->data, inA->baseExtent * (
size_t)
hit_tileCard( *inA ) );
1748 memcpy( (
char *)(out->data) + inA->baseExtent * (
size_t)
hit_tileCard(*inA), inB->data, inB->baseExtent * (
size_t)
hit_tileCard( *inB ) );
HitPTile HIT_TILE_NULL_POINTER
#define hit_shape(nd,...)
#define hit_tileDimStride(var, dim)
int hit_tileFileInternal(void *varP, const int fileFormat, const int fileMode, const int tileMode, const int type, const int formatSize1, const int formatSize2, const char *fileName, const char *debugVarName, const char *debugCodeFile, int debugCodeLine)
int hit_tileReduceDims(void *newVar, int numReductions)
void hit_tileGlue(void *tileInA, void *tileInB, void *tileOut)
void hit_tileFillUpdateArrayCoordinatesRec(HitTile *root, int coords[HIT_MAXDIMS])
HitShape hit_shapeIntersect(HitShape sh1, HitShape sh2)
#define hit_shapeDimsSet(shape, value)
void hit_tileSingleInternal(void *tileP, void *varP, size_t size)
void hit_tileDomainShapeInternal(void *newVarP, size_t baseExtent, int hierDepth, HitShape shape)
HitShape hit_tileShapeTile2Array(void *var, HitShape sh)
#define hit_tileDims(var)
int hit_shapeCmp(HitShape sh1, HitShape sh2)
#define hit_tileDimSig(var, dim)
int hit_tileCheckBoundaryArrayCoords(const void *tileP, HitShape sh)
#define hit_tileAlloc(var)
void hit_tileFillInternal(void *varP, void *value, const char *name, const char *file, int numLine)
#define hit_sigIn(sig, ind)
void hit_tileDomainInternal(void *newVarP, size_t baseExtent, int hierDepth, int numDims,...)
#define hit_tileCard(var)
int hit_tileSelectInternal(void *newVarP, const void *oldVarP, HitShape sh, int out)
void hit_tileSelectRefPointer(HitTile *newVar, const HitTile *oldVar)
void hit_tileCloneInternal(void *newVarP, const void *oldVarP, const char *name, const char *file, int numLine)
#define hit_tileDimCard(var, dim)
#define hit_shapeDims(shape)
#define hit_cShapeNvertices(shape)
#define hit_tileDimBegin(var, dim)
Hitmap functions to allocate memory.
void * hit_mtileElemAtArrayCoord(HitTile *root, int coords[HIT_MAXDIMS])
HitShape hit_tileShapeArray2Tile(void *var, HitShape sh)
void * hit_mtileBlockArrayCoord(HitTile *root, int coords[HIT_MAXDIMS])
int hit_tileCheckBoundaryTileCoords(const void *tileP, HitShape sh)
void hit_tileUpdateFromToAncestorInternal(void *sh, int fromTo, const char *name, const char *file, int numLine)
void hit_tileAllocInternal(void *newVarP, const char *name, const char *file, int numLine)
HitShape hit_tileShapeLocal(const void *inTile)
#define hit_tileDimEnd(var, dim)
int hit_tileExpandDims(void *newVarP, int numExpansions)
int hit_tileSelectArrayCoordsInternal(void *newVarP, const void *oldVarP, HitShape sh, int out)
#define hit_vmalloc(ptr, size)
#define hit_tileSelectArrayCoords(newVar, oldVar, shape)
#define hit_warnInternal(routine, text, extraParam, file, numLine)
#define hit_shapeSig(shape, dim)
#define hit_tileFree(var)
#define hit_errInternal(routine, text, extraParam, file, numLine)
void hit_tileFreeRecInternal(void *varP)
#define hit_sshapeDims(shape)
#define hit_sigCmp(s1, s2)
#define hit_tileShape(var)