void SystemEventsManager::prevent(int event, bool prevent) {
if (prevent) {
prepareLoop();
#if VERSIONWIN
if (event == SYSTEM_SLEEP)
SetThreadExecutionState(ES_CONTINUOUS | ES_SYSTEM_REQUIRED);
#endif
}
events[event].prevent(prevent);
if (!prevent) {
stopLoop();
#if VERSIONWIN
if (event == SYSTEM_SLEEP)
SetThreadExecutionState(ES_CONTINUOUS);
#endif
}
}
void SystemEventsManager::registerCallback(int event) {
prepareLoop();
events[event].registerCallback();
}
// generator optimizing to a subproblem size
static int
copyDBlockOptimGen(
struct KgenContext *ctx,
const SubproblemDim *dim,
const PGranularity *pgran,
GenPriv *gpriv)
{
char fpref;
const char varPref[2] = {'G', 'L'};
char tmp[1024];
// lead dimension for right and transposed local block in float words
ItemWork work;
LoopCtl loopCtl;
LoopUnrollers unrollers;
const char *s, *s1, *s2;
bool image;
SubproblemDim newDim;
// copying direction within the memory or image related function group
int gdir = 0;
int r;
fpref = dtypeToPrefix(gpriv->dtype);
if (!fpref || (fpref == 'i')) {
return -EINVAL;
}
image = (gpriv->dir == DBLOCK_GLOBAL_TO_IMAGE ||
gpriv->dir == DBLOCK_LOCAL_TO_IMAGE);
memset(&unrollers, 0, sizeof(unrollers));
memset(&loopCtl, 0, sizeof(loopCtl));
memset(&newDim, 0, sizeof(newDim));
gpriv->dim = &newDim;
gpriv->work = (const ItemWork*)&work;
gpriv->globLDName = "ld";
s = (gpriv->transp) ? "Transp" : "";
s1 = (gpriv->conjugate) ? "Conj" : "";
s2 = (gpriv->notVectorize) ? "Nvec" : "";
if ((gpriv->dir == DBLOCK_LOCAL_TO_GLOBAL) && gpriv->transp) {
// pass over columns of the block stored in the local memory
newDim.x = dim->y;
newDim.y = dim->x;
}
else {
// pass over rows
newDim.x = dim->x;
newDim.y = dim->y;
}
getItemWork(&work, &newDim, pgran, gpriv->nfloats, gpriv->vecLen);
if (image) {
s = (gpriv->packed) ? "Pack" : "";
if (gpriv->dir == DBLOCK_GLOBAL_TO_IMAGE) {
sprintf(tmp, copyMemGImgDBlockDecl, fpref, s, dim->y, dim->x);
}
else {
sprintf(tmp, copyMemLImgDBlockDecl, fpref, s, dim->y, dim->x);
}
}
else {
gdir = (gpriv->dir == DBLOCK_GLOBAL_TO_LOCAL) ? 0 : 1;
sprintf(tmp, copyMemDBlockDecl, fpref, s, s1, s2, varPref[gdir],
varPref[1 - gdir], dim->y, dim->x, varPref[1 - gdir],
varPref[gdir]);
}
kgenDeclareFunction(ctx, tmp);
kgenBeginFuncBody(ctx);
kgenDeclareLocalID(ctx, lidVarName, pgran);
if (image) {
// data for loop unrolling
if (work.nrRows > 1) {
gpriv->srcName = "src1";
gpriv->dstName = "dst";
gpriv->imgXName="x1";
gpriv->imgYName="y1";
if(gpriv->dir == DBLOCK_GLOBAL_TO_IMAGE) {
kgenAddStmt(ctx, "GPtr src1;\n");
}
else if(gpriv->dir == DBLOCK_LOCAL_TO_IMAGE) {
kgenAddStmt(ctx, "LPtr src1;\n");
}
kgenAddStmt(ctx, "int x1, y1;\n");
unrollers.preUnroll = copyImgPreUnroll;
unrollers.postUnroll = copyImgPostUnroll;
}
else {
gpriv->srcName = "src";
// dst has image2d_t type here
gpriv->dstName = "dst";
gpriv->imgXName="x";
gpriv->imgYName="y";
}
}
else {
if ((gpriv->nfloats != FLOAT4_VECLEN) &&
(gpriv->transp || gpriv->conjugate)) {
/*
* temporary variable to transpose or conjugate non double
* complex elements
*/
kgenAddStmt(ctx, "float4 tmp;\n");
}
if (work.nrRows > 1) {
sprintf(tmp, privatePtrs, varPref[gdir], varPref[1 - gdir]);
kgenAddStmt(ctx, tmp);
// data for loop unrolling
unrollers.preUnroll = copyMemPreUnroll;
unrollers.postUnroll = copyMemPostUnroll;
gpriv->srcName = "src1";
gpriv->dstName = "dst1";
}
else {
gpriv->srcName = "src";
gpriv->dstName = "dst";
}
}
if ((work.nrRows > 1) || work.nrItems) {
prepareLoop(ctx, &work, &loopCtl);
}
kgenAddBlankLine(ctx);
loopCtl.inBound = (unsigned long)work.nrCols;
// now, prepare all needed for loop unrolling
if (image) {
kgenAddStmt(ctx, "int x, y;\n");
if (gpriv->packed) {
kgenAddStmt(ctx, "int pLine, index;\n");
}
gpriv->lmemLD = fl4RowWidth(dim->x, gpriv->typeSize) *
FLOAT4_VECLEN / gpriv->nfloats;
// set up starting x and y in image
addSettingImageXYCode(ctx, "x", "y", pgran, gpriv);
if (gpriv->dir == DBLOCK_GLOBAL_TO_IMAGE) {
// set initial global pointer
addSettingPtrCode(ctx, "src", 0, false, pgran, gpriv);
}
else if (gpriv->dir == DBLOCK_LOCAL_TO_IMAGE) {
// set initial local pointer
addSettingPtrCode(ctx, "src", gpriv->lmemLD, gpriv->transp,
pgran, gpriv);
}
unrollers.genSingleVec = copyImgVec;
unrollers.genSingle = copyImgSingle;
}
else {
// set initial global pointer
s = (gdir) ? "dst" : "src";
addSettingPtrCode(ctx, s, 0, false, pgran, gpriv);
s = (gdir) ? "src" : "dst";
if (!gdir && gpriv->transp) {
gpriv->lmemLD = fl4RowWidth(dim->y, gpriv->typeSize) *
FLOAT4_VECLEN / gpriv->nfloats;
}
else {
gpriv->lmemLD = fl4RowWidth(dim->x, gpriv->typeSize) *
FLOAT4_VECLEN / gpriv->nfloats;
}
if (gpriv->transp) {
unrollers.genSingleVec = (gpriv->notVectorize) ? NULL :
copyMemVecTransp;
unrollers.genSingle = copyMemSingleTransp;
}
else {
unrollers.genSingleVec = (gpriv->notVectorize) ? NULL : copyMemVec;
unrollers.genSingle = copyMemSingle;
}
addSettingPtrCode(ctx, s, gpriv->lmemLD, gpriv->transp,
pgran, gpriv);
}
unrollers.getVecLen = getVecLen;
// unroll for float4 aligned data chunk
kgenLoopUnroll(ctx, &loopCtl, gpriv->dtype, &unrollers, gpriv);
/*
* Unroll for remaining data tail.
* Block tail reading/writing is done separately
* when many work items process single row
* because the compiler don't like any conditional
* branches in loops
*/
if ((unrollers.postUnroll == NULL) && work.tail) {
addCopyTailCode(ctx, gpriv);
}
r = kgenEndFuncBody(ctx);
return r ? -EOVERFLOW : 0;
}