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;
}
PowerPageComponent::PowerPageComponent() {
bgColor = Colours::black;
bgImage = createImageFromFile(assetFile("powerMenuBackground.png"));
mainPage = new Component();
addAndMakeVisible(mainPage);
mainPage->toBack();
ChildProcess child{};
felPage = new PowerFelPageComponent();
// create back button
backButton = createImageButton(
"Back", createImageFromFile(assetFile("nextIcon.png")));
backButton->addListener(this);
backButton->setAlwaysOnTop(true);
addAndMakeVisible(backButton);
powerOffButton = new TextButton("Power OFF");
powerOffButton->setButtonText("Shutdown");
powerOffButton->addListener(this);
addAndMakeVisible(powerOffButton);
rebootButton = new TextButton("Reboot");
rebootButton->setButtonText("Reboot");
rebootButton->addListener(this);
addAndMakeVisible(rebootButton);
sleepButton = new TextButton("Sleep");
sleepButton->setButtonText("Sleep");
sleepButton->addListener(this);
addAndMakeVisible(sleepButton);
felButton = new TextButton("Fel");
felButton->setButtonText("Flash Software");
felButton->addListener(this);
addAndMakeVisible(felButton);
powerSpinnerTimer.powerComponent = this;
Array<String> spinnerImgPaths{"wait0.png","wait1.png","wait2.png","wait3.png","wait4.png","wait5.png","wait6.png","wait7.png"};
for(auto& path : spinnerImgPaths) {
auto image = createImageFromFile(assetFile(path));
launchSpinnerImages.add(image);
}
powerSpinner = new ImageComponent();
powerSpinner->setImage(launchSpinnerImages[0]);
addChildComponent(powerSpinner);
buildName = "Build: ";
auto releaseFileName = absoluteFileFromPath( "/etc/os-release" );
File releaseFile( releaseFileName );
if (releaseFile.exists()) {
auto fileStr = releaseFile.loadFileAsString();
auto lines = split(fileStr, "\n");
if (lines.size() < 9)
DBG(__func__ << ": No release information in /etc/os-release");
else {
auto releaseKv = split(lines[8],"=");
std::vector<String> releaseV(releaseKv.begin()+1,releaseKv.end());
for (const auto& val : releaseV) {
// WIP: misses the removed equals
buildName += val;
}
DBG(buildName);
}
}
#if JUCE_MAC
buildName = "Build: MacOsX Dev Build";
#endif
buildNameLabel = new Label("Build Name");
buildNameLabel->setText(buildName, NotificationType::dontSendNotification);
buildNameLabel-> setFont(16);
buildNameLabel->setJustificationType(Justification::centred);
addAndMakeVisible(buildNameLabel);
//Create rev Text
String rev_string = std::to_string(rev_number);
rev = new Label("rev", ("v0.0."+rev_string));
addAndMakeVisible(rev);
rev->setAlwaysOnTop(true);
rev->setFont(Font(20.f));
//Update button
updateButton = new TextButton("Update");
updateButton->setButtonText("Check for updates");
updateButton->setAlwaysOnTop(true);
updateButton->addListener(this);
addAndMakeVisible(updateButton);
updateButton->setVisible(false);
//Update window
updateWindow = new AlertWindow("Checking for updates",
"Downloading informations, please wait...",
AlertWindow::AlertIconType::NoIcon);
addAndMakeVisible(updateWindow, 10);
updateWindow->setAlwaysOnTop(true);
updateWindow->setVisible(false);
}
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;
}
ResourceLoadNode::~ResourceLoadNode()
{
releaseFile();
}
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));
}
