void device_t<CUDA>::cacheKernelInLibrary(const std::string &filename,
const std::string &functionName,
const kernelInfo &info_){
//---[ Creating shared library ]----
kernel tmpK = dev->buildKernelFromSource(filename, functionName, info_);
tmpK.free();
kernelInfo info = info_;
info.addDefine("OCCA_USING_GPU" , 1);
info.addDefine("OCCA_USING_CUDA", 1);
info.addOCCAKeywords(occaCUDADefines);
std::stringstream salt;
salt << "CUDA"
<< info.salt()
<< parser::version
<< dev->dHandle->compilerEnvScript
<< dev->dHandle->compiler
<< dev->dHandle->compilerFlags;
std::string cachedBinary = getCachedName(filename, salt.str());
std::string contents = readFile(cachedBinary);
//==================================
library::infoID_t infoID;
infoID.modelID = dev->modelID_;
infoID.kernelName = functionName;
library::infoHeader_t &header = library::headerMap[infoID];
header.fileID = -1;
header.mode = CUDA;
const std::string flatDevID = getIdentifier().flattenFlagMap();
header.flagsOffset = library::addToScratchPad(flatDevID);
header.flagsBytes = flatDevID.size();
header.contentOffset = library::addToScratchPad(contents);
header.contentBytes = contents.size();
header.kernelNameOffset = library::addToScratchPad(functionName);
header.kernelNameBytes = functionName.size();
}
std::string kernel_t<CUDA>::getCachedBinaryName(const std::string &filename,
kernelInfo &info_){
OCCA_EXTRACT_DATA(CUDA, Kernel);
info_.addDefine("OCCA_USING_GPU" , 1);
info_.addDefine("OCCA_USING_CUDA", 1);
info_.addOCCAKeywords(occaCUDADefines);
std::stringstream salt;
salt << "CUDA"
<< info_.salt()
<< parser::version
<< dev->dHandle->compilerEnvScript
<< dev->dHandle->compiler
<< dev->dHandle->compilerFlags;
return getCachedName(filename, salt.str());
}
kernel_t<COI>* kernel_t<COI>::buildFromSource(const std::string &filename,
const std::string &functionName_,
const kernelInfo &info_){
functionName = functionName_;
kernelInfo info = info_;
info.addDefine("OCCA_USING_CPU", 1);
info.addDefine("OCCA_USING_COI", 1);
info.addOCCAKeywords(occaCOIDefines);
std::stringstream salt;
salt << "COI"
<< info.salt()
<< dev->dHandle->compilerEnvScript
<< dev->dHandle->compiler
<< dev->dHandle->compilerFlags
<< functionName;
std::string cachedBinary = getCachedName(filename, salt.str());
std::string libPath, soname;
getFilePrefixAndName(cachedBinary, libPath, soname);
std::string libName = "lib" + soname + ".so";
cachedBinary = libPath + libName;
struct stat buffer;
bool fileExists = (stat(cachedBinary.c_str(), &buffer) == 0);
if(fileExists){
std::cout << "Found cached binary of [" << filename << "] in [" << cachedBinary << "]\n";
return buildFromBinary(cachedBinary, functionName);
}
if(!haveFile(cachedBinary)){
waitForFile(cachedBinary);
return buildFromBinary(cachedBinary, functionName);
}
std::string iCachedBinary = createIntermediateSource(filename,
cachedBinary,
info);
std::stringstream command;
if(dev->dHandle->compilerEnvScript.size())
command << dev->dHandle->compilerEnvScript << " && ";
command << dev->dHandle->compiler
#if (OCCA_OS == LINUX_OS) || (OCCA_OS == OSX_OS)
<< " -x c++ -w -nodefaultlibs -fPIC -shared"
#else
<< " /TP /LD /D MC_CL_EXE"
#endif
<< ' ' << dev->dHandle->compilerFlags
<< ' ' << info.flags
<< ' ' << iCachedBinary
#if (OCCA_OS == LINUX_OS) || (OCCA_OS == OSX_OS)
<< " -o " << cachedBinary
#else
<< " /link /OUT:" << cachedBinary
#endif
<< std::endl;
const std::string &sCommand = command.str();
std::cout << "Compiling [" << functionName << "]\n" << sCommand << "\n";
const int compileError = system(sCommand.c_str());
if(compileError){
releaseFile(cachedBinary);
throw 1;
}
OCCA_EXTRACT_DATA(COI, Kernel);
COILIBRARY outLibrary;
const COIRESULT loadingLibraryResult = COIProcessLoadLibraryFromFile(data_.chiefID,
cachedBinary.c_str(),
soname.c_str(),
NULL,
&outLibrary);
if(errorCode != COI_SUCCESS)
releaseFile(cachedBinary);
OCCA_COI_CHECK("Kernel: Loading Kernel To Chief", loadingLibraryResult);
const char *c_functionName = functionName.c_str();
const COIRESULT getFunctionHandleResult = COIProcessGetFunctionHandles(data_.chiefID,
1,
&c_functionName,
&(data_.kernel));
if(errorCode != COI_SUCCESS)
releaseFile(cachedBinary);
OCCA_COI_CHECK("Kernel: Getting Handle", getFunctionHandleResult);
releaseFile(cachedBinary);
return this;
}
void device_t<COI>::setup(const int device, const int memoryAllocated){
data = new COIDeviceData_t;
OCCA_EXTRACT_DATA(COI, Device);
uint32_t deviceCount;
OCCA_COI_CHECK("Device: Get Count",
COIEngineGetCount(COI_ISA_MIC, &deviceCount));
OCCA_CHECK(device < deviceCount);
OCCA_COI_CHECK("Device: Get Handle",
COIEngineGetHandle(COI_ISA_MIC, device, &data_.deviceID) );
std::stringstream salt;
salt << "COI"
<< occaCOIMain;
std::string cachedBinary = getCachedName("occaCOIMain", salt.str());
struct stat buffer;
bool fileExists = (stat(cachedBinary.c_str(), &buffer) == 0);
if(fileExists)
std::cout << "Found cached binary of [occaCOIMain] in [" << cachedBinary << "]\n";
else{
//---[ Write File ]-----------------
std::string prefix, name;
getFilePrefixAndName(cachedBinary, prefix, name);
const std::string iCachedBinary = prefix + "i_" + name;
if(haveFile(cachedBinary)){
std::cout << "Making [" << iCachedBinary << "]\n";
std::ofstream fs;
fs.open(iCachedBinary.c_str());
fs << occaCOIMain;
fs.close();
std::stringstream command;
command << dev->dHandle->compiler
<< " -o " << cachedBinary
<< " -x c++"
<< ' ' << dev->dHandle->compilerFlags
<< ' ' << iCachedBinary;
const std::string &sCommand = command.str();
std::cout << "Compiling [" << functionName << "]\n" << sCommand << "\n\n";
system(sCommand.c_str());
releaseFile(cachedBinary);
}
else
waitForFile(cachedBinary);
}
// [-] Tentative
std::string SINK_LD_LIBRARY_PATH;
char *c_SINK_LD_LIBRARY_PATH = getenv("SINK_LD_LIBRARY_PATH");
if(c_SINK_LD_LIBRARY_PATH != NULL)
SINK_LD_LIBRARY_PATH = std::string(c_SINK_LD_LIBRARY_PATH);
OCCA_COI_CHECK("Device: Initializing",
COIProcessCreateFromFile(data_.deviceID,
cachedBinary.c_str(),
0 , NULL,
true, NULL,
true, NULL,
memoryAllocated ? memoryAllocated : (4 << 30), // 4 GB
SINK_LD_LIBRARY_PATH.c_str(),
&(data_.chiefID)) );
const char *kernelNames[] = {"occaKernelWith1Argument" , "occaKernelWith2Arguments" , "occaKernelWith3Arguments" ,
"occaKernelWith4Arguments" , "occaKernelWith5Arguments" , "occaKernelWith6Arguments" ,
"occaKernelWith7Arguments" , "occaKernelWith8Arguments" , "occaKernelWith9Arguments" ,
"occaKernelWith10Arguments", "occaKernelWith11Arguments", "occaKernelWith12Arguments",
"occaKernelWith13Arguments", "occaKernelWith14Arguments", "occaKernelWith15Arguments",
"occaKernelWith16Arguments", "occaKernelWith17Arguments", "occaKernelWith18Arguments",
"occaKernelWith19Arguments", "occaKernelWith20Arguments", "occaKernelWith21Arguments",
"occaKernelWith22Arguments", "occaKernelWith23Arguments", "occaKernelWith24Arguments",
"occaKernelWith25Arguments"};
// [-] More hard-coding, if you know what I mean
OCCA_COI_CHECK("Device: Getting Kernel Wrappers",
COIProcessGetFunctionHandles(data_.chiefID,
25,
kernelNames,
data_.kernelWrapper));
}
