int main(int argc, char *argv[])
{
struct timeval s_time, e_time;
gettimeofday(&s_time, NULL);
init_rpc();
gettimeofday(&e_time, NULL);
double diff = sub_timeval(&s_time, &e_time);
printf("%f\n", diff);
return 0;
}
int main() {
struct event_base *base = event_base_new();
c = init_rpc(base);
int inc = 2;
rpc_register(c, "test1", test1, &inc);
struct rpc_target dest = { HTTP, "0.0.0.0", 12321 };
init_rpc_server(c, &dest);
signal(SIGINT, exit_handler);
event_base_dispatch(base);
return 0;
}
int main() {
struct event_base *base = event_base_new();
struct rpc_target dest = { HTTP, "127.0.0.1", 12321 };
struct rpc_context *c = init_rpc(base);
init_rpc_client(c);
json_int_t i = 40;
struct data_t param1 = { RPC_INT, &i, NULL, 0};
const struct data_t* param[] = { ¶m1 };
struct method_t m = {"test1", (struct data_t**)param, 1};
int j = 42;
rpc_call(c, &dest, &m, test1_cb, &j);
event_base_dispatch(base);
deinit_rpc(c);
event_base_free(base);
return 0;
}
struct server_context_t *init_raft_server(int id, const char *basedir,
const char *host, int port, enum rpc_proto proto,
long election_timeout, long heartbeat_timeout) {
struct server_context_t *s = (struct server_context_t *)malloc(
sizeof(struct server_context_t));
if(!s) {
return NULL;
}
s->host = u_strdup(host);
s->port = port;
s->id = id;
s->state = FOLLOWER;
s->current_term = 0;
s->commit_index = 0;
s->commit_term = 0;
s->log_last_applied = 0;
s->quoram_size = 1; //TODO: read from config file
s->current_votes = 0;
s->basedir = u_strdup(basedir);
char *logdir = path_join(basedir, RAFT_LOGDIR);
s->log = init_log(logdir);
if(!s->log) {
deinit_raft_server(s);
free(logdir);
return NULL;
}
free(logdir);
s->last_entry = get_last_entry(s->log);
load_state(s);
s->next_index = 0;
s->match_index = 0;
s->stm = init_stm(s);
s->base = event_base_new();
if(!s->base) {
//LOG:FATAL event loop init failed
deinit_raft_server(s);
return NULL;
}
s->timer_el = event_new(s->base, -1, EV_PERSIST, election_timeout_callback, s);
s->timer_hb = event_new(s->base, -1, EV_PERSIST, heartbeat_timeout_callback, s);
s->election_timeout_ = election_timeout;
s->election_timeout = time_in_timeval(election_timeout);
s->heartbeat_timeout_ = heartbeat_timeout;
s->heartbeat_timeout = time_in_timeval(heartbeat_timeout);
if(!s->timer_el || !s->timer_hb || !s->election_timeout
|| !s->heartbeat_timeout) {
//LOG:FATAL timer creation failed
deinit_raft_server(s);
return NULL;
}
s->last_heartbeat_at = 0;
//initially just add election timer and add heartbeat timer later
//when this server elected as the leader
if(event_add(s->timer_el, s->election_timeout)) {
//LOG:FATAL timer event registration failed
deinit_raft_server(s);
return NULL;
}
s->rpc_s = init_rpc(s->base);
s->rpc_c = init_rpc(s->base);
if(!s->rpc_s || !s->rpc_c) {
//LOG:FATAL RPC init failed
deinit_raft_server(s);
return NULL;
}
struct rpc_target *listen_dest = (struct rpc_target *)
malloc(sizeof(struct rpc_target));
if(!listen_dest) {
deinit_raft_server(s);
return NULL;
}
listen_dest->proto = HTTP;
listen_dest->host = s->host;
listen_dest->port = s->port;
int res = 0;
res |= init_rpc_server(s->rpc_s, listen_dest);
res |= init_rpc_client(s->rpc_c);
if(res) {
//LOG:FATAL rpc server init failed
deinit_raft_server(s);
return NULL;
}
free(listen_dest);
res = 0;
res |= rpc_register(s->rpc_s, APPEND_ENTRIES_RPC, handle_append_entries, s);
res |= rpc_register(s->rpc_s, REQUEST_VOTE_RPC, handle_request_vote, s);
if(res) {
//LOG:FATAL method registration failed
deinit_raft_server(s);
return NULL;
}
s->current_leader = -1;
return s;
}
int main(int argc, char *argv[])
{
init_rpc(argv[1]);
cl_platform_id platform;
cl_device_id device;
cl_context context;
cl_command_queue queue;
cl_program program;
cl_kernel kernel;
cl_mem d_input_r;
cl_mem d_input_i;
int length = 1024;
size_t buf_size = length * sizeof(float);
float *input_r, *input_i, *output_r, *output_i;
posix_memalign((void **)&input_r, 16, buf_size);
posix_memalign((void **)&input_i, 16, buf_size);
posix_memalign((void **)&output_r, 16, buf_size);
posix_memalign((void **)&output_i, 16, buf_size);
fill_rand(input_r, length, 0, 255);
fill_rand(input_i, length, 0, 0);
memcpy(output_r, input_r, buf_size);
memcpy(output_i, input_i, buf_size);
size_t local_work_size[1];
size_t global_work_size[1];
local_work_size[0] = 64;
global_work_size[0] = 64;
const char *source = load_program_source("FFT.cl");
size_t source_len = strlen(source);;
cl_uint err = 0;
char *flags = "-x clc++";
clGetPlatformIDs(1, &platform, NULL);
printf("platform %p err %d\n", platform, err);
clGetDeviceIDs(platform, CL_DEVICE_TYPE_CPU, 1, &device, &err);
printf("device %p err %d\n", device, err);
context = clCreateContext(0, 1, &device, NULL, NULL, &err);
printf("context %p err %d\n", context, err);
queue = clCreateCommandQueue(context, device, 0, &err);
printf("queue %p err %d\n", queue, err);
program = clCreateProgramWithSource(context, 1, &source, &source_len, &err);
printf("program %p err %d\n", program, err);
err = clBuildProgram(program, 0, NULL, flags, NULL, NULL);
printf("err %d\n", err);
kernel = clCreateKernel(program, "kfft", NULL);
printf("kernel %p\n", kernel);
d_input_r = clCreateBuffer(context, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR,
buf_size, input_r, &err);
printf("d_input_r %p err %d\n", d_input_r, err);
d_input_i = clCreateBuffer(context, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR,
buf_size, input_i, &err);
printf("d_input_i %p err %d\n", d_input_i, err);
err = clSetKernelArg(kernel, 0, sizeof(cl_mem), (void*)&d_input_r);
printf("err %d\n", err);
err = clSetKernelArg(kernel, 1, sizeof(cl_mem), (void*)&d_input_i);
printf("err %d\n", err);
err = clEnqueueNDRangeKernel(queue, kernel, 1, NULL, global_work_size,
local_work_size, 0, NULL, NULL);
printf("err %d\n", err);
clFinish(queue);
err = clEnqueueReadBuffer(queue, d_input_r, CL_TRUE, 0, buf_size, output_r,
0, NULL, NULL);
printf("err %d\n", err);
err = clEnqueueReadBuffer(queue, d_input_i, CL_TRUE, 0, buf_size, output_i,
0, NULL, NULL);
printf("err %d\n", err);
int i;
for (i = 0; i < length; i++) {
printf("%i %f %f\n", i, output_r[i], output_i[i]);
}
clReleaseMemObject(d_input_r);
clReleaseMemObject(d_input_i);
clReleaseProgram(program);
clReleaseKernel(kernel);
clReleaseCommandQueue(queue);
}
int main(int argc, char * argv[])
{
init_rpc(argv[1]);
cl_platform_id platform;
cl_device_id device;
cl_context context;
cl_command_queue queue;
cl_program program;
cl_kernel kernel;
cl_mem d_in_pos, d_in_vel, d_out_pos, d_out_vel;
int iterations = 100;
int num_bodies = 1024;
float espSqr = 500.0f;
float delT = 0.005f;
int exchange = 1;
size_t buf_size = 4 * num_bodies * sizeof(float);
float *ref_pos = (float *)malloc(buf_size);
float *ref_vel = (float *)malloc(buf_size);
int i, j;
for (i = 0; i < num_bodies; i++) {
int index = 4 * i;
for (j = 0; j < 3; ++j) {
ref_pos[index + j] = frandom(3, 50);
}
ref_pos[index + 3] = frandom(1, 1000);
for (j = 0; j < 3; ++j) {
ref_vel[index + j] = 0.0f;
}
ref_vel[3] = 0.0f;
}
size_t local_work_size[1];
size_t global_work_size[1];
local_work_size[0] = 256;
global_work_size[0] = num_bodies;
const char *source = load_program_source("NBody.cl");
size_t source_len = strlen(source);;
cl_uint err = 0;
char *flags = "";
clGetPlatformIDs(1, &platform, NULL);
printf("platform %p err %d\n", platform, err);
clGetDeviceIDs(platform, CL_DEVICE_TYPE_CPU, 1, &device, &err);
printf("device %p err %d\n", device, err);
context = clCreateContext(0, 1, &device, NULL, NULL, &err);
printf("context %p err %d\n", context, err);
queue = clCreateCommandQueue(context, device, 0, &err);
printf("queue %p err %d\n", queue, err);
program = clCreateProgramWithSource(context, 1, &source, &source_len, &err);
printf("program %p err %d\n", program, err);
err = clBuildProgram(program, 0, NULL, flags, NULL, NULL);
printf("err %d\n", err);
kernel = clCreateKernel(program, "nbody_sim", NULL);
printf("kernel %p\n", kernel);
d_in_pos = clCreateBuffer(context, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR,
buf_size, ref_pos, &err);
printf("d_in_pos %p err %d\n", d_in_pos, err);
d_in_vel = clCreateBuffer(context, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR,
buf_size, ref_vel, &err);
printf("d_in_vel %p err %d\n", d_in_vel, err);
d_out_pos = clCreateBuffer(context, CL_MEM_READ_WRITE,
buf_size, NULL, &err);
printf("d_out_pos %p err %d\n", d_out_pos, err);
d_out_vel = clCreateBuffer(context, CL_MEM_READ_WRITE,
buf_size, NULL, &err);
printf("d_out_vel %p err %d\n", d_out_vel, err);
err = clSetKernelArg(kernel, 0, sizeof(cl_mem), (void*)&d_in_pos);
printf("err %d\n", err);
err = clSetKernelArg(kernel, 1, sizeof(cl_mem), (void*)&d_in_vel);
printf("err %d\n", err);
err = clSetKernelArg(kernel, 2, sizeof(int), (void*)&num_bodies);
printf("err %d\n", err);
err = clSetKernelArg(kernel, 3, sizeof(float), (void*)&delT);
printf("err %d\n", err);
err = clSetKernelArg(kernel, 4, sizeof(float), (void*)&espSqr);
printf("err %d\n", err);
err = clSetKernelArg(kernel, 5, 256 * 4 * sizeof(float), NULL);
printf("err %d\n", err);
err = clSetKernelArg(kernel, 6, sizeof(cl_mem), (void*)&d_out_pos);
printf("err %d\n", err);
err = clSetKernelArg(kernel, 7, sizeof(cl_mem), (void*)&d_out_vel);
printf("err %d\n", err);
for (i = 0; i < iterations; i++) {
err = clEnqueueNDRangeKernel(queue, kernel, 1, NULL, global_work_size,
local_work_size, 0, NULL, NULL);
printf("err %d\n", err);
clFinish(queue);
err = clSetKernelArg(kernel, exchange ? 6 : 0, sizeof(cl_mem),
(void*)&d_in_pos);
printf("err %d\n", err);
err = clSetKernelArg(kernel, exchange ? 7 : 1, sizeof(cl_mem),
(void*)&d_in_vel);
printf("err %d\n", err);
err = clSetKernelArg(kernel, exchange ? 0 : 6, sizeof(cl_mem),
(void*)&d_out_pos);
printf("err %d\n", err);
err = clSetKernelArg(kernel, exchange ? 1 : 7, sizeof(cl_mem),
(void*)&d_out_vel);
printf("err %d\n", err);
exchange = exchange ? 0 : 1;
}
err = clEnqueueReadBuffer(queue, d_out_pos, CL_TRUE, 0, buf_size, ref_pos,
0, NULL, NULL);
printf("err %d\n", err);
err = clEnqueueReadBuffer(queue, d_out_vel, CL_TRUE, 0, buf_size, ref_vel,
0, NULL, NULL);
printf("err %d\n", err);
for (i = 0; i < num_bodies ; i++) {
printf("%i %f %f\n", i, ref_pos[i], ref_vel[i]);
}
clReleaseMemObject(d_in_pos);
clReleaseMemObject(d_in_vel);
clReleaseMemObject(d_out_pos);
clReleaseMemObject(d_out_vel);
clReleaseProgram(program);
clReleaseKernel(kernel);
clReleaseCommandQueue(queue);
}
int main(int argc, char *argv[])
{
init_rpc(argv[1]);
cl_platform_id platform;
cl_device_id device;
cl_context context;
cl_command_queue queue;
cl_program program;
cl_kernel kernel;
cl_mem buffer;
size_t i;
int scale = 8; // scale should be higher than 8
size_t array_size = powl(2, scale) * 4;
cl_int *input = (cl_int *) malloc(sizeof(cl_int) * array_size);
cl_int *output = (cl_int *) malloc(sizeof(cl_int) * array_size);
cl_int dir = 1;
cl_int no_stages = 0;
cl_int temp;
generateInput(input, array_size);
//ExecuteSortReference(input, array_size, dir);
for (temp = array_size; temp > 2; temp >>= 1) {
no_stages++;
}
size_t local_work_size[1];
size_t global_work_size[1];
const char *source = load_program_source("BitonicSort.cl");
size_t source_len = strlen(source);;
cl_uint err = 0;
char *flags = "-cl-fast-relaxed-math";
clGetPlatformIDs(1, &platform, NULL);
printf("platform %p err %d\n", platform, err);
clGetDeviceIDs(platform, CL_DEVICE_TYPE_CPU, 1, &device, &err);
printf("device %p err %d\n", device, err);
context = clCreateContext(0, 1, &device, NULL, NULL, &err);
printf("context %p err %d\n", context, err);
queue = clCreateCommandQueue(context, device, 0, &err);
printf("queue %p err %d\n", queue, err);
program = clCreateProgramWithSource(context, 1, &source, &source_len, &err);
printf("program %p err %d\n", program, err);
err = clBuildProgram(program, 0, NULL, flags, NULL, NULL);
printf("err %d\n", err);
kernel = clCreateKernel(program, "BitonicSort", NULL);
printf("kernel %p\n", kernel);
buffer = clCreateBuffer(context, CL_MEM_COPY_HOST_PTR,
sizeof(cl_int) * array_size, input, &err);
printf("buffer %p err %d\n", buffer, err);
err = clSetKernelArg(kernel, 0, sizeof(cl_mem), (void*)&buffer);
printf("err %d\n", err);
err = clSetKernelArg(kernel, 3, sizeof(cl_int), (void*)&dir);
printf("err %d\n", err);
cl_int stage, pass_stage;
for (stage = 0; stage < no_stages; stage++) {
err = clSetKernelArg(kernel, 1, sizeof(cl_int), (void*)&stage);
printf("err %d\n", err);
for (pass_stage = stage; pass_stage >= 0; pass_stage--) {
err = clSetKernelArg(kernel, 2, sizeof(cl_int),
(void*)&pass_stage);
printf("err %d\n", err);
size_t gsz = array_size/(2*4);
global_work_size[0] = pass_stage ? gsz : gsz << 1;
local_work_size[0] = 128;
err = clEnqueueNDRangeKernel(queue, kernel, 1, NULL, global_work_size,
local_work_size, 0, NULL, NULL);
printf("err %d\n", err);
}
}
clFinish(queue);
err = clEnqueueReadBuffer(queue, buffer, CL_TRUE, 0,
sizeof(cl_int) * array_size, output, 0, NULL, NULL);
printf("err %d\n", err);
for (i = 0; i < array_size; i++) {
printf("%i %i\n", i, output[i]);
}
clReleaseMemObject(buffer);
clReleaseProgram(program);
clReleaseKernel(kernel);
clReleaseCommandQueue(queue);
}
