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); }