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