ccnet_packet *
ccnet_packet_io_read_packet (CcnetPacketIO* io)
{
ccnet_packet *packet;
int len;
buffer_drain (io->in_buf, io->in_buf->off);
if (readn (io->fd, io->in_buf, CCNET_PACKET_LENGTH_HEADER) <= 0)
return NULL;
packet = (ccnet_packet *) BUFFER_DATA(io->in_buf);
len = ntohs (packet->header.length);
if (len > 0) {
if (readn (io->fd, io->in_buf, len) <= 0)
return NULL;
}
/* Note: must reset packet since readn() may cause realloc of buffer */
packet = (ccnet_packet *) BUFFER_DATA(io->in_buf);
packet->header.length = len;
packet->header.id = ntohl (packet->header.id);
return packet;
}
object grow_buffer(object old, long new_capacity) {
long old_capacity = BUFFER_CAPACITY(old);
long old_length = BUFFER_LENGTH(old);
if (old_capacity >= new_capacity) return old;
gc_tmp1 = old;
gc_tmp2 = make_buffer(new_capacity);
memcpy(BUFFER_DATA(gc_tmp2),BUFFER_DATA(gc_tmp1),old_length);
BUFFER_LENGTH(gc_tmp2) = BUFFER_LENGTH(old);
return gc_tmp2;
}
void
ccnet_packet_finish (CcnetPacketIO *io)
{
ccnet_header *header;
header = (ccnet_header *) BUFFER_DATA(io->buffer);
header->length = htons (BUFFER_LENGTH(io->buffer)
- CCNET_PACKET_LENGTH_HEADER);
}
object make_procedure(object opbuffer, object name, long argc) {
long op_size = BUFFER_LENGTH(opbuffer);
object result;
gc_tmp2 = name;
gc_tmp3 = opbuffer;
result = make_heap_object(PROCEDURE_TYPE,
sizeof(struct proc_heap_structure));
PROC_OPS(result) = (long *)allocate_code_space(op_size);
memcpy(PROC_OPS(result),BUFFER_DATA(gc_tmp3),op_size);
PROC_MODULE(result) = gc_tmp2;
PROC_ARGC(result) = argc;
return result;
}
/* return 0 on EOF, -1 on error, 1 otherwise */
int
ccnet_packet_io_read (CcnetPacketIO *io)
{
int n;
ccnet_packet *packet;
int len;
again:
if ( (n = buffer_read(io->in_buf, io->fd, 1024)) < 0) {
if (errno == EINTR)
goto again;
g_warning ("read from connfd error: %s.\n", strerror(errno));
return -1;
}
if (n == 0) {
if (io->func)
io->func (NULL, io->user_data);
return 0;
}
while (BUFFER_LENGTH(io->in_buf) >= CCNET_PACKET_LENGTH_HEADER)
{
packet = (ccnet_packet *) BUFFER_DATA(io->in_buf);
len = ntohs (packet->header.length);
if (BUFFER_LENGTH (io->in_buf) - CCNET_PACKET_LENGTH_HEADER < len)
break;
packet->header.length = len;
packet->header.id = ntohl (packet->header.id);
io->func (packet, io->user_data);
buffer_drain (io->in_buf, len + CCNET_PACKET_LENGTH_HEADER);
}
return 1;
}
void init_heap(long heap_kbytes, long stack_kbytes, long code_kbytes) {
long i, code_size;
long hemiCount = 2;
will_gc_hook = did_gc_hook = NULL;
heap_size = heap_kbytes * 1024;
stack_size = stack_kbytes * 1024;
code_size = code_kbytes * 1024;
i = (hemiCount * heap_size) + stack_size + code_size;
heap = allocate_memory(i + sizeof(long));
if (!heap)
fatal_error("Cannot allocate %ld bytes for the heap!", i);
/* printf("INIT: heap = %x\n",heap); */
min_memory = heap = (void *)ALIGN_BYTE_POINTER((long)heap);
max_memory = heap + i;
heap_pointer = heap;
heap_end = heap + heap_size;
max_heap = heap + (hemiCount * heap_size);
code_pointer = max_heap;
stack_bottom = (object *)(code_pointer + code_size);
stack_top = (object *)((long)stack_bottom + stack_size);
sp = stack_top;
i = (long)GC_ROOT_STACK_MAX * (long)sizeof(object *);
gc_root_stack_buffer = make_buffer(i);
gc_root_stack_begin = (object **)BUFFER_DATA(gc_root_stack_buffer);
gc_root_stack_end = gc_root_stack_begin + i;
gc_root_stack_pointer = gc_root_stack_begin;
gc_tmp1 = null_object;
gc_tmp2 = null_object;
gc_tmp3 = null_object;
gc_tmp4 = null_object;
gc_tmp5 = null_object;
PUSH_GC_PROTECT(gc_tmp1);
PUSH_GC_PROTECT(gc_tmp2);
PUSH_GC_PROTECT(gc_tmp3);
PUSH_GC_PROTECT(gc_tmp4);
PUSH_GC_PROTECT(gc_tmp5);
}
void displayFunc(void)
{
sdkStartTimer(&timer);
TColor *d_dst = NULL;
size_t num_bytes;
if (frameCounter++ == 0)
{
sdkResetTimer(&timer);
}
// DEPRECATED: checkCudaErrors(cudaGLMapBufferObject((void**)&d_dst, gl_PBO));
checkCudaErrors(cudaGraphicsMapResources(1, &cuda_pbo_resource, 0));
getLastCudaError("cudaGraphicsMapResources failed");
checkCudaErrors(cudaGraphicsResourceGetMappedPointer((void **)&d_dst, &num_bytes, cuda_pbo_resource));
getLastCudaError("cudaGraphicsResourceGetMappedPointer failed");
checkCudaErrors(CUDA_Bind2TextureArray());
runImageFilters(d_dst);
checkCudaErrors(CUDA_UnbindTexture());
// DEPRECATED: checkCudaErrors(cudaGLUnmapBufferObject(gl_PBO));
checkCudaErrors(cudaGraphicsUnmapResources(1, &cuda_pbo_resource, 0));
// Common display code path
{
glClear(GL_COLOR_BUFFER_BIT);
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, imageW, imageH, GL_RGBA, GL_UNSIGNED_BYTE, BUFFER_DATA(0));
glBegin(GL_TRIANGLES);
glTexCoord2f(0, 0);
glVertex2f(-1, -1);
glTexCoord2f(2, 0);
glVertex2f(+3, -1);
glTexCoord2f(0, 2);
glVertex2f(-1, +3);
glEnd();
glFinish();
}
if (frameCounter == frameN)
{
frameCounter = 0;
if (g_FPS)
{
printf("FPS: %3.1f\n", frameN / (sdkGetTimerValue(&timer) * 0.001));
g_FPS = false;
}
}
glutSwapBuffers();
glutReportErrors();
sdkStopTimer(&timer);
computeFPS();
}
void
ccnet_packet_send (CcnetPacketIO *io)
{
writen (io->fd, BUFFER_DATA (io->buffer), io->buffer->off);
buffer_drain (io->buffer, io->buffer->off);
}
void garbage_collect(long min_space) {
char *p;
object **gcp;
object *op;
long i, max, count;
int old_interrupt;
if (*will_gc_hook) (*will_gc_hook)();
old_interrupt = enable_interrupts(0);
/* switch heap space */
gc_count++;
/* printf("[GC]\n"); */
heap += heap_size;
if (heap >= max_heap)
heap = min_memory;
heap_pointer = heap;
heap_end = heap + heap_size;
/* migrate objects */
count = gc_root_stack_pointer - gc_root_stack_begin;
migrate_object(gc_root_stack_buffer);
if (FORWARDED_P(gc_root_stack_buffer)) gc_root_stack_buffer = FORWARDED_POINTER(gc_root_stack_buffer);
gc_root_stack_begin = (object **)BUFFER_DATA(gc_root_stack_buffer);
gc_root_stack_end = gc_root_stack_begin + GC_ROOT_STACK_MAX;
gc_root_stack_pointer = gc_root_stack_begin + count;
gcp = gc_root_stack_begin;
for (i=0; i<count; i++)
migrate_object(*gcp[i]);
for (op = sp; op < stack_top; op++)
migrate_object(*op);
/* eliminate forwarding pointers */
gcp = gc_root_stack_begin;
for (i=0; i<count; i++) {
object o = *gcp[i];
if (FORWARDED_P(o))
*gcp[i] = FORWARDED_POINTER(o);
}
for (op = sp; op < stack_top; op++) {
object o = *op;
if (FORWARDED_P(o))
*op = FORWARDED_POINTER(o);
}
p = heap;
while (p < heap_pointer) {
object *q, obj, o;
obj = (object)p;
switch (POINTER_TYPE(obj)) {
case PAIR_TYPE:
o = CAR(obj); if (FORWARDED_P(o)) CAR(obj) = FORWARDED_POINTER(o);
o = CDR(obj); if (FORWARDED_P(o)) CDR(obj) = FORWARDED_POINTER(o);
break;
case WEAK_TYPE:
if (FORWARDED_P(WEAK_VALUE(obj))) {
WEAK_BOUND(obj) = 1;
} else {
WEAK_BOUND(obj) = 0;
migrate_object(WEAK_VALUE(obj));
}
o = WEAK_VALUE(obj); if (FORWARDED_P(o)) WEAK_VALUE(obj) = FORWARDED_POINTER(o);
break;
case SYMBOL_TYPE:
o = SYMBOL_VALUE(obj); if (FORWARDED_P(o)) SYMBOL_VALUE(obj) = FORWARDED_POINTER(o);
break;
case VECTOR_TYPE:
max = VECTOR_LENGTH(obj);
q = VECTOR_ELEMENTS(obj);
for (i=0; i<max; i++) {
o = q[i]; if (FORWARDED_P(o)) q[i] = FORWARDED_POINTER(o);
}
o = VECTOR_TAG(obj); if (FORWARDED_P(o)) VECTOR_TAG(obj) = FORWARDED_POINTER(o);
break;
case PROCEDURE_TYPE:
o = PROC_MODULE(obj); if (FORWARDED_P(o)) PROC_MODULE(obj) = FORWARDED_POINTER(o);
break;
case FRAME_TYPE:
o = FRAME_PREVIOUS(obj); if (FORWARDED_P(o)) FRAME_PREVIOUS(obj) = FORWARDED_POINTER(o);
o = FRAME_ENV(obj); if (FORWARDED_P(o)) FRAME_ENV(obj) = FORWARDED_POINTER(o);
max = (POINTER_LENGTH(obj) - sizeof(struct frame_heap_structure))/sizeof(long);
q = FRAME_ELEMENTS(obj);
for (i=0; i<max; i++) {
o = q[i]; if (FORWARDED_P(o)) q[i] = FORWARDED_POINTER(o);
}
break;
case CLOSURE_TYPE:
o = CLOSURE_PROC(obj); if (FORWARDED_P(o)) CLOSURE_PROC(obj) = FORWARDED_POINTER(o);
o = CLOSURE_ENV(obj); if (FORWARDED_P(o)) CLOSURE_ENV(obj) = FORWARDED_POINTER(o);
break;
case CONTINUATION_TYPE:
o = CONTINUATION_FRAME(obj); if (FORWARDED_P(o)) CONTINUATION_FRAME(obj) = FORWARDED_POINTER(o);
max = CONTINUATION_STACKSIZE(obj);
q = CONTINUATION_STACK(obj);
for (i=0; i<max; i++) {
o = q[i]; if (FORWARDED_P(o)) q[i] = FORWARDED_POINTER(o);
}
break;
case SYMBOLTABLE_TYPE:
o = SYMBOLTABLE_MAPPINGS(obj); if (FORWARDED_P(o)) SYMBOLTABLE_MAPPINGS(obj) = FORWARDED_POINTER(o);
break;
case PORT_TYPE:
o = PORT_BUFFER(obj); if (FORWARDED_P(o)) PORT_BUFFER(obj) = FORWARDED_POINTER(o);
break;
default:
fatal_error("Unknown pointer type: heap.c#garbage_collect(): %p\n", obj);
return;
}
p += POINTER_LENGTH(obj);
}
/* finalization of ports */
close_stale_ports();
fix_runtime_pointers();
/* Finish up */
enable_interrupts(old_interrupt);
i = heap_size - (heap_pointer - heap);
if (i < min_space)
fatal_error("out of heap space: %d\n", i);
if (*did_gc_hook) (*did_gc_hook)();
}
void displayFunc(void){
cutStartTimer(hTimer);
TColor *d_dst = NULL;
size_t num_bytes;
if(frameCounter++ == 0) cutResetTimer(hTimer);
// DEPRECATED: cutilSafeCall(cudaGLMapBufferObject((void**)&d_dst, gl_PBO));
cutilSafeCall(cudaGraphicsMapResources(1, &cuda_pbo_resource, 0));
cutilCheckMsg("cudaGraphicsMapResources failed");
cutilSafeCall(cudaGraphicsResourceGetMappedPointer((void**)&d_dst, &num_bytes, cuda_pbo_resource));
cutilCheckMsg("cudaGraphicsResourceGetMappedPointer failed");
cutilSafeCall( CUDA_Bind2TextureArray() );
runImageFilters(d_dst);
cutilSafeCall( CUDA_UnbindTexture() );
// DEPRECATED: cutilSafeCall(cudaGLUnmapBufferObject(gl_PBO));
cutilSafeCall(cudaGraphicsUnmapResources(1, &cuda_pbo_resource, 0));
if (g_bFBODisplay) {
g_FrameBufferObject->bindRenderPath();
}
// Common display code path
{
glClear(GL_COLOR_BUFFER_BIT);
glTexSubImage2D( GL_TEXTURE_2D, 0, 0, 0, imageW, imageH, GL_RGBA, GL_UNSIGNED_BYTE, BUFFER_DATA(0) );
glBegin(GL_TRIANGLES);
glTexCoord2f(0, 0); glVertex2f(-1, -1);
glTexCoord2f(2, 0); glVertex2f(+3, -1);
glTexCoord2f(0, 2); glVertex2f(-1, +3);
glEnd();
glFinish();
}
if (g_bFBODisplay) {
g_FrameBufferObject->unbindRenderPath();
glBindTexture(GL_TEXTURE_2D, 0);
}
if (g_CheckRender && g_CheckRender->IsQAReadback() && g_Verify) {
printf("> (Frame %d) readback BackBuffer\n", frameCount);
if (g_bFBODisplay) {
g_CheckRender->readback( imageW, imageH, g_FrameBufferObject->getFbo() );
} else {
g_CheckRender->readback( imageW, imageH );
}
g_CheckRender->savePPM ( sOriginal[g_Kernel], true, NULL );
if (!g_CheckRender->PPMvsPPM(sOriginal[g_Kernel], sReference[g_Kernel], MAX_EPSILON_ERROR, 0.15f)) {
g_TotalErrors++;
}
g_Verify = false;
}
if(frameCounter == frameN){
frameCounter = 0;
if(g_FPS){
printf("FPS: %3.1f\n", frameN / (cutGetTimerValue(hTimer) * 0.001) );
g_FPS = false;
}
}
glutSwapBuffers();
cutStopTimer(hTimer);
computeFPS();
}
