/* Auxiliary function for freeing boxed types */ void boxed_free_helper (GType *gtype, void *boxed) { if (print_debug_info()) { fprintf(stderr, "Freeing a boxed object at %p\n", boxed); fprintf(stderr, "\tIt is of type %s\n", g_type_name(*gtype)); } g_boxed_free (*gtype, boxed); g_free (gtype); if (print_debug_info()) { fprintf(stderr, "\tdone\n"); } }
void display() { handleInput(tf_world); timer->tick(); monster->update(); glClearColor(0.0f, 0.0f, 0.0f, 1.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glPushMatrix(); tf_world->applyST(); board->draw(); highlight->draw(mouse, tf_world); gun1->draw(); gun2->draw(); tesbil->draw(); monster->draw(); planet->draw(); cursor->draw(); glPopMatrix(); print_debug_info(mouse, tf_world, timer->intervalTicks); glutSwapBuffers(); glutPostRedisplay(); }
TTFSurfacePtr TTFSurfaceManager::create_surface(const TTFFont& font, const std::string& text) { auto key = Key(font.get_ttf_font(), text); auto it = m_cache.find(key); if (it != m_cache.end()) { auto& entry = m_cache[key]; entry.last_access = g_game_time; return entry.ttf_surface; } else { if ((false)) { // Font debug output should go to 'std::cerr', not any of the // log_* functions, as those are mirrored on the console which // in turn will lead to the creation of more TTFSurface's and // screw up the results. print_debug_info(std::cerr); } cache_cleanup_step(); TTFSurfacePtr ttf_surface = TTFSurface::create(font, text); m_cache[key] = ttf_surface; return ttf_surface; } }
uint8_t execute_interpreter_cycle(cpu_registers* registers, bool nmi_flag) { static bool previous_nmi_flag = false; uint8_t cpu_cycles_executed = 0; uint8_t extra_cycles= 0; if(DMA_is_executing()) cpu_cycles_executed = execute_DMA(); else { uint8_t opcode = fetch_opcode(registers); increment_PC(registers); if(nmi_flag && !previous_nmi_flag) cpu_cycles_executed = execute_NMI(registers); else { #ifdef DEBUG print_debug_info(registers, opcode); #endif extra_cycles = execute_instruction(registers, opcode); cpu_cycles_executed = instruction_cycle_length[opcode] + extra_cycles; // Do not increment PC if we jump because it will skip the first instruction at least if(!is_JSR_or_JMP(opcode) && !is_RTI(opcode)) increment_PC_instruction_length(registers, opcode); } } previous_nmi_flag = nmi_flag; odd_cpu_cycle = cpu_cycles_executed & 0x1; return cpu_cycles_executed; }
gpointer dbg_g_object_newv (GType gtype, guint n_params, GParameter *params) { gpointer result; if (print_debug_info()) { fprintf(stderr, "Creating a new GObject of type %s\n", g_type_name(gtype)); } result = g_object_newv (gtype, n_params, params); if (print_debug_info()) { fprintf(stderr, "\tdone, got a pointer at %p\n", result); } return result; }
void dbg_g_object_unref (GObject *obj) { GType gtype; if (print_debug_info()) { fprintf(stderr, "Freeing a GObject at %p\n", obj); gtype = G_TYPE_FROM_INSTANCE (obj); fprintf(stderr, "\tIt is of type %s\n", g_type_name(gtype)); fprintf(stderr, "\t**s refcount before unref is %d\n", (int)obj->ref_count); } g_object_unref(obj); if (print_debug_info()) { fprintf(stderr, "\tdone\n"); } }
std::unique_ptr<TileSet> TileSet::from_file(const std::string& filename) { auto tileset = std::make_unique<TileSet>(); TileSetParser parser(*tileset, filename); parser.parse(); tileset->print_debug_info(filename); return tileset; }
/*------------------------------------------------------------------------+*/ int XeAppendToStringBuffer(XeStringBuffer buffer, XeString string) /*------------------------------------------------------------------------+*/ { int size = buffer->size; XeString buffer_position; /* so operations are pointer based */ int i; # if DEBUG >= 5 sprintf(debug_string, "appending: \"%s\" to: \"%s\"", string, buffer->buffer); print_debug_info(5, debug_string); # endif if (!(string && string[0])) { return(0); } buffer_position = &(buffer->buffer[buffer->last_char]); for (i = buffer->last_char; *string ; i++) { if (i == size) { buffer->last_char = i - 1; if (-1 == ExpandStringBuffer(buffer)) return(-1); size = buffer->size; buffer_position = &(buffer->buffer[i]); } *buffer_position++ = *string++; } if (i == size) { buffer->last_char = i - 1; if (-1 == ExpandStringBuffer(buffer)) return(-1); } buffer->buffer[i] = (XeChar) NULL; buffer->last_char = i; # if DEBUG >= 5 sprintf(debug_string, "new string is: \"%s\"", buffer->buffer); print_debug_info(6, debug_string); # endif return(0); }
static int print_thread(void * data) { while(1){ wake_lock(&messages_wakelock); if (print_thread_enable) print_debug_info(); has_wake_lock(WAKE_LOCK_SUSPEND); msleep(100); wake_unlock(&messages_wakelock); set_current_state(TASK_INTERRUPTIBLE); schedule_timeout(print_thread_interval * HZ); } return 0; }
/*------------------------------------------------------------------------+*/ static int ExpandStringBuffer(XeStringBuffer buffer) /*------------------------------------------------------------------------+*/ { int new_size = buffer->size + buffer->increment; XeString new_string = Xe_make_ntype(new_size, XeChar); # if DEBUG >= 3 sprintf(debug_string, "expanding string buffer. current size is: %d", buffer->size); print_debug_info(3, debug_string); # endif memcpy(new_string, buffer->buffer, buffer->last_char + 1); XeFree(buffer->buffer); buffer->size = new_size; buffer->buffer = new_string; buffer->increment += (buffer->increment % EXPANSION_FACTOR); # if DEBUG >= 3 sprintf(debug_string, "new size is: %d", buffer->size); print_debug_info(4, debug_string); # endif return(0); }
void execute_loop(chip_8_cpu cpu, FILE *debug_log) { if (pthread_create(&(cpu->delay_decrement_thread), NULL, delay_thread, cpu) != 0) { shutdown_cpu(cpu, 1); } if (pthread_create(&(cpu->sound_decrement_thread), NULL, sound_thread, cpu) != 0) { fprintf(stderr, "Failed to start the sound register thread, exiting...\n"); shutdown_cpu(cpu, 1); } pthread_detach(cpu->delay_decrement_thread); pthread_detach(cpu->sound_decrement_thread); cpu->chip_8_screen = init_ncurses(default_window_height, default_window_width); refresh_window(cpu->chip_8_screen); while (1) { if (cpu->program_counter >= MEMORY_SIZE) { fprintf(stderr, "ERR - Fatal memory error: invalid access at memory cell: '%d'\n", cpu->program_counter); shutdown_cpu(cpu, 1); } if (cpu->halt) { break; } opcode instr = fetch_opcode(cpu); if (debug_log) { print_debug_info(debug_log, instr, cpu); } execute_opcode(instr, cpu); if (cpu->performed_jump) { cpu->performed_jump = false; continue; } if (cpu->skip_opcode) { cpu->program_counter = cpu->program_counter + 2; cpu->skip_opcode = false; } else { cpu->program_counter = cpu->program_counter + 1; } } // allow 0.1 seconds for the threads to clean up their memory usleep(100000); delwin(cpu->chip_8_screen); endwin(); }
static int my_action(void *new_ps, void **children, int n_children, int pn_offset, struct D_Parser *parser, int speculative) { D_ParseNode *dd = D_PN(new_ps, pn_offset); PyObject *result = NULL; PyObject *children_list, *string_list = NULL; PNode *pn = (PNode *)new_ps; int action_index = pn->reduction->action_index; PyObject *tuple = NULL; PyObject *arg_types = NULL; D_ParserPyInterface *ppi = d_interface(parser); int takes_speculative = 0; PyObject *action = 0; if (PyErr_Occurred()) { /* just keep returning until finished parsing. Need a way to tell dparser to quit */ return 0; } if (action_index != -1) { tuple = PyList_GetItem(ppi->actions, action_index); PyArg_ParseTuple(tuple, "OOi", &action, &arg_types, &takes_speculative); } if (ppi->takes_globals) { inc_global_state(parser, dd); } if (ppi->print_debug_info && tuple) { print_debug_info(dd, tuple, speculative, ppi->print_debug_info); } if (takes_speculative == -1 && !speculative) { /* user.t and user.s were already set when this was called speculatively */ return 0; } if (ppi->takes_strings) { string_list = pylist_children(parser, dd, 1); if (string_list == NULL) { return -1; } } /* this function owns string_list */ if (takes_speculative == 0 && speculative) { Py_INCREF(Py_None); Py_XDECREF(dd->user.t); /* if (dd->user.s) printf("freeing2:%d\n", dd->user.s);*/ Py_XDECREF(dd->user.s); dd->user.t = Py_None; // printf("dd1:%d\n", dd); dd->user.s = NULL; Py_XDECREF(string_list); /* printf("setting:%d\n", string_list);*/ //dd->user.s = string_list; return 0; } children_list = pylist_children(parser, dd, 0); if (children_list == NULL) { /* if (string_list) printf("freeing3:%d\n", string_list);*/ Py_XDECREF(string_list); return -1; } /* this function owns children_list */ if (action_index != -1) { result = take_action(arg_types, children_list, speculative, dd, string_list, n_children, parser, children, pn_offset, action); Py_DECREF(children_list); } else { result = children_list; } /* function now owns result, string_list */ if (result == ppi->reject || result == NULL) { /* if (string_list) printf("freeing4:%d\n", string_list);*/ Py_XDECREF(result); Py_XDECREF(string_list); return -1; /* user rejected */ } Py_XDECREF(dd->user.t); /* these may have been set in a speculative pass */ /* if(dd->user.s) printf("freeing5:%d\n", dd->user.s);*/ Py_XDECREF(dd->user.s); /* if(dd->user.s) printf("setting2:%d\n", string_list);*/ // printf("dd2:%d\n", dd); dd->user.t = result; dd->user.s = string_list; return 0; }
int main(int argc, char **argv) { if (SDL_Init(SDL_INIT_EVERYTHING) != 0) { APP_LOG << "Failed to initialize SDL: " << SDL_GetError() << '\n'; return EXIT_FAILURE; } int window_width = 640; int window_height = 480; SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3); SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1); SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24); SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1); SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 4); SDL_Window *window = SDL_CreateWindow( "Sample Application", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, window_width, window_height, SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL); if (window == NULL) { APP_LOG << "Failed to create a window: " << SDL_GetError() << '\n'; SDL_Quit(); return EXIT_FAILURE; } SDL_GLContext gl_context = SDL_GL_CreateContext(window); SDL_GL_SetSwapInterval(1); // Wait for vertical refresh glewExperimental = true; GLenum glew_error = glewInit(); if (glew_error != GLEW_OK) { APP_LOG << "Failed to load OpenGL functions: " << glewGetErrorString(glew_error) << '\n'; SDL_GL_DeleteContext(gl_context); SDL_DestroyWindow(window); SDL_Quit(); return EXIT_FAILURE; } print_debug_info(); if(!load_game(window_width, window_height)) { APP_LOG << "Failed to load content" << '\n'; SDL_GL_DeleteContext(gl_context); SDL_DestroyWindow(window); SDL_Quit(); return EXIT_FAILURE; } init_game(); gui::init(window_width, window_height); uint vao; glGenVertexArrays(1, &vao); glBindVertexArray(vao); glViewport(0, 0, window_width, window_height); double frame_time = 1.0 / 60.0; bool running = true; while (running) { double frame_begin = get_elapsed_time(); handle_events(running, window); gui::update(frame_time); update_game(frame_time); render_game(frame_time); SDL_GL_SwapWindow(window); frame_time = get_elapsed_time() - frame_begin; if (check_gl_errors()) running = false; if (frame_time < 1.0 / 60.0) { sleep(1.0 / 60.0 - frame_time); frame_time = get_elapsed_time() - frame_begin; } } gui::dispose(); SDL_GL_DeleteContext(gl_context); SDL_DestroyWindow(window); SDL_Quit(); return EXIT_SUCCESS; }
/* Buffer filling thread. */ static void buffer_thread (http_desc_t *desc) { pthread_mutex_t mut; /* Temporary mutex. */ int BLOCK_SIZE = HTTP_BLOCK_SIZE; void *ibuffer; int rest = 0; int metasize = 0, metapos = 0, extra_read = 0; char *p; /* Init */ pthread_mutex_init (&mut, NULL); if (desc->icy_metaint) { BLOCK_SIZE = (HTTP_BLOCK_SIZE > desc->icy_metaint) ? desc->icy_metaint : HTTP_BLOCK_SIZE; } ibuffer = malloc (BLOCK_SIZE << 1); /* Process while main thread allow it. */ while (desc->going) { void *newbuf; int readed; #ifdef DEBUG_HTTP_BUFFERING print_debug_info (desc); #endif rest = metasize = 0; /* trying to shrink buffer */ pthread_mutex_lock (&desc->buffer_lock); shrink_buffer (desc); pthread_mutex_unlock (&desc->buffer_lock); /* let them know about our state, heh */ status_notify (desc); /* check for overflow */ if (desc->len > http_buffer_size) { /* Notice waiting function that the new block of data has arrived */ desc->new_datablock = 1; pthread_cond_signal (&desc->new_datablock_signal); /* Make pause */ if (!desc->dont_wait) { pthread_mutex_lock (&mut); cond_timedwait_relative (&desc->dont_wait_signal, &mut, calc_time_to_wait (desc)); pthread_mutex_unlock (&mut); } else { desc->dont_wait--; } continue; } /* read to internal buffer */ readed = read_data (desc->sock, ibuffer, BLOCK_SIZE); /* reasons to stop */ if (readed == 0) { desc->going = 0; } else if (readed <0) { desc->error = 1; desc->going = 0; } else { /* Something readed */ /* Metadata stuff */ if (desc->icy_metaint > 0 && (desc->buffer_pos+readed) > desc->icy_metaint) { /* Metadata block is next! */ rest = (desc->buffer_pos+readed) - desc->icy_metaint; p = ((char *)ibuffer); p += (readed-rest); metapos = (readed-rest); if (rest) { metasize = *(int8_t *)p; metasize <<= 4; if (rest < metasize) { /* Uh oh, big trouble ahead, or maybe not? */ extra_read = read_data (desc->sock, ibuffer+readed, metasize); readed += extra_read; rest += extra_read; } if (metasize > 4080) { alsaplayer_error("Invalid metasize (%d)", metasize); } else if (metasize > 0) { p++; p[metasize] = '\0'; pthread_mutex_lock (&desc->meta_lock); if (desc->metadata) { free(desc->metadata); } desc->metadata = malloc(strlen(p)+1); memcpy(desc->metadata, p, strlen(p)); pthread_mutex_unlock (&desc->meta_lock); } else { /* Metadata is zero length */ } } else { alsaplayer_error("Rest = 0???"); } metasize++; /* Length byte */ } else { desc->buffer_pos += readed; } /* These operations are fast. -> doesn't break reader_read */ /* ---------------- lock buffer ( */ pthread_mutex_lock (&desc->buffer_lock); /* enlarge buffer */ newbuf = malloc (desc->len + (BLOCK_SIZE * 2)); /* HTTP_BLOCK_SIZE */ memcpy (newbuf, desc->buffer, desc->len); if (metasize) { memcpy(newbuf + desc->len, ibuffer, metapos); memcpy(newbuf + desc->len + metapos, ibuffer+metapos+metasize, rest - metasize); readed -= metasize; desc->buffer_pos = rest - metasize; } else { memcpy (newbuf + desc->len, ibuffer, readed); } /* switch buffers */ free (desc->buffer); desc->buffer = newbuf; desc->len += readed; /* unlock buffer ) */ pthread_mutex_unlock (&desc->buffer_lock); } /* Notice waiting function that the new block of data has arrived */ desc->new_datablock = 1; pthread_cond_signal (&desc->new_datablock_signal); /* Do wait */ if (desc->going && !desc->dont_wait) { pthread_mutex_lock (&mut); cond_timedwait_relative (&desc->dont_wait_signal, &mut, calc_time_to_wait (desc)); pthread_mutex_unlock (&mut); } if (desc->dont_wait) desc->dont_wait--; } free (ibuffer); pthread_exit (NULL); } /* end of: buffer_thread */
int main(int argc, char *argv[]) { /* mandatory function to initialize simple executive application */ cvmx_user_app_init(); sysinfo = cvmx_sysinfo_get(); if (cvmx_is_init_core()) { /* may need to specify this manually for simulator */ cpu_clock_hz = sysinfo->cpu_clock_hz; if(init_tasks(NUM_PACKET_BUFFERS) != 0) { printf("Initialization failed!\n"); exit(-1); } /* get the FPA pool number of packet and WQE pools */ packet_pool = cvmx_fpa_get_packet_pool(); wqe_pool = cvmx_fpa_get_wqe_pool(); print_debug_info(); int num_interfaces = cvmx_helper_get_number_of_interfaces(); int interface; bool found_valid_xaui_port = false; for (interface=0; interface < num_interfaces && !found_valid_xaui_port; interface++) { uint32_t num_ports = cvmx_helper_ports_on_interface(interface); cvmx_helper_interface_mode_t imode = cvmx_helper_interface_get_mode(interface); if (imode == CVMX_HELPER_INTERFACE_MODE_XAUI) { printf("\nIdentified XAUI interface with %" PRIu32 " port(s)\n", num_ports); printf("interface number: %d\n", interface); uint32_t port; for (port = 0; port < num_ports; port++) { if (cvmx_helper_is_port_valid(interface, port)) { xaui_ipd_port = cvmx_helper_get_ipd_port(interface, port); printf("xaui_ipd_port: %d\n", xaui_ipd_port); found_valid_xaui_port = true; break; } } } printf("\n"); } } /* Wait (stall) until all cores in the given coremask have reached this * point in the progam execution before proceeding. */ CORE_MASK_BARRIER_SYNC; if (cvmx_is_init_core()) { receive_packet(); } else if (cvmx_get_core_num() == 1) { send_packet(); } else { /* for this program, all cores besides the first two are superfluous */ printf("Superfluous core #%02d\n", cvmx_get_core_num()); return 0; } printf("Execution complete for core #%02d\n", cvmx_get_core_num()); return 0; }