IOperand *TOperand<T>::doMod(eOperandType type, const std::string &left, const std::string &right) const
{
T l_value;
T r_value;
std::istringstream l_ss(left);
std::istringstream r_ss(right);
l_ss >> l_value;
r_ss >> r_value;
try
{
if (r_value == 0)
throw Exception("Floating exception (Modulo by 0)");
} catch (Exception ex)
{
std::cerr << ex.what() << std::endl;
exit(0x53);
}
if (TRAIT::is_float<T>::value || TRAIT::is_double<T>::value)
{
checkOverflow(fmod(l_value, r_value));
checkUnderflow(fmod(l_value, r_value));
return new TOperand<T>(type, fmod(l_value, r_value));
}
else
{
checkOverflow((l_value - ((l_value / r_value) * r_value)));
checkUnderflow((l_value - ((l_value / r_value) * r_value)));
return new TOperand<T>(type, (l_value - ((l_value / r_value) * r_value)));
}
}
void genOperation(FILE* yyout, Symbol* leftSide, Symbol* rightSide, char* op )
{
int r0, r1;
r0 = ((ExtraInfo*)(leftSide->info))->nRegister;
r1 = ((ExtraInfo*)(rightSide->info))->nRegister;
int isFloat_ = isFloat( leftSide );
if( !isFloat_ ){
if(r0 == 7){
r0 = assignRegisters(0);
if (r0 == -1){
r0 = checkOverflow(yyout, r0, TYPE_INTEGER);
}
((ExtraInfo*)(leftSide->info))->nRegister = r0;
extraInfoPerRegister[r0] = ((ExtraInfo*)(leftSide->info));
fprintf(yyout, "\tR%d = I(R7);\t//Recovering value from stack\n\tR7 = R7 + 4;\n", r0);
}
if(r1 == 7){
r1 = assignRegisters(0);
if (r1 == -1){
r1 = checkOverflow(yyout, r1, TYPE_INTEGER);
}
((ExtraInfo*)(leftSide->info))->nRegister = r1;
extraInfoPerRegister[r1] = ((ExtraInfo*)(rightSide->info));
fprintf(yyout, "\tR%d = I(R7);\t//Recovering value from stack\n\tR7 = R7 + 4;\n", r1);
}
fprintf(yyout, "\tR%d = R%d %s R%d;\n", r0, r0,op, r1);
}else{
if(r0 == 77){
r0 = assignRegisters(1);
if (r0 == -1){
r0 = checkOverflow(yyout, r0, TYPE_FLOAT);
}
((ExtraInfo*)(leftSide->info))->nRegister = r0;
extraInfoPerDoubleRegister[r0] = ((ExtraInfo*)(leftSide->info));
fprintf(yyout, "\tRR%d = F(R7);\t//Recovering value from stack\n\tR7 = R7 + 4;\n", r0);
}
if(r1 == 77){
r1 = assignRegisters(1);
if (r1 == -1){
r1 = checkOverflow(yyout, r1, TYPE_FLOAT);
}
((ExtraInfo*)(leftSide->info))->nRegister = r1;
extraInfoPerDoubleRegister[r1] = ((ExtraInfo*)(rightSide->info));
fprintf(yyout, "\tRR%d = F(R7);\t//Recovering value from stack\n\tR7 = R7 + 4;\n", r1);
}
fprintf(yyout, "\tRR%d = RR%d %s RR%d;\n", r0, r0,op, r1);
}
freeRegister( r1, isFloat_ );
freeSymbol(rightSide);
}
ckFix::ckFix(s32 n)
{
s64 value = static_cast<s64>(n) << FRACTION_BIT_NUM;
checkOverflow(value);
m_value = static_cast<s32>(value);
}
/* ##### E241: (col 9) 'class String' has not been declared */
String::String(const char* cb1, size_t n1, const char* cb2, size_t n2)
{
assert(cb1 != 0 && cb2 != 0);
//
// operations
//
size_t newlen = n1 + n2;
checkOverflow(n1, newlen, "operator+"); // unsigned overflow
if(newlen == 0) {
/* ##### E029: (col 14) symbol 'srep' has not been declared */
srep = 0;
}
else {
/* ##### E241: (col 27) 'class StringRep' has not been declared */
/* ##### E029: (col 27) symbol 'getNew' has not been declared */
srep = StringRep::getNew(n1, newlen, cb1);
/* ##### E133: (col 16) too many errors: compilation aborted */
memcpy(srep->str + n1, cb2, n2);
srep->setLen(newlen);
}
//
// post conditions
//
assert(newlen == 0 || srep != 0);
assert(length() == newlen);
assert(memcmp(getStr(), cb1, n1) == 0);
assert(memcmp(getStr() + n1, cb2, n2) == 0);
}
ckFix ckFix::operator-() const
{
s64 value = -static_cast<s64>(m_value);
checkOverflow(value);
return fromValue(static_cast<s32>(value));
}
ckFix ckFix::operator+(ckFix fix) const
{
s64 value = static_cast<s64>(m_value) + static_cast<s64>(fix.m_value);
checkOverflow(value);
return fromValue(static_cast<s32>(value));
}
void test_checkOverflow_given_value_is_negative_123_should_unset_Overflow_flag(void)
{
int value = -123;
checkOverflow(value);
TEST_ASSERT_EQUAL(0x0, STATUS);
}
void test_checkOverflow_given_value_is_more_than_127_should_set_Overflow_flag(void)
{
int value = 130;
checkOverflow(value);
TEST_ASSERT_EQUAL(0x8, STATUS);
}
void test_checkOverflow_given_value_is_less_than_negative_128_should_set_Overflow_flag(void)
{
int value = -184;
checkOverflow(value);
TEST_ASSERT_EQUAL(0x8, STATUS);
}
bool BankedMSHR<Addr_t, Cache_t>::retire(Addr_t paddr)
{
bool rmEntry;
maxOutsReqs.sample(nOutsReqs);
rmEntry = mshrBank[calcBankIndex(paddr)]->retire(paddr);
nOutsReqs--;
checkOverflow();
return rmEntry;
}
/*
* ======== Timer_setPeriodMicroSecs ========
* 1. stop timer
* 2. compute counts
* 3. set period register
*
* For Davinci, the timer needs to be stopped for the new value to
* be written (otherwise it gets dropped).
*/
Bool Timer_setPeriodMicroSecs(Timer_Object *obj, UInt32 period)
{
Types_FreqHz freqHz;
UInt64 counts;
UInt32 prdCounts;
UInt32 freqKHz;
TimerRegs *timer;
UInt32 roundUp;
timer = (TimerRegs *)Timer_module->device[obj->id].baseAddr;
Timer_stop(obj);
/* Today c64 supports less than 4.2GHz */
Timer_getFreq(obj, &freqHz);
roundUp = ((freqHz.lo % 1000) >= 500) ? 1 : 0;
freqKHz = (freqHz.lo / 1000) + roundUp;
if (checkOverflow(freqKHz, period/1000)) {
return (FALSE);
}
counts = ((UInt64)freqKHz * (UInt64)period) / (UInt64)1000;
if (counts > 0xffffffff) {
return (FALSE);
}
else {
prdCounts = counts - 1;
}
obj->period = prdCounts;
obj->periodType = Timer_PeriodType_COUNTS;
if (obj->runMode != Timer_RunMode_DYNAMIC) {
timer->tcrr = Timer_MAX_PERIOD - prdCounts;
while (timer->twps & TIMER_TWPS_W_PEND_TCRR)
;
timer->tldr = Timer_MAX_PERIOD - prdCounts;
while (timer->twps & TIMER_TWPS_W_PEND_TLDR)
;
}
else {
timer->tcrr = 0;
while (timer->twps & TIMER_TWPS_W_PEND_TCRR)
;
timer->tmar = prdCounts;
while (timer->twps & TIMER_TWPS_W_PEND_TMAR)
;
}
return(TRUE);
}
ckFix::ckFix(r32 r)
{
s64 value = static_cast<s64>(r * (1 << FRACTION_BIT_NUM));
checkOverflow(value);
if (r != 0.0f && value == 0)
{
ckThrow(ExceptionUnderflow);
}
m_value = static_cast<s32>(value);
}
IOperand *TOperand<T>::doLess(eOperandType type, const std::string &left, const std::string &right) const
{
T l_value;
T r_value;
std::istringstream l_ss(left);
std::istringstream r_ss(right);
l_ss >> l_value;
r_ss >> r_value;
checkOverflow(l_value - r_value);
checkUnderflow(l_value - r_value);
return new TOperand<T>(type, (l_value - r_value));
}
IOperand *TOperand<int8>::doMul(eOperandType type, const std::string &left, const std::string &right) const
{
int l_value;
int r_value;
std::istringstream l_ss(left);
std::istringstream r_ss(right);
l_ss >> l_value;
r_ss >> r_value;
checkOverflow(l_value * r_value);
checkUnderflow(l_value * r_value);
return new TOperand<int8>(type, (l_value * r_value));
}
void SnakeUnit::setPosition(int x,int y)
{
/*this->x=x;
this->y=y;
checkOverflow(x,y);
CCPoint point = ccp(VisibleRect::center().x-(WIDTH/2)+((x+1)*GRID)-GRID/2,VisibleRect::center().y-(HEIGHT/2)+((y+1)*GRID)-GRID/2);
CCSprite::runAction(CCMoveTo::create(0.18f,point));*/
this->x=x;
this->y=y;
checkOverflow(x,y);
CCPoint point = ccp(VisibleRect::center().x-(WIDTH/2)+((x+1)*GRID)-GRID/2,VisibleRect::center().y-(HEIGHT/2)+((y+1)*GRID)-GRID/2);
CCSprite::setPosition(point);
}
/*
* ======== Timer_setPeriodMicroSecs ========
*
* 1. Stop timer
* 2. Compute counts
* 3. Set new period value in timer obj
*
*/
Bool Timer_setPeriodMicroSecs(Timer_Object *obj, UInt32 period)
{
Types_FreqHz freqHz;
UInt32 counts;
UInt32 freqKHz;
Timer_stop(obj);
Timer_getFreq(obj, &freqHz);
freqKHz = freqHz.lo / 1000;
if (checkOverflow(freqKHz, period/1000)) {
return (FALSE);
}
else {
counts = (freqKHz * period) / 1000;
obj->period = counts;
obj->periodType = Timer_PeriodType_COUNTS;
return(TRUE);
}
}
IOperand *TOperand<int8>::doMod(eOperandType type, const std::string &left, const std::string &right) const
{
int l_value;
int r_value;
std::istringstream l_ss(left);
std::istringstream r_ss(right);
l_ss >> l_value;
r_ss >> r_value;
try
{
if (r_value == 0)
throw Exception("Floating exception (Modulo by 0)");
} catch (Exception ex)
{
std::cerr << ex.what() << std::endl;
exit(0x53);
}
checkOverflow((l_value % r_value));
checkUnderflow((l_value % r_value));
return new TOperand<int8>(type, (l_value % r_value));
}
IOperand *TOperand<T>::doDiv(eOperandType type, const std::string &left, const std::string &right) const
{
T l_value;
T r_value;
std::istringstream l_ss(left);
std::istringstream r_ss(right);
l_ss >> l_value;
r_ss >> r_value;
try
{
if (r_value == 0)
throw Exception("Floating exception (Divide by 0)");
} catch (Exception ex)
{
std::cerr << ex.what() << std::endl;
exit(0x52);
}
checkOverflow(l_value / r_value);
checkUnderflow(l_value / r_value);
return new TOperand<T>(type, (l_value / r_value));
}
/*
* Class: sun_java2d_loops_TransformHelper
* Method: Transform
* Signature: (Lsun/java2d/loops/MaskBlit;Lsun/java2d/SurfaceData;Lsun/java2d/SurfaceData;Ljava/awt/Composite;Lsun/java2d/pipe/Region;Ljava/awt/geom/AffineTransform;IIIIIIIII[I)V
*/
JNIEXPORT void JNICALL
Java_sun_java2d_loops_TransformHelper_Transform
(JNIEnv *env, jobject self,
jobject maskblit,
jobject srcData, jobject dstData,
jobject comp, jobject clip,
jobject itxform, jint txtype,
jint sx1, jint sy1, jint sx2, jint sy2,
jint dx1, jint dy1, jint dx2, jint dy2,
jintArray edgeArray, jint dxoff, jint dyoff)
{
SurfaceDataOps *srcOps;
SurfaceDataOps *dstOps;
SurfaceDataRasInfo srcInfo;
SurfaceDataRasInfo dstInfo;
NativePrimitive *pHelperPrim;
NativePrimitive *pMaskBlitPrim;
CompositeInfo compInfo;
RegionData clipInfo;
TransformInfo itxInfo;
jint maxlinepix;
TransformHelperFunc *pHelperFunc;
TransformInterpFunc *pInterpFunc;
jdouble xorig, yorig;
jlong numedges;
jint *pEdges;
jint edgebuf[2 + MAXEDGES * 2];
union {
jlong align;
jint data[LINE_SIZE];
} rgb;
#ifdef MAKE_STUBS
static int th_initialized;
/* For debugging only - used to swap in alternate funcs for perf testing */
if (!th_initialized) {
if (getenv("TXSTUB") != 0) {
pBilinearFunc = BilinearInterpStub;
pBicubicFunc = BicubicInterpStub;
} else if (getenv("TXNOVIS") != 0) {
pBilinearFunc = BilinearInterp;
pBicubicFunc = BicubicInterp;
}
th_initialized = 1;
}
#endif /* MAKE_STUBS */
pHelperPrim = GetNativePrim(env, self);
if (pHelperPrim == NULL) {
/* Should never happen... */
return;
}
pMaskBlitPrim = GetNativePrim(env, maskblit);
if (pMaskBlitPrim == NULL) {
/* Exception was thrown by GetNativePrim */
return;
}
if (pMaskBlitPrim->pCompType->getCompInfo != NULL) {
(*pMaskBlitPrim->pCompType->getCompInfo)(env, &compInfo, comp);
}
if (Region_GetInfo(env, clip, &clipInfo)) {
return;
}
srcOps = SurfaceData_GetOps(env, srcData);
dstOps = SurfaceData_GetOps(env, dstData);
if (srcOps == 0 || dstOps == 0) {
return;
}
/*
* Grab the appropriate pointer to the helper and interpolation
* routines and calculate the maximum number of destination pixels
* that can be processed in one intermediate buffer based on the
* size of the buffer and the number of samples needed per pixel.
*/
switch (txtype) {
case java_awt_image_AffineTransformOp_TYPE_NEAREST_NEIGHBOR:
pHelperFunc = pHelperPrim->funcs.transformhelpers->nnHelper;
pInterpFunc = NULL;
maxlinepix = LINE_SIZE;
break;
case java_awt_image_AffineTransformOp_TYPE_BILINEAR:
pHelperFunc = pHelperPrim->funcs.transformhelpers->blHelper;
pInterpFunc = pBilinearFunc;
maxlinepix = LINE_SIZE / 4;
break;
case java_awt_image_AffineTransformOp_TYPE_BICUBIC:
pHelperFunc = pHelperPrim->funcs.transformhelpers->bcHelper;
pInterpFunc = pBicubicFunc;
maxlinepix = LINE_SIZE / 16;
break;
}
srcInfo.bounds.x1 = sx1;
srcInfo.bounds.y1 = sy1;
srcInfo.bounds.x2 = sx2;
srcInfo.bounds.y2 = sy2;
dstInfo.bounds.x1 = dx1;
dstInfo.bounds.y1 = dy1;
dstInfo.bounds.x2 = dx2;
dstInfo.bounds.y2 = dy2;
SurfaceData_IntersectBounds(&dstInfo.bounds, &clipInfo.bounds);
if (srcOps->Lock(env, srcOps, &srcInfo, pHelperPrim->srcflags)
!= SD_SUCCESS)
{
/* edgeArray should already contain zeros for min/maxy */
return;
}
if (dstOps->Lock(env, dstOps, &dstInfo, pMaskBlitPrim->dstflags)
!= SD_SUCCESS)
{
SurfaceData_InvokeUnlock(env, srcOps, &srcInfo);
/* edgeArray should already contain zeros for min/maxy */
return;
}
Region_IntersectBounds(&clipInfo, &dstInfo.bounds);
numedges = (((jlong) dstInfo.bounds.y2) - ((jlong) dstInfo.bounds.y1));
if (numedges <= 0) {
pEdges = NULL;
} else if (!JNU_IsNull(env, edgeArray)) {
/*
* Ideally Java should allocate an array large enough, but if
* we ever have a miscommunication about the number of edge
* lines, or if the Java array calculation should overflow to
* a positive number and succeed in allocating an array that
* is too small, we need to verify that it can still hold the
* number of integers that we plan to store to be safe.
*/
jsize edgesize = (*env)->GetArrayLength(env, edgeArray);
/* (edgesize/2 - 1) should avoid any overflow or underflow. */
pEdges = (((edgesize / 2) - 1) >= numedges)
? (*env)->GetPrimitiveArrayCritical(env, edgeArray, NULL)
: NULL;
} else if (numedges > MAXEDGES) {
/* numedges variable (jlong) can be at most ((1<<32)-1) */
/* memsize can overflow a jint, but not a jlong */
jlong memsize = ((numedges * 2) + 2) * sizeof(*pEdges);
pEdges = (memsize == ((size_t) memsize))
? malloc((size_t) memsize)
: NULL;
} else {
pEdges = edgebuf;
}
if (pEdges == NULL) {
if (numedges > 0) {
JNU_ThrowInternalError(env, "Unable to allocate edge list");
}
SurfaceData_InvokeUnlock(env, dstOps, &dstInfo);
SurfaceData_InvokeUnlock(env, srcOps, &srcInfo);
/* edgeArray should already contain zeros for min/maxy */
return;
}
Transform_GetInfo(env, itxform, &itxInfo);
if (!Region_IsEmpty(&clipInfo)) {
srcOps->GetRasInfo(env, srcOps, &srcInfo);
dstOps->GetRasInfo(env, dstOps, &dstInfo);
if (srcInfo.rasBase == NULL || dstInfo.rasBase == NULL) {
pEdges[0] = pEdges[1] = 0;
} else if (checkOverflow(dxoff, dyoff, &dstInfo.bounds,
&itxInfo, &xorig, &yorig))
{
Transform_SafeHelper(env, srcOps, dstOps,
&srcInfo, &dstInfo,
pMaskBlitPrim, &compInfo,
pHelperFunc, pInterpFunc,
&clipInfo, &itxInfo, rgb.data, pEdges,
dxoff, dyoff, sx2-sx1, sy2-sy1);
} else {
SurfaceDataBounds span;
jlong dxdxlong, dydxlong;
jlong dxdylong, dydylong;
jlong xbase, ybase;
dxdxlong = DblToLong(itxInfo.dxdx);
dydxlong = DblToLong(itxInfo.dydx);
dxdylong = DblToLong(itxInfo.dxdy);
dydylong = DblToLong(itxInfo.dydy);
xbase = DblToLong(xorig);
ybase = DblToLong(yorig);
calculateEdges(pEdges, &dstInfo.bounds, &itxInfo,
xbase, ybase, sx2-sx1, sy2-sy1);
Region_StartIteration(env, &clipInfo);
while (Region_NextIteration(&clipInfo, &span)) {
jlong rowxlong, rowylong;
void *pDst;
dy1 = span.y1;
dy2 = span.y2;
rowxlong = xbase + (dy1 - dstInfo.bounds.y1) * dxdylong;
rowylong = ybase + (dy1 - dstInfo.bounds.y1) * dydylong;
while (dy1 < dy2) {
jlong xlong, ylong;
/* Note - process at most one scanline at a time. */
dx1 = pEdges[(dy1 - dstInfo.bounds.y1) * 2 + 2];
dx2 = pEdges[(dy1 - dstInfo.bounds.y1) * 2 + 3];
if (dx1 < span.x1) dx1 = span.x1;
if (dx2 > span.x2) dx2 = span.x2;
/* All pixels from dx1 to dx2 have centers in bounds */
while (dx1 < dx2) {
/* Can process at most one buffer full at a time */
jint numpix = dx2 - dx1;
if (numpix > maxlinepix) {
numpix = maxlinepix;
}
xlong =
rowxlong + ((dx1 - dstInfo.bounds.x1) * dxdxlong);
ylong =
rowylong + ((dx1 - dstInfo.bounds.x1) * dydxlong);
/* Get IntArgbPre pixel data from source */
(*pHelperFunc)(&srcInfo,
rgb.data, numpix,
xlong, dxdxlong,
ylong, dydxlong);
/* Interpolate result pixels if needed */
if (pInterpFunc) {
(*pInterpFunc)(rgb.data, numpix,
FractOfLong(xlong-LongOneHalf),
FractOfLong(dxdxlong),
FractOfLong(ylong-LongOneHalf),
FractOfLong(dydxlong));
}
/* Store/Composite interpolated pixels into dest */
pDst = PtrCoord(dstInfo.rasBase,
dx1, dstInfo.pixelStride,
dy1, dstInfo.scanStride);
(*pMaskBlitPrim->funcs.maskblit)(pDst, rgb.data,
0, 0, 0,
numpix, 1,
&dstInfo, &srcInfo,
pMaskBlitPrim,
&compInfo);
/* Increment to next buffer worth of input pixels */
dx1 += maxlinepix;
}
/* Increment to next scanline */
rowxlong += dxdylong;
rowylong += dydylong;
dy1++;
}
}
Region_EndIteration(env, &clipInfo);
}
SurfaceData_InvokeRelease(env, dstOps, &dstInfo);
SurfaceData_InvokeRelease(env, srcOps, &srcInfo);
} else {
pEdges[0] = pEdges[1] = 0;
}
if (!JNU_IsNull(env, edgeArray)) {
(*env)->ReleasePrimitiveArrayCritical(env, edgeArray, pEdges, 0);
} else if (pEdges != edgebuf) {
free(pEdges);
}
SurfaceData_InvokeUnlock(env, dstOps, &dstInfo);
SurfaceData_InvokeUnlock(env, srcOps, &srcInfo);
}
bool SingleMSHR<Addr_t, Cache_t>::retire(Addr_t paddr)
{
bool rmEntry = false;
MSHRit it = ms.find(calcLineAddr(paddr));
I(it != ms.end());
I(calcLineAddr(paddr) == (*it).second.getLineAddr());
maxOutsReqs.sample(nOutsReqs);
nOutsReqs--;
//MSG("[%llu] nFullSubE=%d a=%lu",globalClock,nFullReadEntries,calcLineAddr(paddr));
rmEntry = (*it).second.retire();
if(rmEntry) {
// the last pending request for the MSHRentry was completed
// recycle the entry
nRetiredEntries.inc();
avgReqsPerLine.sample((*it).second.getUsedReads() + (*it).second.getUsedWrites());
maxUsedEntries.sample(nEntries - nFreeEntries);
avgWritesPerLine.sample((*it).second.getUsedWrites());
avgWritesPerLineComb.sample((*it).second.getNWrittenWords());
occStats->decRdReqs((*it).second.getUsedReads());
if((*it).second.getUsedWrites() > 0)
nRetiredEntriesWritten.inc();
if( ! (*it).second.hasFreeReads() ) {
nFullReadEntries--;
I(nFullReadEntries>=0);
}
if( ! (*it).second.hasFreeWrites() ) {
nFullWriteEntries--;
I(nFullWriteEntries>=0);
}
if((*it).second.isL2Hit())
occStats->avgReadSubentriesL2Hit.sample((*it).second.getUsedReads());
else
occStats->avgReadSubentriesL2Miss.sample((*it).second.getUsedReads());
#ifdef MSHR_EXTRAOCCSTATS
// extra MSHR occ stats
occStats->subEntriesHist.sample((*it).second.getUsedReads()+
(*it).second.getUsedWrites(), 1);
occStats->subEntriesReadsHist.sample((*it).second.getUsedReads(), 1);
occStats->subEntriesWritesHist.sample((*it).second.getUsedWrites(), 1);
occStats->subEntriesWritesHistComb.sample((*it).second.getNWrittenWords(), 1);
occStats->subEntriesHistComb.sample((*it).second.getUsedReads()+
(*it).second.getNWrittenWords(), 1);
if((*it).second.getUsedReads() == 0 &&
(*it).second.getUsedWrites() > 0) {
nOnlyWrites.inc();
occStats->retireWrEntry((*it).second.getLineAddr());
} else if( (*it).second.getUsedReads() > 0 &&
(*it).second.getUsedWrites() == 0 ) {
occStats->retireRdEntry((*it).second.getLineAddr());
} else {
I( (*it).second.getUsedWrites() > 0 );
I( (*it).second.getUsedReads() > 0 );
occStats->retireRdWrEntry((*it).second.getLineAddr());
}
#endif
nFreeEntries++;
updateOccHistogram();
bf.remove((*it).second.getLineAddr());
ms.erase(it);
}
checkOverflow();
return rmEntry;
}
bool SnakeUnit::checkOverflow()
{
return checkOverflow(this->x,this->y);
}
/* ##### E241: (col 14) 'class String' has not been declared */
void String::doReplace(size_t pos, size_t n, const char* cb, size_t len)
{
/* ##### E029: (col 22) symbol 'length' has not been declared */
size_t thisLen = length();
size_t newlen;
//
// preconditions
//
assert(pos <= thisLen); // if pos == thisLen it's like an append
assert(cb != 0);
assert(n <= (thisLen - pos));
//
// operations
//
newlen = len + (thisLen - n);
checkOverflow(len, newlen, "String::doReplace");
if(newlen == 0) {
/* ##### E029: (col 15) symbol 'refDec' has not been declared */
refDec();
/* ##### E029: (col 9) symbol 'srep' has not been declared */
srep = 0;
return;
}
// prevent against hacks like: s.insert(1, s.cStr() + 2)
//
/* ##### E029: (col 34) symbol 'srep' has not been declared */
if(srep && NORM_ADR(srep->str) <= NORM_ADR(cb)
&& NORM_ADR(cb) <= NORM_ADR(srep->str + thisLen)) {
/* ##### E029: (col 25) symbol 'String' has not been declared */
replace(pos, n, String(cb, len));
return;
}
/* ##### E029: (col 8) symbol 'needClone' has not been declared */
if(needClone(newlen)) {
/* ##### E241: (col 17) 'class String' has not been declared */
/* ##### E006: (col 31) syntax error; probable cause: missing ';' */
String::StringRep *ps = StringRep::getNew(pos, newlen, srep->str);
if(thisLen > 0) // copy tail
/* ##### E029: (col 20) symbol 'ps' has not been declared */
memcpy(ps->str + pos + len, srep->str + pos + n,
thisLen - (pos + n));
/* ##### E029: (col 9) symbol 'refDec' has not been declared */
refDec();
srep = ps;
}
else {
char* ptarget = srep->str; // srep != 0
if(n != len) // move in place
MemMove(ptarget + pos + len, ptarget + pos + n,
thisLen - (pos + n));
}
if(len > 0)
memcpy(srep->str + pos, cb, len);
srep->setLen(newlen);
assert(newlen == length());
}
extern "C" void *
xrealloc2(void* old, size_t n, size_t size)
{
return xrealloc(old, checkOverflow(n, size, "realloc"));
}
Symbol* genAccessVariable(FILE* yyout,cstr name, int symType, SymbolInfo* atribute)
{
Symbol* variable = searchVariable(symType, name);
int isFloat_ = isFloat( variable );
int reg;
int height = returnVariableHeight( symType, name );
//When trying to access an array variable outside a block
//we can use expression register so we do not have to assign a new one
if( atribute->info == TYPE_ARRAY && !isFloat_ && height == 0 ){
reg = ((ExtraInfo*)(atribute->exprSymbol->info))->nRegister;
}else{
reg = assignRegisters( isFloat_ );
}
cstr regStr = getRegStr( isFloat_ );
int elementSize = 0;
if (isFloat_ == 0) reg = checkOverflow(yyout, reg, TYPE_INTEGER);
else reg = checkOverflow(yyout, reg, TYPE_FLOAT);
Symbol* returnSymbol = createExtraInfoSymbol(reg, isFloat_);
ExtraInfo* aux = (ExtraInfo*)(returnSymbol->info);
aux->nRegister = reg;
aux->variable = variable;
if(atribute->info == SYM_CLASS_VARIABLE){
//varSymbol gets the Symbol of the variable
aux->variable = getClassVar(aux->variable,atribute->name);
}
if( atribute->info == TYPE_ARRAY ){
elementSize = ((Type*)(((Type*)(((Variable*)(aux->variable->info))->type->info))->arrayInfo->type->info))->size;
}
if( symType == SYM_VARIABLE )
{
int accessRegister = genFrameAccess( yyout, height, reg, isFloat_ );
if(((Variable*)(aux->variable->info))->symSubtype == SYM_LOCAL){
if( atribute->info == TYPE_ARRAY ){
int expReg = ((ExtraInfo*)(atribute->exprSymbol->info))->nRegister;
fprintf(yyout, "\tR%d = R%d * %d; //Calculate array %s position\n",expReg, expReg,
elementSize, aux->variable->name);
fprintf(yyout, "\tR%d = R%d - %d; //Calculate local %s position\n",expReg, expReg,
returnAddress(symType,aux->variable->name), aux->variable->name);
fprintf(yyout,"\t%s%d = %c(R%d + R%d); //%s[expr] = expr\n",regStr, reg,
pointerType(aux->variable), accessRegister, expReg, aux->variable->name);
if( !(atribute->info == TYPE_ARRAY && !isFloat_ && height == 0) ){
freeRegister( expReg, 0 );
}
freeSymbol(atribute->exprSymbol);
}else{
fprintf(yyout,"\t%s%d = %c(R%d - %d); //Loading value of var %s\n",regStr, reg,
pointerType(aux->variable), accessRegister, returnAddress(symType,aux->variable->name),
aux->variable->name);
}
}else{
if( atribute->info == TYPE_ARRAY ){
int expReg = ((ExtraInfo*)(atribute->exprSymbol->info))->nRegister;
fprintf(yyout, "\tR%d = R%d * %d; //Calculate array %s position\n",expReg, expReg,
elementSize, aux->variable->name);
fprintf(yyout, "\tR%d = R%d + %d; //Calculate local %s position\n",expReg, expReg,
returnAddress(symType,aux->variable->name), aux->variable->name);
fprintf(yyout,"\t%s%d = %c(R%d + R%d); //%s[expr] = expr\n",regStr, reg,
pointerType(aux->variable), accessRegister, expReg, aux->variable->name);
if( !(atribute->info == TYPE_ARRAY && !isFloat_ && height == 0) ){
freeRegister( expReg, 0 );
}
freeSymbol(atribute->exprSymbol);
}else{
fprintf(yyout,"\t%s%d = %c(R%d + %d); //Loading value of var %s\n",regStr,reg,
pointerType(aux->variable), accessRegister,
returnAddress(symType,aux->variable->name), aux->variable->name);
}
}
if( accessRegister != 6 ){
freeRegister( accessRegister, 0 );
}
}else{
if( symType == SYM_GLOBAL )
{
if( atribute->info == TYPE_ARRAY ){
int expReg = ((ExtraInfo*)(atribute->exprSymbol->info))->nRegister;
fprintf(yyout, "\tR%d = R%d * %d; //Calculate array %s position\n",expReg, expReg,
elementSize, aux->variable->name);
fprintf(yyout,"\t%s%d = %c(0x%x + R%d); //Loading value of var %s[expr]\n",regStr, reg, pointerType(aux->variable),
returnAddress(symType,aux->variable->name), expReg, aux->variable->name);
if( !(atribute->info == TYPE_ARRAY && !isFloat_ && height == 0) ){
freeRegister( expReg, 0 );
}
freeSymbol(atribute->exprSymbol);
}else{
fprintf(yyout,"\t%s%d = %c(0x%x); //Loading value of var %s\n", regStr, reg, pointerType(aux->variable),
returnAddress(symType,aux->variable->name), aux->variable->name);
}
//FIXME Las constantes van aqui
}else{
}
}
freeSymbolInfo(atribute);
return returnSymbol;
}
int main (int argc, char ** argv) {
//For varriable definitions:
//gbounds = global bounds string, lbounds = local bounds string, offs = offset string, tstring = temp string to hold temperary stuff
char gbounds[1007], lbounds[1007], offs[1007],tstring[100];
//size = number of cores, gidx = adios group index
int rank, size, gidx, i, j, k, ii;
//data = pointer to read-in data
void * data = NULL;
uint64_t s[] = {0,0,0,0,0,0,0,0,0,0}; //starting offset
uint64_t c[] = {1,1,1,1,1,1,1,1,1,1}; //chunk block array
uint64_t bytes_read = 0;
int element_size;
int64_t new_adios_group, m_adios_file;
uint64_t var_size; //portion_bound,
uint64_t adios_groupsize, adios_totalsize;
int read_buffer; //possible maximum size you the user would like for each chunk in MB
int write_buffer = 1536; //actual buffer size you use in MB
int itime;
int WRITEME=1;
uint64_t chunk_size; //chunk size in # of elements
char *var_path, *var_name; // full path cut into dir path and name
MPI_Init(&argc,&argv);
MPI_Comm_rank(comm,&rank);
MPI_Comm_size(comm,&size);
// timing numbers
// we will time:
// 0: adios_open, adios_group_size
// 1: the total time to read in the data
// 2: times around each write (will only work if we do NOT buffer....
// 3: the time in the close
// 4: fopen, fclose
// 5: total time
// timers: the total I/O time
int timers = 6;
double start_time[timers], end_time[timers], total_time[timers];
if (TIMING==100) {
for (itime=0;itime<timers;itime++) {
start_time[itime] = 0;
end_time[itime] = 0;
total_time[itime]=0;
}
//MPI_Barrier(MPI_COMM_WORLD);
start_time[5] = MPI_Wtime();
}
if(rank==0)
printf("converting...\n");
if (argc < 5) {
if (rank==0) printf("Usage: %s <BP-file> <ADIOS-file> read_buffer(MB) write_buffer(MB) METHOD (LUSTRE_strip_count) (LUSTRE_strip_size) (LUSTRE_block_size)\n", argv[0]);
return 1;
}
if(TIMING==100)
start_time[4] = MPI_Wtime();
ADIOS_FILE * f = adios_fopen (argv[1], MPI_COMM_SELF);
if(TIMING==100){
end_time[4] = MPI_Wtime();
total_time[4] = end_time[4]-start_time[4];
}
adios_init_noxml(comm); // no xml will be used to write the new adios file
read_buffer = atoi(argv[3]);
write_buffer = atoi(argv[4]);
adios_allocate_buffer (ADIOS_BUFFER_ALLOC_NOW, write_buffer); // allocate MB buffer
if (f == NULL) {
printf("rank=%d, file cant be opened\n", rank);
if (DEBUG) printf ("%s\n", adios_errmsg());
return -1;
}
for (gidx = 0; gidx < f->groups_count; gidx++) { //group part
adios_groupsize = 0;
ADIOS_GROUP * g = adios_gopen (f, f->group_namelist[gidx]);
if (g == NULL) {
if (DEBUG) printf ("%s\n", adios_errmsg());
printf("rank %d: group cannot be opened.\n", rank);
return -1;
}
/* First create all of the groups */
// now I need to create this group in the file that will be written
adios_declare_group(&new_adios_group,f->group_namelist[gidx],"",adios_flag_yes);
if(strcmp(argv[5],"MPI_LUSTRE")!=0) //see whether or not the user uses MPI_LUSTRE method
adios_select_method (new_adios_group, argv[5], "", ""); //non-MPI_LUSTRE methods... like MPI, POSIX....
else{
char lustre_pars[1000];
strcpy(lustre_pars, "");
strcat(lustre_pars, "stripe_count=");
sprintf(tstring, "%d", atoi(argv[6]));
strcat(lustre_pars, tstring);
strcat(lustre_pars, ",stripe_size=");
sprintf(tstring, "%d", atoi(argv[7]));
strcat(lustre_pars, tstring);
strcat(lustre_pars, ",block_size=");
sprintf(tstring, "%d", atoi(argv[8]));
strcat(lustre_pars, tstring);
if(rank==0)
printf("lustre_pars=%s\n", lustre_pars);
adios_select_method (new_adios_group, argv[5], lustre_pars, ""); //Use MPI Lustre method
}
// variable definition part
for (i = 0; i < g->vars_count; i++) {
ADIOS_VARINFO * v = adios_inq_var_byid (g, i);
getbasename (g->var_namelist[i], &var_path, &var_name);
if (v->ndim == 0)
{
// scalars: every process does them the same.
adios_define_var(new_adios_group,var_name,var_path,v->type,0,0,0);
getTypeInfo( v->type, &element_size); //element_size is size per element based on its type
if (v->type == adios_string) { //special case when the scalar is string.
adios_groupsize += strlen(v->value);
} else {
adios_groupsize += element_size;
}
}
else
{
// vector variables
getTypeInfo( v->type, &element_size);
var_size=1;
for (ii=0;ii<v->ndim;ii++) {
var_size*=v->dims[ii];
}
uint64_t total_size = var_size; //total_size tells you the total number of elements in the current vector variable
var_size*=element_size; //var_size tells you the size of the current vector variable in bytess
//re-initialize the s and c variables
for(j=0; j<v->ndim; j++){
s[j] = 0;
c[j] = 1;
}
//find the approximate chunk_size you would like to use.
chunk_size = calcChunkSize(total_size, read_buffer*1024*1024/element_size, size);
//set the chunk block array with the total size as close to chunk_size as possible
calcC(chunk_size, v, c);
strcpy(lbounds,"");
for(j=0; j<v->ndim; j++){
sprintf(tstring, "%" PRId64 ",", c[j]);
strcat(lbounds, tstring);
}
printf("rank=%d, name=%s, chunk_size1=%" PRId64 " c[]=%s\n",rank,g->var_namelist[i],chunk_size,lbounds);
chunk_size = 1;
for(ii=0; ii<v->ndim; ii++) //reset chunk_size based on the created c. Now the chunk_size is exact.
chunk_size *= c[ii];
//current step points to where the process is in processing the vector. First sets with respect to rank.
uint64_t current_step = rank*chunk_size;
//First advance the starting point s by current_step. Of course, you don't do it if the current_step exceeds total_size.
if(current_step<total_size)
rS(v, s, current_step, rank);
uint64_t elements_defined = 0; //First, the number of elements you have defined is 0.
//You (the process) process your part of the vector when your current_step is smaller than the total_size
while(current_step < total_size)
{
//ts, temporary s, is introduced for the sake of the inner do while loop below. Copy s to ts.
uint64_t ts[] = {0,0,0,0,0,0,0,0,0,0};
arrCopy(s, ts);
//for every outer while iteration, you always have the whole chunk_size remained to process.
uint64_t remain_chunk = chunk_size;
if(current_step+chunk_size>total_size) //except when you are nearing the end of the vector....
remain_chunk = total_size-current_step;
//tc, temporary c, is introduced for the sake of the inner do while loop below. Copy s to tc.
uint64_t tc[] = {1,1,1,1,1,1,1,1,1,1};
arrCopy(c, tc);
do{
//how much of the remain chunk you wanna process? initially you think you can do all of it....
uint64_t used_chunk = remain_chunk;
//you feel like you should process the vector with tc block size, but given ts, you might go over bound.
uint64_t uc[] = {1,1,1,1,1,1,1,1,1,1};
//so you verify it by setting a new legit chunck block uc, and getting a new remain_chunk.
remain_chunk = checkBound(v, ts, tc, uc, remain_chunk);
//you check whether or not ts+uc goes over the bound. This is just checking to make sure there's no error.
//Thereotically, there should be no problem at all.
checkOverflow(0, v, ts, uc);
//the below code fragment simply calculates gbounds, and sets place holders for lbounds and offs.
strcpy(gbounds,"");
strcpy(lbounds,"");
strcpy(offs,"");
for(j=0; j<v->ndim-1; j++){
sprintf(tstring, "%d,", (int)v->dims[j]);
strcat(gbounds, tstring);
//sprintf(tstring, "ldim%d_%s,", j, var_name);
sprintf(tstring, "ldim%d,", j);
strcat(lbounds, tstring);
//sprintf(tstring, "offs%d_%s,", j, var_name);
sprintf(tstring, "offs%d,", j);
strcat(offs, tstring);
}
sprintf(tstring, "%d", (int)v->dims[v->ndim-1]);
strcat(gbounds, tstring);
//sprintf(tstring, "ldim%d_%s", v->ndim-1, var_name);
sprintf(tstring, "ldim%d", v->ndim-1);
strcat(lbounds, tstring);
//sprintf(tstring, "offs%d_%s", v->ndim-1, var_name);
sprintf(tstring, "offs%d", v->ndim-1);
strcat(offs, tstring);
//sprintf(tstring, "%d", v->ndim);
for(j=0; j<v->ndim; j++){
//sprintf(tstring, "ldim%d_%s", j, var_name);
sprintf(tstring, "ldim%d", j);
adios_define_var(new_adios_group, tstring, "bp2bp", adios_unsigned_long, 0, 0, 0);
//sprintf(tstring, "offs%d_%s", j, var_name);
sprintf(tstring, "offs%d", j);
adios_define_var(new_adios_group, tstring, "bp2bp", adios_unsigned_long, 0, 0, 0);
}
adios_define_var(new_adios_group,var_name,var_path,v->type,lbounds,gbounds,offs);
if (DEBUG){
strcpy(lbounds,"");
strcpy(offs,"");
for(j=0; j<v->ndim; j++){
sprintf(tstring, "%" PRId64 ",", ts[j]);
strcat(offs, tstring);
sprintf(tstring, "%" PRId64 ",", uc[j]);
strcat(lbounds, tstring);
}
printf("rank=%d, name=%s, gbounds=%s: lbounds=%s: offs=%s \n",rank,g->var_namelist[i],gbounds, lbounds, offs);
}
used_chunk -= remain_chunk; //you get the actual used_chunk here.
elements_defined += used_chunk;
if(remain_chunk!=0){
rS(v, ts, used_chunk, rank); //advance ts by used_chunk.
for(k=0; k<10; k++)
tc[k] = 1;
calcC(remain_chunk, v, tc); //based on the remain_chunk, calculate new tc chunk block remained to process.
}
adios_groupsize+= used_chunk*element_size+2*v->ndim*8;
}while(remain_chunk!=0);
current_step += size*chunk_size; //once a whole chunk_size is processed, advance the current_step in roll-robin manner.
if(current_step<total_size){ //advance s in the same way.
rS(v, s, size*chunk_size, rank);
}
}
//beside checkOverflow above, here you check whether or not the total number of elements processed across processes matches
//the total number of elements in the original vector.
if(DEBUG){
uint64_t* sb = (uint64_t *) malloc(sizeof(uint64_t));
uint64_t* rb = (uint64_t *) malloc(sizeof(uint64_t));
sb[0] = elements_defined;
MPI_Reduce(sb,rb,1,MPI_UNSIGNED_LONG_LONG,MPI_SUM,0, comm);
if(rank==0 && rb[0]!=total_size)
printf("some array define mismatch. please use debug mode\n");
free(sb); free(rb);
}
}
free (var_name);
free (var_path);
} // finished declaring all of the variables
// Now we can define the attributes....
for (i = 0; i < g->attrs_count; i++) {
enum ADIOS_DATATYPES atype;
int asize;
void *adata;
adios_get_attr_byid (g, i, &atype, &asize, &adata);
// if (DEBUG) printf("attribute name=%s\n",g->attr_namelist[i]);
adios_define_attribute(new_adios_group,g->attr_namelist[i],"",atype,adata,0);
}
/*------------------------------ NOW WE WRITE -------------------------------------------- */
// Now we have everything declared... now we need to write them out!!!!!!
if (WRITEME==1) {
// open up the file for writing....
if (DEBUG) printf("rank=%d, opening file = %s, with group %s, size=%" PRId64 "\n",rank,argv[2],f->group_namelist[gidx],adios_groupsize);
if(TIMING==100)
start_time[0] = MPI_Wtime();
adios_open(&m_adios_file, f->group_namelist[gidx],argv[2],"w",comm);
adios_group_size( m_adios_file, adios_groupsize, &adios_totalsize);
//get both the total adios_totalsize and total adios_groupsize summed across processes.
uint64_t* sb = (uint64_t *) malloc(sizeof(uint64_t));;
uint64_t* rb = (uint64_t *) malloc(sizeof(uint64_t));
sb[0] = adios_groupsize;
MPI_Reduce(sb,rb,1,MPI_UNSIGNED_LONG_LONG,MPI_SUM,0, comm);
uint64_t* sb2 = (uint64_t *) malloc(sizeof(uint64_t));;
uint64_t* rb2 = (uint64_t *) malloc(sizeof(uint64_t));
sb2[0] = adios_totalsize;
MPI_Reduce(sb2,rb2,1,MPI_UNSIGNED_LONG_LONG,MPI_SUM,0, comm);
if(rank==0){
printf("total adios_totalsize = %" PRId64 "\n", *rb2);
printf("total adios_groupsize = %" PRId64 "\n", *rb);
}
free(sb); free(rb); free(sb2); free(rb2);
if (TIMING==100) {
end_time[0] = MPI_Wtime();
total_time[0]+=end_time[0] - start_time[0]; //variable definition time taken
}
// now we have to write out the variables.... since they are all declared now
// This will be the place we actually write out the data!!!!!!!!
for (i = 0; i < g->vars_count; i++) {
ADIOS_VARINFO * v = adios_inq_var_byid (g, i);
getbasename (g->var_namelist[i], &var_path, &var_name);
if (v->ndim == 0)
{
if (DEBUG) {
printf ("ADIOS WRITE SCALAR: rank=%d, name=%s value=",
rank,g->var_namelist[i]);
print_data (v->value, 0, v->type);
printf ("\n");
}
if (TIMING==100) {
start_time[2] = MPI_Wtime();
}
adios_write(m_adios_file,g->var_namelist[i],v->value);
if (TIMING==100) {
end_time[2] = MPI_Wtime();
total_time[2]+=end_time[2] - start_time[2]; //IO write time...
}
}
else
{
for(j=0; j<v->ndim; j++){
s[j] = 0;
c[j] = 1;
}
getTypeInfo( v->type, &element_size);
uint64_t total_size = 1;
for (ii=0;ii<v->ndim;ii++)
total_size*=v->dims[ii];
chunk_size = calcChunkSize(total_size, read_buffer*1024*1024/element_size, size);
calcC(chunk_size, v, c);
chunk_size = 1;
for(ii=0; ii<v->ndim; ii++)
chunk_size *= c[ii];
uint64_t current_step = rank*chunk_size;
if(current_step<total_size)
rS(v, s, current_step, rank);
uint64_t elements_written = 0;
while(current_step < total_size)
{
uint64_t ts[] = {0,0,0,0,0,0,0,0,0,0};
arrCopy(s, ts);
uint64_t remain_chunk = chunk_size;
if(current_step+chunk_size>total_size)
remain_chunk = total_size-current_step;
uint64_t tc[] = {1,1,1,1,1,1,1,1,1,1};
arrCopy(c, tc);
do{
uint64_t uc[] = {1,1,1,1,1,1,1,1,1,1};
uint64_t used_chunk = remain_chunk;
remain_chunk = checkBound(v, ts, tc, uc, remain_chunk);
checkOverflow(1, v, ts, uc);
used_chunk -= remain_chunk;
elements_written += used_chunk;
//allocated space for data read-in
data = (void *) malloc(used_chunk*element_size);
if (TIMING==100) {
start_time[1] = MPI_Wtime();
}
if(PERFORMANCE_CHECK) printf("rank=%d, read start\n",rank);
bytes_read = adios_read_var_byid(g,v->varid,ts,uc,data);
if(PERFORMANCE_CHECK) printf("rank=%d, read end\n",rank);
if (TIMING==100) {
end_time[1] = MPI_Wtime();
total_time[1]+=end_time[1] -start_time[1]; //IO read time
}
if (DEBUG)
printf ("ADIOS WRITE: rank=%d, name=%s datasize=%" PRId64 "\n",rank,g->var_namelist[i],bytes_read);
if (TIMING==100) {
start_time[2] = MPI_Wtime();
}
if (DEBUG){
printf("rank=%d, write ts=",rank);
int k;
for(k=0; k<v->ndim; k++)
printf("%" PRId64 ",", ts[k]);
printf(" uc=");
for(k=0; k<v->ndim; k++)
printf("%" PRId64 ",", uc[k]);
printf("\n");
}
//local bounds and offets placeholders are not written out with actual values.
if(PERFORMANCE_CHECK) printf("rank=%d, adios write start\n", rank);
for(k=0; k<v->ndim; k++){
//sprintf(tstring, "ldim%d_%s", k, var_name);
sprintf(tstring, "ldim%d", k);
if (DEBUG) {
printf ("ADIOS WRITE DIMENSION: rank=%d, name=%s value=",
rank,tstring);
print_data (&uc[k], 0, adios_unsigned_long);
printf ("\n");
}
adios_write(m_adios_file, tstring, &uc[k]);
//sprintf(tstring, "offs%d_%s", k, var_name);
sprintf(tstring, "offs%d", k);
if (DEBUG) {
printf ("ADIOS WRITE OFFSET: rank=%d, name=%s value=",
rank,tstring);
print_data (&ts[k], 0, adios_unsigned_long);
printf ("\n");
}
adios_write(m_adios_file, tstring, &ts[k]);
}
adios_write(m_adios_file,g->var_namelist[i],data);
if(PERFORMANCE_CHECK) printf("rank=%d, adios write end\n", rank);
if (TIMING==100) {
end_time[2] = MPI_Wtime();
total_time[2]+=end_time[2] - start_time[2]; //IO write time
}
free(data);
if(remain_chunk!=0){
rS(v, ts, used_chunk, rank);
for(k=0; k<10; k++)
tc[k] = 1;
calcC(remain_chunk, v, tc);
}
}while(remain_chunk!=0);
current_step += size*chunk_size;
if(current_step<total_size)
rS(v, s, size*chunk_size,rank);
}
if(DEBUG){
uint64_t* sb = (uint64_t *) malloc(sizeof(uint64_t));;
uint64_t* rb = (uint64_t *) malloc(sizeof(uint64_t));
sb[0] = elements_written;
MPI_Reduce(sb,rb,1,MPI_UNSIGNED_LONG_LONG,MPI_SUM,0, comm);
if(rank==0 && rb[0]!=total_size)
printf("some array read mismatch. please use debug mode\n");
free(sb); free(rb);
}
}
free (var_name);
free (var_path);
}// end of the writing of the variable..
if (TIMING==100) {
start_time[3] = MPI_Wtime();
}
if(PERFORMANCE_CHECK) printf("rank=%d, adios_close start\n", rank);
adios_close(m_adios_file);
if(PERFORMANCE_CHECK) printf("rank=%d, adios_close end\n", rank);
if (TIMING==100) {
end_time[3] = MPI_Wtime();
total_time[3]+=end_time[3] - start_time[3];
}
adios_gclose(g);
} //end of WRITEME
} // end of all of the groups
if(rank==0)
printf("conversion done!\n");
if(TIMING==100)
start_time[4] = MPI_Wtime();
adios_fclose(f);
if(TIMING==100){
end_time[4] = MPI_Wtime();
total_time[4] = total_time[4]+end_time[4]-start_time[4];
}
adios_finalize(rank);
// now, we write out the timing data, for each category, we give max, min, avg, std, all in seconds, across all processes.
if(TIMING==100){
// 0: adios_open, adios_group_size
// 1: the total time to read in the data
// 2: times around each write (will only work if we do NOT buffer....
// 3: the time in the close
// 4: fopen, fclose
// 5: total time
end_time[5] = MPI_Wtime();
total_time[5] = end_time[5] - start_time[5];
double sb[7];
sb[0] = total_time[1]; sb[1] = total_time[4]; //read_var, fopen+fclose
sb[2] = sb[0]+sb[1];
sb[3] = total_time[0]; sb[4] = total_time[2]+total_time[3]; //adios_open+adios_group_size, write+close
sb[5] = sb[3]+sb[4];
sb[6] = total_time[5]; //total
double * rb = NULL;
if(rank==0)
rb = (double *)malloc(size*7*sizeof(double));
//MPI_Barrier(comm);
MPI_Gather(sb, 7, MPI_DOUBLE, rb, 7, MPI_DOUBLE, 0, comm);
if(rank==0){
double read_avg1 = 0;
double read_avg2 = 0;
double tread_avg = 0;
double write_avg1 = 0;
double write_avg2 = 0;
double twrite_avg = 0;
double total_avg = 0;
for(j=0; j<size; j++){
read_avg1 += rb[7*j];
read_avg2 += rb[7*j+1];
tread_avg += rb[7*j+2];
write_avg1 += rb[7*j+3];
write_avg2 += rb[7*j+4];
twrite_avg += rb[7*j+5];
total_avg += rb[7*j+6];
}
read_avg1 /= size;
read_avg2 /= size;
tread_avg /= size;
write_avg1 /= size;
write_avg2 /= size;
twrite_avg /= size;
total_avg /= size;
double read1_max = rb[0];
double read1_min = rb[0];
double read1_std = rb[0]-read_avg1; read1_std *= read1_std;
double read2_max = rb[1];
double read2_min = rb[1];
double read2_std = rb[1]-read_avg2; read2_std *= read2_std;
double tread_max = rb[2];
double tread_min = rb[2];
double tread_std = rb[2]-tread_avg; tread_std *= tread_std;
double write1_max = rb[3];
double write1_min = rb[3];
double write1_std = rb[3]-write_avg1; write1_std *= write1_std;
double write2_max = rb[4];
double write2_min = rb[4];
double write2_std = rb[4]-write_avg2; write2_std *= write2_std;
double twrite_max = rb[5];
double twrite_min = rb[5];
double twrite_std = rb[5]-twrite_avg; twrite_std *= twrite_std;
double total_max = rb[6];
double total_min = rb[6];
double total_std = rb[6]-total_avg; total_std *= total_std;
for(j=1; j<size; j++){
if(rb[7*j]>read1_max)
read1_max = rb[7*j];
else if(rb[7*j]<read1_min)
read1_min = rb[7*j];
double std = rb[7*j]-read_avg1; std *= std;
read1_std += std;
if(rb[7*j+1]>read2_max)
read2_max = rb[7*j+1];
else if(rb[7*j+1]<read2_min)
read2_min = rb[7*j+1];
std = rb[7*j+1]-read_avg2; std *= std;
read2_std += std;
if(rb[7*j+2]>tread_max)
tread_max = rb[7*j+2];
else if(rb[7*j+2]<tread_min)
tread_min = rb[7*j+2];
std = rb[7*j+2]-tread_avg; std *= std;
tread_std += std;
if(rb[7*j+3]>write1_max)
write1_max = rb[7*j+3];
else if(rb[7*j+3]<write1_min)
write1_min = rb[7*j+3];
std = rb[7*j+3]-write_avg1; std *= std;
write1_std += std;
if(rb[7*j+4]>write2_max)
write2_max = rb[7*j+4];
else if(rb[7*j+4]<write2_min)
write2_min = rb[7*j+4];
std = rb[7*j+4]-write_avg2; std *= std;
write2_std += std;
if(rb[7*j+5]>twrite_max)
twrite_max = rb[7*j+5];
else if(rb[7*j+5]<twrite_min)
twrite_min = rb[7*j+5];
std = rb[7*j+5]-twrite_avg; std *= std;
twrite_std += std;
if(rb[7*j+6]>total_max)
total_max = rb[7*j+6];
else if(rb[7*j+6]<total_min)
total_min = rb[7*j+6];
std = rb[7*j+6]-total_avg; std *= std;
total_std += std;
}
read1_std /= size; read1_std = sqrt(read1_std);
read2_std /= size; read2_std = sqrt(read2_std);
tread_std /= size; tread_std = sqrt(tread_std);
write1_std /= size; write1_std = sqrt(write1_std);
write2_std /= size; write2_std = sqrt(write2_std);
twrite_std /= size; twrite_std = sqrt(twrite_std);
total_std /= size; total_std = sqrt(total_std);
printf("---type--- max\tmin\tavg\tstd\n");
printf("---read_var--- %lf\t%lf\t%lf\t%lf\n", read1_max, read1_min, read_avg1, read1_std);
printf("---fopen+fclose--- %lf\t%lf\t%lf\t%lf\n", read2_max, read2_min, read_avg2, read2_std);
printf("---total_read--- %lf\t%lf\t%lf\t%lf\n", tread_max, tread_min, tread_avg, tread_std);
printf("---adios_open+adios_groupsize--- %lf\t%lf\t%lf\t%lf\n", write1_max, write1_min, write_avg1, write1_std);
printf("---write+close--- %lf\t%lf\t%lf\t%lf\n", write2_max, write2_min, write_avg2, write2_std);
printf("---total_write--- %lf\t%lf\t%lf\t%lf\n", twrite_max, twrite_min, twrite_avg, twrite_std);
printf("---total--- %lf\t%lf\t%lf\t%lf\n", total_max, total_min, total_avg, total_std);
free(rb);
}
}
// if (TIMING==100 && rank==0) {
// printf("------------------------------------------------------------------\n");
// printf("Define variables = %lf\n",total_time[0]);
// printf("Read variables = %lf\n",total_time[1]);
// printf("Write variables = %lf\n",total_time[2]);
// printf("Close File for write = %lf\n",total_time[3]);
// printf("Total write time = %lf\n",total_time[2] + total_time[3]);
// for (itime=0;itime<timers-1;itime++)
// total_time[timers-1]+=total_time[itime];
// printf("Total I/O time = %lf\n",total_time[timers-1]);
// }
MPI_Finalize();
return(0);
}
extern "C" JNIEXPORT int
JVM_handle_linux_signal(int sig,
siginfo_t* info,
void* ucVoid,
int abort_if_unrecognized) {
// in fact this isn't ucontext_t* at all, but struct sigcontext*
// but Linux porting layer uses ucontext_t, so to minimize code change
// we cast as needed
ucontext_t* ucFake = (ucontext_t*) ucVoid;
sigcontext* uc = (sigcontext*)ucVoid;
Thread* t = ThreadLocalStorage::get_thread_slow();
SignalHandlerMark shm(t);
// Note: it's not uncommon that JNI code uses signal/sigset to install
// then restore certain signal handler (e.g. to temporarily block SIGPIPE,
// or have a SIGILL handler when detecting CPU type). When that happens,
// JVM_handle_linux_signal() might be invoked with junk info/ucVoid. To
// avoid unnecessary crash when libjsig is not preloaded, try handle signals
// that do not require siginfo/ucontext first.
if (sig == SIGPIPE || sig == SIGXFSZ) {
// allow chained handler to go first
if (os::Linux::chained_handler(sig, info, ucVoid)) {
return true;
} else {
if (PrintMiscellaneous && (WizardMode || Verbose)) {
char buf[64];
warning("Ignoring %s - see bugs 4229104 or 646499219",
os::exception_name(sig, buf, sizeof(buf)));
}
return true;
}
}
JavaThread* thread = NULL;
VMThread* vmthread = NULL;
if (os::Linux::signal_handlers_are_installed) {
if (t != NULL ){
if(t->is_Java_thread()) {
thread = (JavaThread*)t;
}
else if(t->is_VM_thread()){
vmthread = (VMThread *)t;
}
}
}
// decide if this trap can be handled by a stub
address stub = NULL;
address pc = NULL;
address npc = NULL;
//%note os_trap_1
if (info != NULL && uc != NULL && thread != NULL) {
pc = address(SIG_PC(uc));
npc = address(SIG_NPC(uc));
// Check to see if we caught the safepoint code in the
// process of write protecting the memory serialization page.
// It write enables the page immediately after protecting it
// so we can just return to retry the write.
if ((sig == SIGSEGV) && checkSerializePage(thread, (address)info->si_addr)) {
// Block current thread until the memory serialize page permission restored.
os::block_on_serialize_page_trap();
return 1;
}
if (checkPrefetch(uc, pc)) {
return 1;
}
// Handle ALL stack overflow variations here
if (sig == SIGSEGV) {
if (checkOverflow(uc, pc, (address)info->si_addr, thread, &stub)) {
return 1;
}
}
if (sig == SIGBUS &&
thread->thread_state() == _thread_in_vm &&
thread->doing_unsafe_access()) {
stub = StubRoutines::handler_for_unsafe_access();
}
if (thread->thread_state() == _thread_in_Java) {
do {
// Java thread running in Java code => find exception handler if any
// a fault inside compiled code, the interpreter, or a stub
if ((sig == SIGSEGV) && checkPollingPage(pc, (address)info->si_addr, &stub)) {
break;
}
if ((sig == SIGBUS) && checkByteBuffer(pc, &stub)) {
break;
}
if ((sig == SIGSEGV || sig == SIGBUS) &&
checkVerifyOops(pc, (address)info->si_addr, &stub)) {
break;
}
if ((sig == SIGSEGV) && checkZombie(uc, &pc, &stub)) {
break;
}
if ((sig == SIGILL) && checkICMiss(uc, &pc, &stub)) {
break;
}
if ((sig == SIGFPE) && checkFPFault(pc, info->si_code, thread, &stub)) {
break;
}
if ((sig == SIGSEGV) &&
checkNullPointer(pc, (intptr_t)info->si_addr, thread, &stub)) {
break;
}
} while (0);
// jni_fast_Get<Primitive>Field can trap at certain pc's if a GC kicks in
// and the heap gets shrunk before the field access.
if ((sig == SIGSEGV) || (sig == SIGBUS)) {
checkFastJNIAccess(pc, &stub);
}
}
if (stub != NULL) {
// save all thread context in case we need to restore it
thread->set_saved_exception_pc(pc);
thread->set_saved_exception_npc(npc);
set_cont_address(uc, stub);
return true;
}
}
// signal-chaining
if (os::Linux::chained_handler(sig, info, ucVoid)) {
return true;
}
if (!abort_if_unrecognized) {
// caller wants another chance, so give it to him
return false;
}
if (pc == NULL && uc != NULL) {
pc = os::Linux::ucontext_get_pc((ucontext_t*)uc);
}
// unmask current signal
sigset_t newset;
sigemptyset(&newset);
sigaddset(&newset, sig);
sigprocmask(SIG_UNBLOCK, &newset, NULL);
VMError err(t, sig, pc, info, ucVoid);
err.report_and_die();
ShouldNotReachHere();
}
extern "C" void *
xmalloc2(size_t n, size_t size)
{
return xmalloc(checkOverflow(n, size, "malloc"));
}
