int main(int argc, char const *argv[]) { /* Get platform */ cl_platform_id platform; cl_uint num_platforms; cl_int ret = clGetPlatformIDs(1, &platform, &num_platforms); if (ret != CL_SUCCESS) { printf("error: call to 'clGetPlatformIDs' failed\n"); exit(1); } printf("Number of platforms: %d\n", num_platforms); printf("platform=%p\n", platform); /* Get platform name */ char platform_name[100]; ret = clGetPlatformInfo(platform, CL_PLATFORM_NAME, sizeof(platform_name), platform_name, NULL); if (ret != CL_SUCCESS) { printf("error: call to 'clGetPlatformInfo' failed\n"); exit(1); } printf("platform.name='%s'\n\n", platform_name); /* Get device */ cl_device_id device; cl_uint num_devices; ret = clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, 1, &device, &num_devices); if (ret != CL_SUCCESS) { printf("error: call to 'clGetDeviceIDs' failed\n"); exit(1); } printf("Number of devices: %d\n", num_devices); printf("device=%p\n", device); /* Get device name */ char device_name[100]; ret = clGetDeviceInfo(device, CL_DEVICE_NAME, sizeof(device_name), device_name, NULL); if (ret != CL_SUCCESS) { printf("error: call to 'clGetDeviceInfo' failed\n"); exit(1); } printf("device.name='%s'\n", device_name); printf("\n"); /* Create a Context Object */ cl_context context; context = clCreateContext(NULL, 1, &device, NULL, NULL, &ret); if (ret != CL_SUCCESS) { printf("error: call to 'clCreateContext' failed\n"); exit(1); } printf("context=%p\n", context); /* Create a Command Queue Object*/ cl_command_queue command_queue; command_queue = clCreateCommandQueue(context, device, 0, &ret); if (ret != CL_SUCCESS) { printf("error: call to 'clCreateCommandQueue' failed\n"); exit(1); } printf("command_queue=%p\n", command_queue); printf("\n"); /* Program source */ unsigned char *source_code; size_t source_length; /* Read program from 'relational_greater_than_uchar4uchar4.cl' */ source_code = read_buffer("relational_greater_than_uchar4uchar4.cl", &source_length); /* Create a program */ cl_program program; program = clCreateProgramWithSource(context, 1, (const char **)&source_code, &source_length, &ret); if (ret != CL_SUCCESS) { printf("error: call to 'clCreateProgramWithSource' failed\n"); exit(1); } printf("program=%p\n", program); /* Build program */ ret = clBuildProgram(program, 1, &device, NULL, NULL, NULL); if (ret != CL_SUCCESS ) { size_t size; char *log; /* Get log size */ clGetProgramBuildInfo(program, device, CL_PROGRAM_BUILD_LOG,0, NULL, &size); /* Allocate log and print */ log = malloc(size); clGetProgramBuildInfo(program, device, CL_PROGRAM_BUILD_LOG,size, log, NULL); printf("error: call to 'clBuildProgram' failed:\n%s\n", log); /* Free log and exit */ free(log); exit(1); } printf("program built\n"); printf("\n"); /* Create a Kernel Object */ cl_kernel kernel; kernel = clCreateKernel(program, "relational_greater_than_uchar4uchar4", &ret); if (ret != CL_SUCCESS) { printf("error: call to 'clCreateKernel' failed\n"); exit(1); } /* Create and allocate host buffers */ size_t num_elem = 10; /* Create and init host side src buffer 0 */ cl_uchar4 *src_0_host_buffer; src_0_host_buffer = malloc(num_elem * sizeof(cl_uchar4)); for (int i = 0; i < num_elem; i++) src_0_host_buffer[i] = (cl_uchar4){{2, 2, 2, 2}}; /* Create and init device side src buffer 0 */ cl_mem src_0_device_buffer; src_0_device_buffer = clCreateBuffer(context, CL_MEM_READ_ONLY, num_elem * sizeof(cl_uchar4), NULL, &ret); if (ret != CL_SUCCESS) { printf("error: could not create source buffer\n"); exit(1); } ret = clEnqueueWriteBuffer(command_queue, src_0_device_buffer, CL_TRUE, 0, num_elem * sizeof(cl_uchar4), src_0_host_buffer, 0, NULL, NULL); if (ret != CL_SUCCESS) { printf("error: call to 'clEnqueueWriteBuffer' failed\n"); exit(1); } /* Create and init host side src buffer 1 */ cl_uchar4 *src_1_host_buffer; src_1_host_buffer = malloc(num_elem * sizeof(cl_uchar4)); for (int i = 0; i < num_elem; i++) src_1_host_buffer[i] = (cl_uchar4){{2, 2, 2, 2}}; /* Create and init device side src buffer 1 */ cl_mem src_1_device_buffer; src_1_device_buffer = clCreateBuffer(context, CL_MEM_READ_ONLY, num_elem * sizeof(cl_uchar4), NULL, &ret); if (ret != CL_SUCCESS) { printf("error: could not create source buffer\n"); exit(1); } ret = clEnqueueWriteBuffer(command_queue, src_1_device_buffer, CL_TRUE, 0, num_elem * sizeof(cl_uchar4), src_1_host_buffer, 0, NULL, NULL); if (ret != CL_SUCCESS) { printf("error: call to 'clEnqueueWriteBuffer' failed\n"); exit(1); } /* Create host dst buffer */ cl_int4 *dst_host_buffer; dst_host_buffer = malloc(num_elem * sizeof(cl_int4)); memset((void *)dst_host_buffer, 1, num_elem * sizeof(cl_int4)); /* Create device dst buffer */ cl_mem dst_device_buffer; dst_device_buffer = clCreateBuffer(context, CL_MEM_WRITE_ONLY, num_elem *sizeof(cl_int4), NULL, &ret); if (ret != CL_SUCCESS) { printf("error: could not create dst buffer\n"); exit(1); } /* Set kernel arguments */ ret = CL_SUCCESS; ret |= clSetKernelArg(kernel, 0, sizeof(cl_mem), &src_0_device_buffer); ret |= clSetKernelArg(kernel, 1, sizeof(cl_mem), &src_1_device_buffer); ret |= clSetKernelArg(kernel, 2, sizeof(cl_mem), &dst_device_buffer); if (ret != CL_SUCCESS) { printf("error: call to 'clSetKernelArg' failed\n"); exit(1); } /* Launch the kernel */ size_t global_work_size = num_elem; size_t local_work_size = num_elem; ret = clEnqueueNDRangeKernel(command_queue, kernel, 1, NULL, &global_work_size, &local_work_size, 0, NULL, NULL); if (ret != CL_SUCCESS) { printf("error: call to 'clEnqueueNDRangeKernel' failed\n"); exit(1); } /* Wait for it to finish */ clFinish(command_queue); /* Read results from GPU */ ret = clEnqueueReadBuffer(command_queue, dst_device_buffer, CL_TRUE,0, num_elem * sizeof(cl_int4), dst_host_buffer, 0, NULL, NULL); if (ret != CL_SUCCESS) { printf("error: call to 'clEnqueueReadBuffer' failed\n"); exit(1); } /* Dump dst buffer to file */ char dump_file[100]; sprintf((char *)&dump_file, "%s.result", argv[0]); write_buffer(dump_file, (const char *)dst_host_buffer, num_elem * sizeof(cl_int4)); printf("Result dumped to %s\n", dump_file); /* Free host dst buffer */ free(dst_host_buffer); /* Free device dst buffer */ ret = clReleaseMemObject(dst_device_buffer); if (ret != CL_SUCCESS) { printf("error: call to 'clReleaseMemObject' failed\n"); exit(1); } /* Free host side src buffer 0 */ free(src_0_host_buffer); /* Free device side src buffer 0 */ ret = clReleaseMemObject(src_0_device_buffer); if (ret != CL_SUCCESS) { printf("error: call to 'clReleaseMemObject' failed\n"); exit(1); } /* Free host side src buffer 1 */ free(src_1_host_buffer); /* Free device side src buffer 1 */ ret = clReleaseMemObject(src_1_device_buffer); if (ret != CL_SUCCESS) { printf("error: call to 'clReleaseMemObject' failed\n"); exit(1); } /* Release kernel */ ret = clReleaseKernel(kernel); if (ret != CL_SUCCESS) { printf("error: call to 'clReleaseKernel' failed\n"); exit(1); } /* Release program */ ret = clReleaseProgram(program); if (ret != CL_SUCCESS) { printf("error: call to 'clReleaseProgram' failed\n"); exit(1); } /* Release command queue */ ret = clReleaseCommandQueue(command_queue); if (ret != CL_SUCCESS) { printf("error: call to 'clReleaseCommandQueue' failed\n"); exit(1); } /* Release context */ ret = clReleaseContext(context); if (ret != CL_SUCCESS) { printf("error: call to 'clReleaseContext' failed\n"); exit(1); } return 0; }
void run_Pitch(LV2_Handle Instance, uint32_t SampleCount) { Pitch * ptr = (Pitch *)Instance; float * input = ptr->input; float * output = ptr->output; float drylevel = db2lin(LIMIT(*(ptr->drylevel),-90.0f,20.0f)); float wetlevel = 0.333333f * db2lin(LIMIT(*(ptr->wetlevel),-90.0f,20.0f)); float buflen = ptr->buflen / 2.0f; float semitone = LIMIT(*(ptr->semitone),-12.0f,12.0f); float rate; float r; float depth; unsigned long sample_index; unsigned long sample_count = SampleCount; float in = 0.0f; float sign = 1.0f; float phase_0 = 0.0f; float phase_am_0 = 0.0f; float phase_1 = 0.0f; float phase_am_1 = 0.0f; float phase_2 = 0.0f; float phase_am_2 = 0.0f; float fpos_0 = 0.0f, fpos_1 = 0.0f, fpos_2 = 0.0f; float n_0 = 0.0f, n_1 = 0.0f, n_2 = 0.0f; float rem_0 = 0.0f, rem_1 = 0.0f, rem_2 = 0.0f; float sa_0, sb_0, sa_1, sb_1, sa_2, sb_2; if (semitone == 0.0f) rate = LIMIT(*(ptr->rate),-50.0f,100.0f); else rate = 100.0f * (powf(ROOT_12_2,semitone) - 1.0f); r = -1.0f * ABS(rate); depth = buflen * LIMIT(ABS(r) / 100.0f, 0.0f, 1.0f); if (rate > 0.0f) sign = -1.0f; for (sample_index = 0; sample_index < sample_count; sample_index++) { in = *(input++); phase_0 = COS_TABLE_SIZE * PM_FREQ * sample_index / ptr->sample_rate + ptr->phase; while (phase_0 >= COS_TABLE_SIZE) phase_0 -= COS_TABLE_SIZE; phase_am_0 = phase_0 + COS_TABLE_SIZE/2; while (phase_am_0 >= COS_TABLE_SIZE) phase_am_0 -= COS_TABLE_SIZE; phase_1 = phase_0 + COS_TABLE_SIZE/3.0f; while (phase_1 >= COS_TABLE_SIZE) phase_1 -= COS_TABLE_SIZE; phase_am_1 = phase_1 + COS_TABLE_SIZE/2; while (phase_am_1 >= COS_TABLE_SIZE) phase_am_1 -= COS_TABLE_SIZE; phase_2 = phase_0 + 2.0f*COS_TABLE_SIZE/3.0f; while (phase_2 >= COS_TABLE_SIZE) phase_2 -= COS_TABLE_SIZE; phase_am_2 = phase_2 + COS_TABLE_SIZE/2; while (phase_am_2 >= COS_TABLE_SIZE) phase_am_2 -= COS_TABLE_SIZE; push_buffer(in, ptr->ringbuffer, ptr->buflen, &(ptr->pos)); fpos_0 = depth * (1.0f - sign * (2.0f * phase_0 / COS_TABLE_SIZE - 1.0f)); n_0 = floorf(fpos_0); rem_0 = fpos_0 - n_0; fpos_1 = depth * (1.0f - sign * (2.0f * phase_1 / COS_TABLE_SIZE - 1.0f)); n_1 = floorf(fpos_1); rem_1 = fpos_1 - n_1; fpos_2 = depth * (1.0f - sign * (2.0f * phase_2 / COS_TABLE_SIZE - 1.0f)); n_2 = floorf(fpos_2); rem_2 = fpos_2 - n_2; sa_0 = read_buffer(ptr->ringbuffer, ptr->buflen, ptr->pos, (unsigned long) n_0); sb_0 = read_buffer(ptr->ringbuffer, ptr->buflen, ptr->pos, (unsigned long) n_0 + 1); sa_1 = read_buffer(ptr->ringbuffer, ptr->buflen, ptr->pos, (unsigned long) n_1); sb_1 = read_buffer(ptr->ringbuffer, ptr->buflen, ptr->pos, (unsigned long) n_1 + 1); sa_2 = read_buffer(ptr->ringbuffer, ptr->buflen, ptr->pos, (unsigned long) n_2); sb_2 = read_buffer(ptr->ringbuffer, ptr->buflen, ptr->pos, (unsigned long) n_2 + 1); *(output++) = wetlevel * ((1.0f + cos_table[(unsigned long) phase_am_0]) * ((1 - rem_0) * sa_0 + rem_0 * sb_0) + (1.0f + cos_table[(unsigned long) phase_am_1]) * ((1 - rem_1) * sa_1 + rem_1 * sb_1) + (1.0f + cos_table[(unsigned long) phase_am_2]) * ((1 - rem_2) * sa_2 + rem_2 * sb_2)) + drylevel * read_buffer(ptr->ringbuffer, ptr->buflen, ptr->pos, (unsigned long) depth); } ptr->phase += COS_TABLE_SIZE * PM_FREQ * sample_index / ptr->sample_rate; while (ptr->phase >= COS_TABLE_SIZE) ptr->phase -= COS_TABLE_SIZE; *(ptr->latency) = buflen - (unsigned long) depth; }
/* Fetch the next certificate. Return 0 on success, GPG_ERR_EOF if no (more) certificates are available or any other error code. GPG_ERR_TRUNCATED may be returned to indicate that the result has been truncated. */ gpg_error_t fetch_next_cert_ldap (cert_fetch_context_t context, unsigned char **value, size_t *valuelen) { gpg_error_t err; unsigned char hdr[5]; char *p, *pend; unsigned long n; int okay = 0; /* int is_cms = 0; */ *value = NULL; *valuelen = 0; err = 0; while (!err) { err = read_buffer (context->reader, hdr, 5); if (err) break; n = buf32_to_ulong (hdr+1); if (*hdr == 'V' && okay) { #if 0 /* That code is not yet ready. */ if (is_cms) { /* The certificate needs to be parsed from CMS data. */ ksba_cms_t cms; ksba_stop_reason_t stopreason; int i; err = ksba_cms_new (&cms); if (err) goto leave; err = ksba_cms_set_reader_writer (cms, context->reader, NULL); if (err) { log_error ("ksba_cms_set_reader_writer failed: %s\n", gpg_strerror (err)); goto leave; } do { err = ksba_cms_parse (cms, &stopreason); if (err) { log_error ("ksba_cms_parse failed: %s\n", gpg_strerror (err)); goto leave; } if (stopreason == KSBA_SR_BEGIN_DATA) log_error ("userSMIMECertificate is not " "a certs-only message\n"); } while (stopreason != KSBA_SR_READY); for (i=0; (cert=ksba_cms_get_cert (cms, i)); i++) { check_and_store (ctrl, stats, cert, 0); ksba_cert_release (cert); cert = NULL; } if (!i) log_error ("no certificate found\n"); else any = 1; } else #endif { *value = xtrymalloc (n); if (!*value) return gpg_error_from_errno (errno); *valuelen = n; err = read_buffer (context->reader, *value, n); break; /* Ready or error. */ } } else if (!n && *hdr == 'A') okay = 0; else if (n) { if (n > context->tmpbufsize) { xfree (context->tmpbuf); context->tmpbufsize = 0; context->tmpbuf = xtrymalloc (n+1); if (!context->tmpbuf) return gpg_error_from_errno (errno); context->tmpbufsize = n; } err = read_buffer (context->reader, context->tmpbuf, n); if (err) break; if (*hdr == 'A') { p = context->tmpbuf; p[n] = 0; /*(we allocated one extra byte for this.)*/ /* fixme: is_cms = 0; */ if ( (pend = strchr (p, ';')) ) *pend = 0; /* Strip off the extension. */ if (!ascii_strcasecmp (p, USERCERTIFICATE)) { if (DBG_LOOKUP) log_debug ("fetch_next_cert_ldap: got attribute '%s'\n", USERCERTIFICATE); okay = 1; } else if (!ascii_strcasecmp (p, CACERTIFICATE)) { if (DBG_LOOKUP) log_debug ("fetch_next_cert_ldap: got attribute '%s'\n", CACERTIFICATE); okay = 1; } else if (!ascii_strcasecmp (p, X509CACERT)) { if (DBG_LOOKUP) log_debug ("fetch_next_cert_ldap: got attribute '%s'\n", CACERTIFICATE); okay = 1; } /* else if (!ascii_strcasecmp (p, USERSMIMECERTIFICATE)) */ /* { */ /* if (DBG_LOOKUP) */ /* log_debug ("fetch_next_cert_ldap: got attribute '%s'\n", */ /* USERSMIMECERTIFICATE); */ /* okay = 1; */ /* is_cms = 1; */ /* } */ else { if (DBG_LOOKUP) log_debug ("fetch_next_cert_ldap: got attribute '%s'" " - ignored\n", p); okay = 0; } } else if (*hdr == 'E') { p = context->tmpbuf; p[n] = 0; /*(we allocated one extra byte for this.)*/ if (!strcmp (p, "truncated")) { context->truncated = 1; log_info (_("ldap_search hit the size limit of" " the server\n")); } } } } if (err) { xfree (*value); *value = NULL; *valuelen = 0; if (gpg_err_code (err) == GPG_ERR_EOF && context->truncated) { context->truncated = 0; /* So that the next call would return EOF. */ err = gpg_error (GPG_ERR_TRUNCATED); } } return err; }
static glui32 read_stackstate(dest_t *dest, glui32 chunklen, int portable) { glui32 res; glui32 frameend, frm, frm2, frm3, locpos, frlen, numlocals; if (chunklen > stacksize) return 1; stackptr = chunklen; frameptr = 0; valstackbase = 0; localsbase = 0; if (!portable) { res = read_buffer(dest, stack, stackptr); if (res) return res; return 0; } /* This isn't going to be pleasant; we're going to read the data in as a block, and then convert it in-place. */ res = read_buffer(dest, stack, stackptr); if (res) return res; frameend = stackptr; while (frameend != 0) { /* Read the beginning-of-frame pointer. Remember, right now, the whole frame is stored big-endian. So we have to read with the Read*() macros, and then write with the StkW*() macros. */ frm = Read4(stack+(frameend-4)); frm2 = frm; frlen = Read4(stack+frm2); StkW4(frm2, frlen); frm2 += 4; locpos = Read4(stack+frm2); StkW4(frm2, locpos); frm2 += 4; /* The locals-format list is in bytes, so we don't have to convert it. */ frm3 = frm2; frm2 = frm+locpos; numlocals = 0; while (1) { unsigned char loctype, loccount; loctype = Read1(stack+frm3); frm3 += 1; loccount = Read1(stack+frm3); frm3 += 1; if (loctype == 0 && loccount == 0) break; /* Skip up to 0, 1, or 3 bytes of padding, depending on loctype. */ while (frm2 & (loctype-1)) { StkW1(frm2, 0); frm2++; } /* Convert this set of locals. */ switch (loctype) { case 1: do { /* Don't need to convert bytes. */ frm2 += 1; loccount--; } while (loccount); break; case 2: do { glui16 loc = Read2(stack+frm2); StkW2(frm2, loc); frm2 += 2; loccount--; } while (loccount); break; case 4: do { glui32 loc = Read4(stack+frm2); StkW4(frm2, loc); frm2 += 4; loccount--; } while (loccount); break; } numlocals++; } if ((numlocals & 1) == 0) { StkW1(frm3, 0); frm3++; StkW1(frm3, 0); frm3++; } if (frm3 != frm+locpos) { return 1; } while (frm2 & 3) { StkW1(frm2, 0); frm2++; } if (frm2 != frm+frlen) { return 1; } /* Now, the values pushed on the stack after the call frame itself. This includes the stub. */ while (frm2 < frameend) { glui32 loc = Read4(stack+frm2); StkW4(frm2, loc); frm2 += 4; } frameend = frm; } return 0; }
int Dump_Restore::populate (Dump_Restore::Operation_Type op) { if (this->infile_) { int result = -1; enum State { NAME, VALUE, TYPE }; State state = NAME; // reset file pointer ACE_OS::rewind (this->infile_); ACE_Allocator *allocator = ACE_Allocator::instance (); ACE_Read_Buffer read_buffer (this->infile_, 0, allocator); for (char *temp; (temp = read_buffer.read ('\n')) != 0; ) { char *name = 0; const char *actual_name = 0; char *value = 0; const char *actual_value = 0; char *type = 0; const char *actual_type = 0; switch (state) { case NAME: name = temp; ACE_OS::strtok (name, "="); actual_name = ACE_OS::strtok (0, "="); state = VALUE; break; case VALUE: value = temp; ACE_OS::strtok (value, "="); actual_value = ACE_OS::strtok (0, "="); state = TYPE; break; case TYPE: type = temp; ACE_OS::strtok (type, "="); actual_type = ACE_OS::strtok (0, "="); if (actual_type) result = this->doit (op, actual_name, actual_value, actual_type); else result = this->doit (op, actual_name, actual_value); if (name) allocator->free(name); if (value) allocator->free(value); if (type) allocator->free(type); state = NAME; break; default: ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("populate")), -1); /* NOTREACHED */ } } return result; } else return -1; }
static int read_byte(dest_t *dest, unsigned char *val) { return read_buffer(dest, val, 1); }
// This is called both during init and at runtime. static int resize_cache(struct priv *s, int64_t size) { int64_t min_size = FILL_LIMIT * 4; int64_t max_size = ((size_t)-1) / 4; int64_t buffer_size = MPMIN(MPMAX(size, min_size), max_size); unsigned char *buffer = malloc(buffer_size); struct byte_meta *bm = calloc(buffer_size / BYTE_META_CHUNK_SIZE + 2, sizeof(struct byte_meta)); if (!buffer || !bm) { free(buffer); free(bm); return STREAM_ERROR; } if (s->buffer) { // Copy & free the old ringbuffer data. // If the buffer is too small, prefer to copy these regions: // 1. Data starting from read_filepos, until cache end size_t read_1 = read_buffer(s, buffer, buffer_size, s->read_filepos); // 2. then data from before read_filepos until cache start // (this one needs to be copied to the end of the ringbuffer) size_t read_2 = 0; if (s->min_filepos < s->read_filepos) { size_t copy_len = buffer_size - read_1; copy_len = MPMIN(copy_len, s->read_filepos - s->min_filepos); assert(copy_len + read_1 <= buffer_size); read_2 = read_buffer(s, buffer + buffer_size - copy_len, copy_len, s->read_filepos - copy_len); // This shouldn't happen, unless copy_len was computed incorrectly. assert(read_2 == copy_len); } // Set it up such that read_1 is at buffer pos 0, and read_2 wraps // around below it, so that it is located at the end of the buffer. s->min_filepos = s->read_filepos - read_2; s->max_filepos = s->read_filepos + read_1; s->offset = s->max_filepos - read_1; } else { cache_drop_contents(s); } free(s->buffer); free(s->bm); s->buffer_size = buffer_size; s->back_size = buffer_size / 2; s->buffer = buffer; s->bm = bm; s->idle = false; s->eof = false; //make sure that we won't wait from cache_fill //more data than it is allowed to fill if (s->seek_limit > s->buffer_size - FILL_LIMIT) s->seek_limit = s->buffer_size - FILL_LIMIT; for (size_t n = 0; n < s->buffer_size / BYTE_META_CHUNK_SIZE + 2; n++) s->bm[n] = (struct byte_meta){.stream_pts = MP_NOPTS_VALUE}; return STREAM_OK; }
int main(int argc, char **argv) { cl_int ret; /* * Command line */ char *binary_path; if (argc != 2) { printf("syntax: %s <binary>\n", argv[0]); exit(1); } binary_path = argv[1]; /* * Platform */ /* Get platform */ cl_platform_id platform; cl_uint num_platforms; ret = clGetPlatformIDs(1, &platform, &num_platforms); if (ret != CL_SUCCESS) { printf("error: second call to 'clGetPlatformIDs' failed\n"); exit(1); } printf("Number of platforms: %d\n", num_platforms); /* Get platform name */ char platform_name[100]; ret = clGetPlatformInfo(platform, CL_PLATFORM_NAME, sizeof(platform_name), platform_name, NULL); if (ret != CL_SUCCESS) { printf("error: call to 'clGetPlatformInfo' failed\n"); exit(1); } printf("platform.name='%s'\n", platform_name); printf("\n"); /* * Device */ /* Get device */ cl_device_id device; cl_uint num_devices; ret = clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, 1, &device, &num_devices); if (ret != CL_SUCCESS) { printf("error: call to 'clGetDeviceIDs' failed\n"); exit(1); } printf("Number of devices: %d\n", num_devices); /* Get device name */ char device_name[100]; ret = clGetDeviceInfo(device, CL_DEVICE_NAME, sizeof(device_name), device_name, NULL); if (ret != CL_SUCCESS) { printf("error: call to 'clGetDeviceInfo' failed\n"); exit(1); } printf("device.name='%s'\n", device_name); printf("\n"); /* * Context */ /* Create context */ cl_context context; context = clCreateContext(NULL, 1, &device, NULL, NULL, &ret); if (ret != CL_SUCCESS) { printf("error: call to 'clCreateContext' failed\n"); exit(1); } /* * Command Queue */ /* Create command queue */ cl_command_queue command_queue; command_queue = clCreateCommandQueue(context, device, 0, &ret); if (ret != CL_SUCCESS) { printf("error: call to 'clCreateCommandQueue' failed\n"); exit(1); } printf("\n"); /* * Program */ /* Program binary */ const unsigned char *binary; size_t binary_length; /* Read binary */ binary = read_buffer(binary_path, &binary_length); if (!binary) { printf("error: %s: cannot open binary\n", binary_path); exit(1); } /* Create a program */ cl_program program; program = clCreateProgramWithBinary(context, 1, &device, &binary_length, &binary, NULL, &ret); if (ret != CL_SUCCESS) { printf("error: call to 'clCreateProgramWithSource' failed\n"); exit(1); } /* Build program */ ret = clBuildProgram(program, 1, &device, NULL, NULL, NULL); if (ret != CL_SUCCESS ) { size_t size; char *log; /* Get log size */ clGetProgramBuildInfo(program, device, CL_PROGRAM_BUILD_LOG, 0, NULL, &size); /* Allocate log and print */ log = malloc(size); clGetProgramBuildInfo(program, device, CL_PROGRAM_BUILD_LOG, size, log, NULL); printf("error: call to 'clBuildProgram' failed:\n%s\n", log); /* Free log and exit */ free(log); exit(1); } printf("program built\n"); printf("\n"); /* * Kernel */ /* Create kernel */ cl_kernel kernel; kernel = clCreateKernel(program, "vector_add", &ret); if (ret != CL_SUCCESS) { printf("error: call to 'clCreateKernel' failed\n"); exit(1); } printf("\n"); /* * Buffers */ /* Create and allocate host buffers */ size_t num_elem = 10; cl_int *src1_host_buffer; cl_int *src2_host_buffer; cl_int *dst_host_buffer; src1_host_buffer = malloc(num_elem * sizeof(cl_int)); src2_host_buffer = malloc(num_elem * sizeof(cl_int)); dst_host_buffer = malloc(num_elem * sizeof(cl_int)); /* Initialize host source buffer */ int i; for (i = 0; i < num_elem; i++) { src1_host_buffer[i] = i; src2_host_buffer[i] = 100; } /* Create device source buffers */ cl_mem src1_device_buffer; cl_mem src2_device_buffer; src1_device_buffer = clCreateBuffer(context, CL_MEM_READ_ONLY, num_elem * sizeof(cl_int), NULL, NULL); src2_device_buffer = clCreateBuffer(context, CL_MEM_READ_ONLY, num_elem * sizeof(cl_int), NULL, NULL); if (!src1_device_buffer || !src2_device_buffer) { printf("error: could not create destination buffer\n"); exit(1); } /* Create device destination buffer */ cl_mem dst_device_buffer; dst_device_buffer = clCreateBuffer(context, CL_MEM_WRITE_ONLY, num_elem * sizeof(cl_int), NULL, &ret); if (ret != CL_SUCCESS) { printf("error: could not create destination buffer\n"); exit(1); } /* Copy buffer */ ret = clEnqueueWriteBuffer(command_queue, src1_device_buffer, CL_TRUE, 0, num_elem * sizeof(cl_int), src1_host_buffer, 0, NULL, NULL); ret |= clEnqueueWriteBuffer(command_queue, src2_device_buffer, CL_TRUE, 0, num_elem * sizeof(cl_int), src2_host_buffer, 0, NULL, NULL); if (ret != CL_SUCCESS) { printf("error: call to 'clEnqueueWriteBuffer' failed\n"); exit(1); } /* * Kernel arguments */ ret = clSetKernelArg(kernel, 0, sizeof(cl_mem), &src1_device_buffer); ret |= clSetKernelArg(kernel, 1, sizeof(cl_mem), &src2_device_buffer); ret |= clSetKernelArg(kernel, 2, sizeof(cl_mem), &dst_device_buffer); if (ret != CL_SUCCESS) { printf("error: call to 'clSetKernelArg' failed\n"); exit(1); } /* * Launch Kernel */ size_t global_work_size = num_elem; size_t local_work_size = num_elem; /* Launch the kernel */ ret = clEnqueueNDRangeKernel(command_queue, kernel, 1, NULL, &global_work_size, &local_work_size, 0, NULL, NULL); if (ret != CL_SUCCESS) { printf("error: call to 'clEnqueueNDRangeKernel' failed\n"); exit(1); } /* Wait for it to finish */ clFinish(command_queue); /* * Result */ /* Receive buffer */ ret = clEnqueueReadBuffer(command_queue, dst_device_buffer, CL_TRUE, 0, num_elem * sizeof(cl_int), dst_host_buffer, 0, NULL, NULL); if (ret != CL_SUCCESS) { printf("error: call to 'clEnqueueReadBuffer' failed\n"); exit(1); } /* Print result */ for (i = 0; i < num_elem; i++) printf("dst_host_buffer[%d] = %d\n", i, dst_host_buffer[i]); printf("\n"); return 0; }
static void handle_send(struct connect_s *conn, struct timeval *tv) { httpd_conn *hc = conn->hc; int nwritten; int nread; /* Read until the entire file is sent -- this could take awhile!! */ while (conn->offset < conn->end_offset) { ninfo("offset: %d end_offset: %d bytes_sent: %d\n", conn->offset, conn->end_offset, conn->hc->bytes_sent); /* Fill the rest of the response buffer with file data */ nread = read_buffer(conn); if (nread < 0) { nerr("ERROR: File read error: %d\n", errno); goto errout_clear_connection; } ninfo("Read %d bytes, buflen %d\n", nread, hc->buflen); /* Send the buffer */ if (hc->buflen > 0) { /* httpd_write does not return until all bytes have been sent * (or an error occurs). */ nwritten = httpd_write(hc->conn_fd, hc->buffer, hc->buflen); if (nwritten < 0) { nerr("ERROR: Error sending %s: %d\n", hc->encodedurl, errno); goto errout_clear_connection; } /* We wrote one full buffer of data (httpd_write does not * return until the full buffer is written (or an error occurs). */ conn->active_at = tv->tv_sec; hc->buflen = 0; /* And update how much of the file we wrote */ conn->offset += nwritten; conn->hc->bytes_sent += nwritten; ninfo("Wrote %d bytes\n", nwritten); } } /* The file transfer is complete -- finish the connection */ ninfo("Finish connection\n"); finish_connection(conn, tv); return; errout_clear_connection: ninfo("Clear connection\n"); clear_connection(conn, tv); return; }
ParticlesDataMutable* readPRT(const char* filename,const bool headersOnly,std::ostream* errorStream) { std::auto_ptr<std::istream> input(new std::ifstream(filename,std::ios::in|std::ios::binary)); if (!*input) { if(errorStream) *errorStream<<"Partio: Unable to open file "<<filename<<std::endl; return 0; } // Use simple particle since we don't have optimized storage. ParticlesDataMutable* simple=0; if (headersOnly) simple=new ParticleHeaders; else simple=create(); FileHeadder header; input->read((char*)&header,sizeof(FileHeadder)); if (memcmp(header.magic, magic, sizeof(magic))) { if(errorStream) *errorStream<<"Partio: failed to get PRT magic"<<std::endl; return 0; } // The header may be a different size in other PRT versions if (header.headersize > sizeof(FileHeadder)) input->seekg(header.headersize); int reserve=0; int channels=0; int channelsize=0; read<LITEND>(*input,reserve); // reserved read<LITEND>(*input,channels); // number of channel read<LITEND>(*input,channelsize); // size of channel simple->addParticles((const int)header.numParticles); std::vector<Channel> chans; std::vector<ParticleAttribute> attrs; unsigned particleSize = 0; for (int i=0; i<channels; i++) { Channel ch; input->read((char*)&ch, sizeof(Channel)); ParticleAttributeType type=NONE; switch (ch.type) { case 0: // int16 case 1: // int32 case 2: // int64 type = INT; break; case 3: // float16 case 4: // float32 case 5: // float64 if (ch.arity == 3) type = VECTOR; else type = FLOAT; break; case 6: // uint16 case 7: // uint32 case 8: // uint64 type = INT; break; case 9: // int8 case 10:// uint8 type = INT; break; } if (type != NONE) { #ifdef AUTO_CASES if (ch.name[0] >= 'A' && ch.name[0] <= 'Z') { ch.name[0] += 0x20; } #endif std::string name((char*)ch.name); ParticleAttribute attrHandle=simple->addAttribute(name.c_str(),type,ch.arity); chans.push_back(ch); attrs.push_back(attrHandle); } // The size of the particle is determined from the channel with largest offset. The channels are not required to be listed in order. particleSize = (std::max)( particleSize, chans.back().offset + sizes[ch.type] ); // The channel entry might have more data in other PRT versions. if ((unsigned)channelsize > sizeof(Channel)) input->seekg(channelsize - sizeof(Channel), std::ios::cur); } if (headersOnly) return simple; z_stream z; z.zalloc = Z_NULL;z.zfree = Z_NULL;z.opaque = Z_NULL; if (inflateInit( &z ) != Z_OK) { if(errorStream) *errorStream<<"Zlib inflateInit error"<<std::endl; return 0; } char in_buf[OUT_BUFSIZE]; z.next_in = 0; z.avail_in = 0; char* prt_buf = new char[particleSize]; for (unsigned int particleIndex=0;particleIndex<(unsigned int )simple->numParticles();particleIndex++) { // Read the particle from the file, and decompress it into a single particle-sized buffer. read_buffer(*input, z, (char*)in_buf, prt_buf, particleSize, errorStream); for (unsigned int attrIndex=0;attrIndex<attrs.size();attrIndex++) { if (attrs[attrIndex].type==Partio::INT) { int* data=simple->dataWrite<int>(attrs[attrIndex],particleIndex); for (int count=0;count<attrs[attrIndex].count;count++) { int ival = 0; switch (chans[attrIndex].type) { case 0: // int16 { ival = (int)*reinterpret_cast<short*>( &prt_buf[ chans[attrIndex].offset + count * sizeof(short) ] ); } break; case 1: // int32 { ival = (int)*reinterpret_cast<int*>( &prt_buf[ chans[attrIndex].offset + count * sizeof(int) ] ); } break; case 2: // int64 { ival = (int)*reinterpret_cast<long long*>( &prt_buf[ chans[attrIndex].offset + count * sizeof(long long) ] ); } break; case 6: // uint16 { ival = (int)*reinterpret_cast<unsigned short*>( &prt_buf[ chans[attrIndex].offset + count * sizeof(unsigned short) ] ); } break; case 7: // uint32 { ival = (int)*reinterpret_cast<unsigned int*>( &prt_buf[ chans[attrIndex].offset + + count * sizeof(unsigned int) ] ); } break; case 8: // uint64 { ival = (int)*reinterpret_cast<unsigned long long*>( &prt_buf[ chans[attrIndex].offset + count * sizeof(unsigned long long) ] ); } break; case 9: // int8 { ival = (int)prt_buf[ chans[attrIndex].offset + count ]; } break; case 10:// uint8 { ival = (int)*reinterpret_cast<unsigned char*>( &prt_buf[ chans[attrIndex].offset + count * sizeof(unsigned char) ] ); } break; } data[count]=ival; } }else if (attrs[attrIndex].type==Partio::FLOAT || attrs[attrIndex].type==Partio::VECTOR) { float* data=simple->dataWrite<float>(attrs[attrIndex],particleIndex); for (int count=0;count<attrs[attrIndex].count;count++) { float fval = 0; switch (chans[attrIndex].type) { case 3: // float16 { #ifdef USE_ILMHALF fval = (float)*reinterpret_cast<half*>( &prt_buf[ chans[attrIndex].offset + count * sizeof(half) ] ); #else unsigned short val = *reinterpret_cast<unsigned short*>( &prt_buf[ chans[attrIndex].offset + count * sizeof(unsigned short) ] ); fval = half2float[val].f; #endif } break; case 4: // float32 { fval = (float)*reinterpret_cast<float*>( &prt_buf[ chans[attrIndex].offset + count * sizeof(float) ] ); } break; case 5: // float64 { fval = (float)*reinterpret_cast<double*>( &prt_buf[ chans[attrIndex].offset + count * sizeof(double) ] ); } break; } data[count]=fval; } } } } delete prt_buf; if (inflateEnd( &z ) != Z_OK) { if(errorStream) *errorStream<<"Zlib inflateEnd error"<<std::endl; return 0; } // success return simple; }