void ConfigReader::processFileList(std::vector<std::string> path){
for(std::vector<std::string>::iterator it = path.begin(); it != path.end(); ++it) {
DEBUG_FUNCTION_LINE("Reading %s\n",it->c_str());
std::string result = loadFileToString(*it);
ConfigParser parser(result);
parser.parseIni();
}
}
std::string Limitless::loadResource(std::string externVariable, std::string fileName)
{
std::string fileContent;
boost::filesystem::path path(fileName);
fileContent=loadFileToString(path.parent_path().string(), path.filename().string());
if(fileContent.empty())
return externVariable;
return fileContent;
}
char* loadExternalFileToString(const char* filename)
{
if (isURIPath(filename) != 0) {
// local file
return loadFileToString(filename);
}
else if (string_startsWith(filename, "file://") == 0) {
char* localPath = uriToLocalPath(filename);
char* result = NULL;
if (!localPath) {
return NULL;
}
result = loadFileToString(localPath);
free(localPath);
return result;
}
else {
return curlGetURLInMemory(filename);
}
}
string
getMockFromDisk(string fileName)
{
// string fileName
path binPath = confParam<string>("argv0");
path filePath = binPath.remove_filename() /
"../../financials/mocks" / fileName;
cout << "going to load file at " << filePath.string();
string filing = loadFileToString(filePath.string());
return filing;
}
void Document::loadFromCurrenttDir( const String& fileName_ )
{
FRL_EXCEPT_GUARD();
String currDir = io::fs::getCurrentDirectory();
io::fs::addSlashToEndPath( currDir );
fileName = currDir + fileName_;
String buffer;
loadFileToString( fileName, buffer );
buffer.erase( std::remove_if( buffer.begin(), buffer.end(), private_::isCRLF ), buffer.end() ); // remove CRLF
parseHeader( buffer );
NodesList tmpMap = Parser::getSubNodes( buffer );
if( tmpMap.size() > 1 )
FRL_THROW_S_CLASS( Document::BrokenXML ); // must be one root node
root = (*tmpMap.begin());
}
int main () {
assert (restart_gl_log ());
Rendebal_Object ro;
GLuint shader_programme;
GLfloat points[] = {
0.0f, 0.5f, 0.0f,
0.5f, -0.5f, 0.0f,
-0.5f, -0.5f, 0.0f
};
std::string vs = loadFileToString("Resources/basic.vert");
std::string fs = loadFileToString("Resources/basic.frag");
const char* vertex_shader = vs.c_str();
const char* fragment_shader = fs.c_str();
struct render_object object;
object.points = points;
object.pointsSize = 9;
GLFWwindow* window;
window = CreateGLFWWindow(false);
loadVertexToGPU(&object, &ro);
shader_programme = buildShaderProgram(vertex_shader, fragment_shader);
ro.shader_programme = shader_programme;
mainLoop(ro, window);
// close GL context and any other GLFW resources
glfwTerminate();
return 0;
}
std::string Limitless::loadFileToString(std::string path, std::string fileName)
{
std::string buffer;
std::string filePath=path+'/'+fileName;
FILE *file=fopen(filePath.c_str(), "r");
if(file != NULL)
{
int capacity=1024;
char *localBuffer=(char *)malloc(capacity);
boost::regex expression("^\\s*#include\\s*[\"<]\\s*([\\w.]+)\\s*[\">]\\s*?");
while(fgets(localBuffer, capacity, file) != NULL)
{
while(strlen(localBuffer) == capacity-1)
{
if(localBuffer[capacity-2] == '\n')
break;
localBuffer=(char *)realloc(localBuffer, capacity+1024);
if(localBuffer == NULL)
return buffer;
if(fgets(&localBuffer[capacity-1], 1025, file) == NULL)
break;
capacity+=1024;
}
boost::cmatch match;
if(regex_match(localBuffer, match, expression))
buffer+=loadFileToString(path, match[1]);
else
buffer+=localBuffer;
}
fclose(file);
free(localBuffer);
}
return buffer;
}
int main(int argc, char **argv)
{
const char *kernelname = "counthits";
unsigned count =10000;
cl_int err;
cl_context cl_context;
cl_program program;
cl_kernel cl_kernel;
cl_mem cl_out;
cl_command_queue cl_queue;
size_t i, nthreads, hits_sz;
size_t cores, work_group_size;
cl_uint2 * hits_host;
double d = 0.; // timer
d = timer(&d);
progname = argv[0];
CHECK(cl::Platform::get(&platformList));
CHECKERR( cl_context = createCLContext(CL_DEVICE_TYPE_GPU,cl_vendor::VENDOR_AMD, &err) );
std::vector<cl::Device> devices;
CHECKERR( devices = cl_context.getInfo<CL_CONTEXT_DEVICES>(&err) );
size_t length = 0;
const char * sourceStr = loadFileToString("pi_opencl_kernel.ocl","",&length);
cl::Program::Sources sources(1, std::make_pair(sourceStr, length));
program = cl::Program(cl_context, sources);
CHECK( program.build(devices,"-I ..\\include") );
CHECKERR(work_group_size = devices[0].getInfo<CL_DEVICE_MAX_WORK_GROUP_SIZE>(&err) );
CHECKERR(cores = devices[0].getInfo<CL_DEVICE_MAX_COMPUTE_UNITS>(&err) );
cores *= 16*4; //Tahiti.
if (work_group_size > 64) work_group_size /= 2;
nthreads = cores * work_group_size*32; //2048*128 = 262144
if (count == 0)
count = NTRIES/nthreads; //38
printf("Count: %lu\n",count);
hits_sz = nthreads * sizeof(hits_host[0]);//2097152
CHECKNOTZERO(hits_host = (cl_uint2 *)malloc(hits_sz));
CHECKERR ( cl_out = cl::Buffer( cl_context, CL_MEM_WRITE_ONLY | CL_MEM_USE_HOST_PTR, hits_sz, hits_host, &err));
CHECKERR ( cl_kernel = cl::Kernel(program,kernelname,&err) );
CHECK ( cl_kernel.setArg( 0, count) );
CHECK ( cl_kernel.setArg( 1, cl_out) );
CHECKERR (cl_queue = cl::CommandQueue(cl_context, devices[0], 0, &err) );
cl::Event event;
CHECK( cl_queue.enqueueNDRangeKernel(cl_kernel,cl::NullRange,cl::NDRange(nthreads), cl::NDRange(work_group_size), NULL, &event) );
event.wait();
CHECK( cl_queue.enqueueReadBuffer(cl_out, CL_TRUE, 0,hits_sz, hits_host) );
unsigned long hits = 0, tries = 0;
for (i = 0; i < nthreads; i++) {
#ifdef _DEBUG
printf("%lu %u %u\n", (unsigned long)i, hits_host[i].s[0], hits_host[i].s[1]);
#endif
hits += hits_host[i].s[0];
tries += hits_host[i].s[1];
}
return pi_check(hits, tries);
}