bool Arguments::handleCommandLine() const
{
if (!(mSaveLayout && haveFile() && haveOutputDir()))
return false;
CCopasiRootContainer::init(0, NULL, false);
CCopasiDataModel& model = *CCopasiRootContainer::addDatamodel();
try
{
if (!model.importSBML(mFilename, NULL))
model.loadModel(mFilename, NULL);
}
catch (CCopasiException &ex)
{
std::cerr << ex.getMessage().getAllMessageText() << std::endl;
return true;
}
for (size_t i = 0; i < model.getListOfLayouts()->size(); ++i)
{
CLayout* layout = (*model.getListOfLayouts())[i];
CQLayoutScene scene(layout, &model);
scene.recreate();
scene.saveToFile(mOutputDir + "/" + QFileInfo(mFilename.c_str()).baseName().toStdString() + "_" + layout->getObjectName() + "." + mFileType, mFileType);
}
return true;
}
bool Arguments::isValid() const
{
if (!haveFile()) return false;
if (!QFile(mFilename.c_str()).exists()) return false;
return true;
}
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;
}
kernel_t<CUDA>* kernel_t<CUDA>::buildFromSource(const std::string &filename,
const std::string &functionName_,
const kernelInfo &info_){
OCCA_EXTRACT_DATA(CUDA, Kernel);
functionName = functionName_;
kernelInfo info = info_;
std::string cachedBinary = getCachedBinaryName(filename, info);
struct stat buffer;
const 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::string libPath, soname;
getFilePrefixAndName(cachedBinary, libPath, soname);
std::string oCachedBinary = libPath + "o_" + soname + ".o";
std::string archSM = "";
if(dev->dHandle->compilerFlags.find("-arch=sm_") == std::string::npos){
std::stringstream archSM_;
int major, minor;
OCCA_CUDA_CHECK("Kernel (" + functionName + ") : Getting CUDA Device Arch",
cuDeviceComputeCapability(&major, &minor, data_.device) );
archSM_ << " -arch=sm_" << major << minor << ' ';
archSM = archSM_.str();
}
std::stringstream command;
//---[ PTX Check Command ]----------
if(dev->dHandle->compilerEnvScript.size())
command << dev->dHandle->compilerEnvScript << " && ";
command << dev->dHandle->compiler
<< ' ' << dev->dHandle->compilerFlags
<< archSM
<< " -Xptxas -v,-dlcm=cg,-abi=no"
<< ' ' << info.flags
<< " -x cu -c " << iCachedBinary
<< " -o " << oCachedBinary;
const std::string &ptxCommand = command.str();
std::cout << "Compiling [" << functionName << "]\n" << ptxCommand << "\n";
#if (OCCA_OS == LINUX_OS) || (OCCA_OS == OSX_OS)
const int ptxError = system(ptxCommand.c_str());
#else
const int ptxError = system(("\"" + ptxCommand + "\"").c_str());
#endif
// Not needed here I guess
// if(ptxError){
// releaseFile(cachedBinary);
// throw 1;
// }
//---[ Compiling Command ]----------
command.str("");
command << dev->dHandle->compiler
<< " -o " << cachedBinary
<< " -ptx -I."
<< ' ' << dev->dHandle->compilerFlags
<< archSM
<< ' ' << info.flags
<< " -x cu " << iCachedBinary;
const std::string &sCommand = command.str();
std::cout << sCommand << '\n';
const int compileError = system(sCommand.c_str());
if(compileError){
releaseFile(cachedBinary);
throw 1;
}
const CUresult moduleLoadError = cuModuleLoad(&data_.module,
cachedBinary.c_str());
if(moduleLoadError)
releaseFile(cachedBinary);
OCCA_CUDA_CHECK("Kernel (" + functionName + ") : Loading Module",
moduleLoadError);
const CUresult moduleGetFunctionError = cuModuleGetFunction(&data_.function,
data_.module,
functionName.c_str());
if(moduleGetFunctionError)
releaseFile(cachedBinary);
OCCA_CUDA_CHECK("Kernel (" + functionName + ") : Loading Function",
moduleGetFunctionError);
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));
}