kernel_t<COI>* kernel_t<COI>::buildFromBinary(const std::string &filename, const std::string &functionName_){ OCCA_EXTRACT_DATA(COI, Kernel); functionName = functionName_; std::string libPath, soname; getFilePrefixAndName(filename, libPath, soname); for(int i = 0; i < soname.size(); ++i){ if(soname[i] == '.'){ soname = soname.substr(0, i); break; } } COILIBRARY outLibrary; OCCA_COI_CHECK("Kernel: Loading Kernel To Chief", COIProcessLoadLibraryFromFile(data_.chiefID, filename.c_str(), soname.c_str(), NULL, &outLibrary)); const char *c_functionName = functionName.c_str(); OCCA_COI_CHECK("Kernel: Getting Handle", COIProcessGetFunctionHandles(data_.chiefID, 1, &c_functionName, &(data_.kernel))); return this; }
void init(const char* cfg) { /* get number of Xeon Phi devices */ uint32_t engines = 0; COIEngineGetCount( COI_ISA_MIC, &engines ); if (engines == 0) throw std::runtime_error("No Xeon Phi device found."); /* get engine handle */ COIRESULT result; result = COIEngineGetHandle( COI_ISA_MIC, 0, &engine ); if (result != COI_SUCCESS) throw std::runtime_error("Failed to load engine number " + std::stringOf(0) + ": " + COIResultGetName(result)); /* print info of engine */ COI_ENGINE_INFO info; result = COIEngineGetInfo(engine,sizeof(info),&info); std::cout << "Found Xeon Phi device with " << info.NumCores << " cores and " << (info.PhysicalMemory/1024/1024) << "MB memory" << std::endl; /* create process */ const std::string executable = std::string(tutorialName)+"_xeonphi_device"; result = COIProcessCreateFromFile (engine, executable.c_str(), // The local path to the sink side binary to launch. 0, NULL, // argc and argv for the sink process. false, NULL, // Environment variables to set for the sink process. true, NULL, // Enable the proxy but don't specify a proxy root path. 0, // The amount of memory to reserve for COIBuffers. NULL, // Path to search for dependencies &process // The resulting process handle. ); if (result != COI_SUCCESS) throw std::runtime_error("Failed to create process " + std::string(executable) +": " + COIResultGetName(result)); /* create pipeline */ COI_CPU_MASK cpuMask; result = COIPipelineClearCPUMask(&cpuMask); if (result != COI_SUCCESS) throw std::runtime_error(std::string("COIPipelineClearCPUMask failed: ") + COIResultGetName(result)); result = COIPipelineSetCPUMask(process,info.NumCores-1,0,&cpuMask); result = COIPipelineSetCPUMask(process,info.NumCores-1,1,&cpuMask); result = COIPipelineSetCPUMask(process,info.NumCores-1,2,&cpuMask); result = COIPipelineSetCPUMask(process,info.NumCores-1,3,&cpuMask); if (result != COI_SUCCESS) throw std::runtime_error(std::string("COIPipelineSetCPUMask failed: ") + COIResultGetName(result)); result = COIPipelineCreate(process,cpuMask,0,&pipeline); if (result != COI_SUCCESS) throw std::runtime_error(std::string("COIPipelineCreate failed: ") + COIResultGetName(result)); /* get run functions */ const char *fctNameArray[8] = { "run_init", "run_key_pressed", "run_create_mesh", "run_create_hairset", "run_create_scene", "run_pick", "run_render", "run_cleanup" }; result = COIProcessGetFunctionHandles (process, 8, fctNameArray, &runInit); if (result != COI_SUCCESS) throw std::runtime_error("COIProcessGetFunctionHandles failed: "+std::string(COIResultGetName(result))); /* run init runfunction */ InitData parms; strncpy(parms.cfg,cfg,sizeof(parms.cfg)); result = COIPipelineRunFunction (pipeline, runInit, 0, NULL, NULL, 0, NULL, &parms, sizeof(parms), NULL, 0, NULL); if (result != COI_SUCCESS) throw std::runtime_error("COIPipelineRunFunction failed: "+std::string(COIResultGetName(result))); }
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)); }