void sha1_init(size_t user_kpc)
{
kpc = user_kpc;
load_source();
createDevice();
createkernel();
create_clobj();
}
Value load_in_global_module(StringConstPtr _file) {
std::string file;
string_to_std_string(_file, file);
std::string path;
if (expand_load_path(file, path)) {
ASSERT(get_module_type(path) == ModuleTypeSource); // only source modules are supported in load_in_global_module
Value mod = get_global_module();
if (compile_module(path, load_source(file), mod)) {
return object_get_instance_variable(mod, snow::sym("__module_value__"));
} else {
fprintf(stderr, "ERROR: Could not compile module: %s\n", path.c_str());
return NULL;
}
} else {
throw_exception_with_description("File not found in any load path: %@", file.c_str());
return NULL;
}
}
void Program::compile(){
load_source();
glShaderSource(fragment_shader, 1, &fragment_source, NULL);
glShaderSource(vertex_shader, 1, &vertex_source, NULL);
glCompileShader(vertex_shader);
glCompileShader(fragment_shader);
GLint status;
glGetShaderiv(vertex_shader, GL_COMPILE_STATUS, &status);
std::cout << "Vertex Shader: " << error(status) << std::endl;
glGetShaderiv(fragment_shader, GL_COMPILE_STATUS, &status);
std::cout << "Fragment Shader: " << error(status) << std::endl;
glGetShaderInfoLog(fragment_shader, 512, NULL, fragment_status);
glGetShaderInfoLog(vertex_shader, 512, NULL, vertex_status);
glAttachShader(program, vertex_shader);
glAttachShader(program, fragment_shader);
glLinkProgram(program);
GLint isLinked = 0;
glGetProgramiv(program, GL_LINK_STATUS, &isLinked);
if(isLinked == GL_FALSE)
{
GLint maxLength = 0;
glGetProgramiv(program, GL_INFO_LOG_LENGTH, &maxLength);
//The maxLength includes the NULL character
std::vector<GLchar> infoLog(maxLength);
glGetProgramInfoLog(program, maxLength, &maxLength, &infoLog[0]);
for(auto l: infoLog)
std::cout << l;
//Provide the infolog in whatever manner you deem best.
//Exit with failure.
}
}
int
main (int argc,
char **argv)
{
AppData *data;
gtk_init (&argc, &argv);
data = g_slice_new0 (AppData);
data->settings = load_settings ();
create_gui (data);
update_processor (data);
/* Load input file */
if (argc == 2)
load_source (data, argv[1]);
gtk_main ();
return 0;
}
void execute(cl_device_id device, cl_context context, cl_command_queue queue)
{
cl_int err;
cl_program program;
cl_kernel kernel;
char *source;
size_t length;
size_t global_size[] = {NUM_WORLDS, ROBOTS_PER_WORLD};
size_t local_size[] = {1, ROBOTS_PER_WORLD};
cl_uint ann_param_size = ANN_PARAM_SIZE;
cl_float targets_distance = TARGETS_DISTANCE;
cl_uint save = 0;
unsigned int i, j, k;
char *param_list = (char*) malloc(NUM_WORLDS * ANN_PARAM_SIZE);
for (i=0; i<NUM_WORLDS; i++)
{
for (j=0; j < ANN_PARAM_SIZE; j++)
{
param_list[(i*ANN_PARAM_SIZE)+j] = params[j];
}
}
cl_float4 *random_positions = (cl_float4*) malloc(NUM_WORLDS * ROBOTS_PER_WORLD * 10 * sizeof(cl_float4));
for (i=0; i<NUM_WORLDS; i++)
{
for (j=0; j < ROBOTS_PER_WORLD; j++)
{
for (k=0; k < 10; k++)
{
random_positions[i*(ROBOTS_PER_WORLD*10)+j*10+k].s0 = RANDF();
random_positions[i*(ROBOTS_PER_WORLD*10)+j*10+k].s1 = RANDF();
random_positions[i*(ROBOTS_PER_WORLD*10)+j*10+k].s2 = RANDF();
random_positions[i*(ROBOTS_PER_WORLD*10)+j*10+k].s3 = RANDF();
}
}
}
char build_options[4096];
sprintf(
build_options,
"-I\"%s\" -DNUM_WORLDS=%d -DROBOTS_PER_WORLD=%d -DTIME_STEP=%f -DTA=%d -DTB=%d -DWORLDS_PER_LOCAL=%d -DROBOTS_PER_LOCAL=%d",
"/home/buratti/srs2d/srs2d/kernels", NUM_WORLDS, ROBOTS_PER_WORLD, TIME_STEP, TA, TB, (int) local_size[0], (int) local_size[1]
);
// load source code from file
length = load_source("../srs2d/kernels/physics.cl", &source);
assert(length > 0, -1, "load_source()");
// create and build program
program = clCreateProgramWithSource(context, 1, (const char **) &source, &length, &err);
assert(err == CL_SUCCESS, err, "clCreateProgramWithSource()");
err = clBuildProgram(program, 0, NULL, (const char*) build_options, NULL, NULL);
if ((err != CL_SUCCESS) && (err == CL_BUILD_PROGRAM_FAILURE))
{
cl_build_status build_status;
char *build_log;
size_t build_log_size;
err = clGetProgramBuildInfo(program, device, CL_PROGRAM_BUILD_STATUS, sizeof(cl_build_status), &build_status, NULL);
assert(err == CL_SUCCESS, err, "clGetProgramBuildInfo()");
err = clGetProgramBuildInfo(program, device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
assert(err == CL_SUCCESS, err, "clGetProgramBuildInfo()");
build_log = (char *) malloc(build_log_size+1);
err = clGetProgramBuildInfo(program, device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
assert(err == CL_SUCCESS, err, "clGetProgramBuildInfo()");
build_log[build_log_size] = '\0';
fprintf(stderr, "BUILD LOG:\n%s\n\n", build_log);
free(build_log);
exit(EXIT_FAILURE);
}
// create buffers
cl_mem worlds_buffer = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(world_t) * NUM_WORLDS, NULL, &err);
assert(err == CL_SUCCESS, err, "clCreateBuffer()");
cl_mem param_buffer = clCreateBuffer(context, CL_MEM_READ_ONLY, sizeof(cl_char) * ANN_PARAM_SIZE * NUM_WORLDS, NULL, &err);
assert(err == CL_SUCCESS, err, "clCreateBuffer()");
cl_mem random_positions_buffer = clCreateBuffer(context, CL_MEM_READ_ONLY, sizeof(cl_float4) * 10 * ROBOTS_PER_WORLD * NUM_WORLDS, NULL, &err);
assert(err == CL_SUCCESS, err, "clCreateBuffer()");
cl_mem fitness_buffer = clCreateBuffer(context, CL_MEM_WRITE_ONLY, sizeof(cl_float) * NUM_WORLDS, NULL, &err);
assert(err == CL_SUCCESS, err, "clCreateBuffer()");
// copy host mem to buffers
err = clEnqueueWriteBuffer(queue, param_buffer, CL_TRUE, 0, sizeof(cl_char) * ANN_PARAM_SIZE * NUM_WORLDS, param_list, 0, NULL, NULL);
assert(err == CL_SUCCESS, err, "clEnqueueWriteBuffer()");
err = clEnqueueWriteBuffer(queue, random_positions_buffer, CL_TRUE, 0, sizeof(cl_float4) * 10 * ROBOTS_PER_WORLD * NUM_WORLDS, random_positions, 0, NULL, NULL);
assert(err == CL_SUCCESS, err, "clEnqueueWriteBuffer()");
// execute simulate kernel
kernel = clCreateKernel(program, "simulate", &err);
assert(err == CL_SUCCESS, err, "clCreateKernel()");
err = CL_SUCCESS;
err |= clSetKernelArg(kernel, 0, sizeof(cl_mem), (void*) &worlds_buffer);
err |= clSetKernelArg(kernel, 1, sizeof(cl_float), (void*) &targets_distance);
err |= clSetKernelArg(kernel, 2, sizeof(cl_mem), (void*) ¶m_buffer);
err |= clSetKernelArg(kernel, 3, sizeof(cl_uint), (void*) &ann_param_size);
err |= clSetKernelArg(kernel, 4, sizeof(cl_mem), (void*) &random_positions_buffer);
err |= clSetKernelArg(kernel, 5, sizeof(cl_mem), (void*) &fitness_buffer);
err |= clSetKernelArg(kernel, 6, sizeof(cl_mem), NULL);
err |= clSetKernelArg(kernel, 7, sizeof(cl_mem), NULL);
err |= clSetKernelArg(kernel, 8, sizeof(cl_mem), NULL);
err |= clSetKernelArg(kernel, 9, sizeof(cl_mem), NULL);
err |= clSetKernelArg(kernel, 10, sizeof(cl_mem), NULL);
err |= clSetKernelArg(kernel, 11, sizeof(cl_mem), NULL);
err |= clSetKernelArg(kernel, 12, sizeof(cl_mem), NULL);
err |= clSetKernelArg(kernel, 13, sizeof(cl_mem), NULL);
err |= clSetKernelArg(kernel, 14, sizeof(cl_mem), NULL);
err |= clSetKernelArg(kernel, 15, sizeof(cl_mem), NULL);
err |= clSetKernelArg(kernel, 16, sizeof(cl_uint), (void*) &save);
assert(err == CL_SUCCESS, err, "clSetKernelArg()");
// execute kernel
err = clEnqueueNDRangeKernel(queue, kernel, 2, NULL, global_size, local_size, 0, NULL, NULL);
assert(err == CL_SUCCESS, err, "clEnqueueNDRangeKernel()");
// copy results from device
float *fitness = (float *) malloc(NUM_WORLDS * sizeof(cl_float));
err = clEnqueueReadBuffer(queue, fitness_buffer, CL_TRUE, 0, NUM_WORLDS * sizeof(cl_float), fitness, 0, NULL, NULL);
assert(err == CL_SUCCESS, err, "clEnqueueReadBuffer()");
for (i=0; i<NUM_WORLDS; i++)
printf("fitness[%d] = %f\n", i, fitness[i]);
err = CL_SUCCESS;
err |= clReleaseMemObject(worlds_buffer);
err |= clReleaseMemObject(param_buffer);
err |= clReleaseMemObject(fitness_buffer);
assert(err == CL_SUCCESS, err, "clReleaseMemObject()");
err = clReleaseKernel(kernel);
assert(err == CL_SUCCESS, err, "clReleaseKernel()");
err = clReleaseProgram(program);
assert(err == CL_SUCCESS, err, "clReleaseProgram()");
free(param_list);
free(fitness);
free(source);
}
int main(int argc, char * argv[]){
int i = load_source(argv[1]);
if (i){
NODE * ast = parse();
}
}
int main(int argc, char *argv[])
{
CGTFile cgtFile;
char *source;
Symbol *rdc;
DFA *dfa;
LALR *lalr;
ErrorTable *myErrors;
SimpleErrorRep myReporter;
// Load grammar file
if (cgtFile.load ("simple.cgt")) {
wprintf (L"%s\n", "Grammar loaded succesfully");
cgtFile.printInfo ();
} else {
wprintf (L"%s\n", "error loading file");
return -1;
}
// Load source file
char *filename = "test1.s";
source = load_source (filename);
if (source == NULL) {
wprintf (L"Error loading source file\n");
return -1;
}
// Get DFA (Deterministic Finite Automata) from the cgt file
dfa = cgtFile.getScanner();
// Scan the source in search of tokens
dfa->scan(source);
delete [] source;
// Get the error table
myErrors = dfa->getErrors();
// If there are errors report them
if (myErrors->errors.size() > 0) {
for (unsigned int i=0; i < myErrors->errors.size(); i++) {
cout << filename << ":";
cout << myReporter.composeErrorMsg (*myErrors->errors[i]) << endl;
}
return -1;
}
// Get the tokens to feed the LALR machine with them
vector <Token*> tokens = dfa->getTokens();
printTokens (tokens);
// Get the LALR (Look Ahead, Left-to-right parse, Rightmost-derivation)
lalr = cgtFile.getParser();
// Parse the tokens
rdc = lalr->parse (tokens, true, true);
myErrors = lalr->getErrors();
if (myErrors->errors.size() != 0) {
for (unsigned int i=0; i < myErrors->errors.size(); i++) {
cout << filename << ":";
cout << myReporter.composeErrorMsg (*myErrors->errors[i]) << endl;
}
return -1;
}
lalr->printReductionTree(rdc, 0);
delete rdc;
return EXIT_SUCCESS;
}
