void timers_mark_updated(void) { uint8_t handler_count = linked_list_count(update_handlers); for (uint8_t h = 0; h < handler_count; h += 1) { TimersUpdatedHandler handler = linked_list_get(update_handlers, h); handler(); } }
/* Return a wavefront from the wavefront pool in the compute unit. * If a wavefront was found, it will be extracted from the wavefront pool. * If no valid candidate is found in the wavefront pool, the function returns NULL. */ struct gpu_wavefront_t *gpu_schedule(struct gpu_compute_unit_t *compute_unit) { struct gpu_wavefront_t *wavefront; /* If there is no wavefront in the pool, return NULL. */ if (!linked_list_count(compute_unit->wavefront_pool)) return NULL; /* Run different scheduling algorithm depending on configured policy */ switch (gpu_sched_policy) { case gpu_sched_round_robin: wavefront = gpu_schedule_round_robin(compute_unit); break; case gpu_sched_greedy: wavefront = gpu_schedule_greedy(compute_unit); break; default: panic("%s: invalid policy", __FUNCTION__); } /* Scheduled wavefront */ return wavefront; }
void timers_highlight(Timer* timer) { uint8_t handler_count = linked_list_count(highlight_handlers); for (uint8_t h = 0; h < handler_count; h += 1) { TimerHighlightHandler handler = linked_list_get(highlight_handlers, h); handler(timer); } }
static DISCRETE_START(dss_input_stream) { struct dss_input_context *context = (struct dss_input_context *)node->context; assert(DSS_INPUT_STREAM__STREAM < linked_list_count(node->info->input_list)); context->is_stream = TRUE; /* Stream out number is set during start */ context->stream_in_number = DSS_INPUT_STREAM__STREAM; context->gain = DSS_INPUT_STREAM__GAIN; context->offset = DSS_INPUT_STREAM__OFFSET; context->ptr = NULL; //context->data = 0; if (node->block->type == DSS_INPUT_BUFFER) { context->is_buffered = TRUE; context->buffer_stream = stream_create(node->info->device, 0, 1, node->info->sample_rate, (void *) node, buffer_stream_update); stream_set_input(node->info->discrete_stream, context->stream_in_number, context->buffer_stream, 0, 1.0); } else { context->is_buffered = FALSE; context->buffer_stream = NULL; } }
static void prv_init(void) { if (!s_handler_list) { s_handler_list = linked_list_create_root(); } if (linked_list_count(s_handler_list) == 0) { battery_state_service_subscribe(prv_handle_state_change); } }
void bitmaps_cleanup(void) { while (linked_list_count(bitmaps) > 0) { AppBitmap* bmp = linked_list_get(bitmaps, 0); gbitmap_destroy(bmp->bitmap); free(bmp); linked_list_remove(bitmaps, 0); } }
static char* clear_multiple(void) { linked_list_append(root, create_object(1)); linked_list_append(root, create_object(2)); linked_list_append(root, create_object(3)); linked_list_clear(root); mu_assert(0 == linked_list_count(root), "List is not empty after clearing multiple item list."); return 0; }
static char* append_count_multiple(void) { linked_list_append(root, create_object(1)); linked_list_append(root, create_object(2)); linked_list_append(root, create_object(3)); linked_list_append(root, create_object(4)); mu_assert(4 == linked_list_count(root), "Appending four item doesn't set size to 4."); return 0; }
static void prv_init(void) { if (!s_handler_list) { s_handler_list = linked_list_create_root(); } if (linked_list_count(s_handler_list) == 0) { app_focus_service_subscribe_handlers((AppFocusHandlers) { .will_focus = prv_handle_will_focus, .did_focus = prv_handle_did_focus, });
int return_valid_ticket(linked_list_t *invalid_tickets, int ticket_tail) { while (++ticket_tail) { if (linked_list_count(invalid_tickets, ticket_tail)) linked_list_remove(invalid_tickets, ticket_tail); else break; } return ticket_tail; }
void evg_faults_done(void) { while (linked_list_count(evg_fault_list)) { linked_list_head(evg_fault_list); free(linked_list_get(evg_fault_list)); linked_list_remove(evg_fault_list); } linked_list_free(evg_fault_list); }
static AppBitmap* get_app_bitmap_by_group(uint8_t group) { uint8_t count = linked_list_count(bitmaps); for (uint8_t b = 0; b < count; b += 1) { AppBitmap* bmp = (AppBitmap*)linked_list_get(bitmaps, b); if (bmp->group == group) { return bmp; } } return NULL; }
static AppBitmap* get_app_bitmap_by_res_id(uint32_t res_id) { uint8_t count = linked_list_count(bitmaps); for (uint8_t b = 0; b < count; b += 1) { AppBitmap* bmp = (AppBitmap*)linked_list_get(bitmaps, b); if (bmp->res_id == res_id) { return bmp; } } return NULL; }
static char* remove_multiple_items(void) { linked_list_append(root, create_object(1)); linked_list_append(root, create_object(2)); linked_list_append(root, create_object(3)); linked_list_remove(root, 2); linked_list_remove(root, 1); mu_assert(1 == get_id(linked_list_get(root, 0)), "Removing multiple items failed."); mu_assert(1 == linked_list_count(root), "Removing multiple items failed."); return 0; }
void timers_clear(void) { if (! timers) { return; } while (linked_list_count(timers) > 0) { Timer* timer = (Timer*) linked_list_get(timers, 0); linked_list_remove(timers, 0); free(timer); } }
/* Free command queue */ void evg_opencl_command_queue_free(struct evg_opencl_command_queue_t *command_queue) { /* Check that command list is empty */ if (linked_list_count(command_queue->command_list)) fatal("%s: freed command queue is not empty", __FUNCTION__); /* Free */ evg_opencl_repo_remove_object(evg_emu->opencl_repo, command_queue); linked_list_free(command_queue->command_list); free(command_queue); }
void si_uop_list_free(struct linked_list_t *gpu_uop_list) { struct si_uop_t *uop; while (linked_list_count(gpu_uop_list)) { linked_list_head(gpu_uop_list); uop = linked_list_get(gpu_uop_list); si_uop_free(uop); linked_list_remove(gpu_uop_list); } }
void events_app_message_unsubscribe(EventHandle handle) { int16_t index = linked_list_find(s_handler_list, handle); if (index == -1) { return; } free(linked_list_get(s_handler_list, index)); linked_list_remove(s_handler_list, index); if (linked_list_count(s_handler_list) == 0) { app_message_deregister_callbacks(); } }
void events_battery_state_service_unsubscribe(EventHandle handle) { int16_t index = linked_list_find(s_handler_list, handle); if (index == -1) { return; } free(linked_list_get(s_handler_list, index)); linked_list_remove(s_handler_list, index); if (linked_list_count(s_handler_list) == 0) { battery_state_service_unsubscribe(); } }
void X86CoreFreeEventQueue(X86Core *self) { struct x86_uop_t *uop; while (linked_list_count(self->event_queue)) { uop = X86CoreExtractFromEventQueue(self); x86_uop_free_if_not_queued(uop); } linked_list_free(self->event_queue); }
static bool prv_init(void) { if (!s_handler_list) { s_handler_list = linked_list_create_root(); } if (linked_list_count(s_handler_list) == 0) { app_message_register_outbox_sent(prv_handle_outbox_sent); app_message_register_outbox_failed(prv_handle_outbox_failed); app_message_register_inbox_received(prv_handle_inbox_received); app_message_register_inbox_dropped(prv_handle_inbox_dropped); } return true; }
void X86ThreadFreeLSQ(X86Thread *self) { struct linked_list_t *lq; struct linked_list_t *sq; struct linked_list_t *preq; struct x86_uop_t *uop; /* Load queue */ lq = self->lq; linked_list_head(lq); while (linked_list_count(lq)) { uop = linked_list_get(lq); uop->in_lq = 0; linked_list_remove(lq); x86_uop_free_if_not_queued(uop); } linked_list_free(lq); /* Store queue */ sq = self->sq; linked_list_head(sq); while (linked_list_count(sq)) { uop = linked_list_get(sq); uop->in_sq = 0; linked_list_remove(sq); x86_uop_free_if_not_queued(uop); } linked_list_free(sq); /* Prefetch queue */ preq = self->preq; linked_list_head(preq); while (linked_list_count(preq)) { uop = linked_list_get(preq); uop->in_preq = 0; linked_list_remove(preq); x86_uop_free_if_not_queued(uop); } linked_list_free(preq); }
/* Schedule all events waiting in the wakeup list */ void net_buffer_wakeup(struct net_buffer_t *buffer) { struct net_buffer_wakeup_t *wakeup; while (linked_list_count(buffer->wakeup_list)) { /* Get event/stack */ linked_list_head(buffer->wakeup_list); wakeup = linked_list_get(buffer->wakeup_list); linked_list_remove(buffer->wakeup_list); /* Schedule event */ esim_schedule_event(wakeup->event, wakeup->stack, 0); free(wakeup); } }
struct x86_uop_t *X86CoreExtractFromEventQueue(X86Core *self) { struct linked_list_t *event_queue = self->event_queue; struct x86_uop_t *uop; if (!linked_list_count(event_queue)) return NULL; linked_list_head(event_queue); uop = linked_list_get(event_queue); assert(x86_uop_exists(uop)); assert(uop->in_event_queue); linked_list_remove(event_queue); uop->in_event_queue = 0; return uop; }
GBitmap* bitmaps_get_sub_bitmap(uint32_t res_id, GRect rect) { if (! bitmaps) { return NULL; } GBitmap* parent = NULL; uint8_t count = linked_list_count(bitmaps); for (uint8_t b = 0; b < count; b += 1) { AppBitmap* bmp = (AppBitmap*)linked_list_get(bitmaps, b); if (bmp->res_id == res_id) { if (bmp->is_sub) { if (grect_equal(bmp->rect, &rect)) { return bmp->bitmap; } } else { parent = bmp->bitmap; } } } if (! parent) { parent = bitmaps_get_bitmap(res_id); if (! parent) { return NULL; } } AppBitmap* app_bmp = malloc(sizeof(AppBitmap)); if (app_bmp == NULL) { return NULL; } app_bmp->res_id = res_id; app_bmp->bitmap = gbitmap_create_as_sub_bitmap(parent, rect); if (app_bmp->bitmap == NULL) { return NULL; } app_bmp->rect = malloc(sizeof(GRect)); app_bmp->rect->origin = rect.origin; app_bmp->rect->size = rect.size; app_bmp->is_sub = true; linked_list_append(bitmaps, app_bmp); return app_bmp->bitmap; }
const char *localize_str(int hashval) { hash_string s; s.hashval = hashval; int16_t index = linked_list_find_compare(s_root, &s, compare_hash_string); if(index > -1){ return ((hash_string*)linked_list_get(s_root, index))->value; } else { char *res = prv_load(hashval); if(res){ if(s_limit > 0){ uint16_t count = linked_list_count(s_root); if(count > s_limit){ hash_string *last = linked_list_get(s_root, count-1); prv_destroy_element(last, NULL); linked_list_remove(s_root, count-1); } } return res; } } return "\7"; //return blank character }
uint8_t timers_count(void) { return linked_list_count(timers); }
void si_scalar_unit_writeback(struct si_scalar_unit_t *scalar_unit) { struct si_uop_t *uop = NULL; struct si_wavefront_t *wavefront; struct si_work_group_t *work_group; struct si_ndrange_t *ndrange; int i; int list_count; int wavefront_id; /* Process completed memory instructions */ list_count = linked_list_count(scalar_unit->mem_out_buffer); linked_list_head(scalar_unit->mem_out_buffer); for (i = 0; i < list_count; i++) { uop = linked_list_get(scalar_unit->mem_out_buffer); assert(uop); if (!uop->global_mem_witness) { /* Access complete, remove the uop from the queue */ linked_list_remove(scalar_unit->mem_out_buffer); si_trace("si.inst id=%lld cu=%d stg=\"su-w\"\n", uop->id_in_compute_unit, scalar_unit->compute_unit->id); /* Make the wavefront active again */ wavefront = uop->wavefront; wavefront->ready = 1; /* Free uop */ if (si_tracing()) si_gpu_uop_trash_add(uop); else si_uop_free(uop); } else { linked_list_next(scalar_unit->mem_out_buffer); } } /* Process completed ALU instructions */ list_count = linked_list_count(scalar_unit->alu_out_buffer); linked_list_head(scalar_unit->alu_out_buffer); for (i = 0; i < list_count; i++) { uop = linked_list_get(scalar_unit->alu_out_buffer); assert(uop); if (uop->execute_ready <= si_gpu->cycle) { /* Access complete, remove the uop from the queue */ linked_list_remove(scalar_unit->alu_out_buffer); si_trace("si.inst id=%lld cu=%d stg=\"su-w\"\n", uop->id_in_compute_unit, scalar_unit->compute_unit->id); /* Make the wavefront active again */ wavefront = uop->wavefront; work_group = wavefront->work_group; ndrange = work_group->ndrange; if (wavefront->finished) { work_group->compute_unit_finished_count++; } else if (wavefront->barrier) { if (wavefront->barrier_cleared) { /* All wavefronts have hit barrier */ wavefront->barrier_cleared = 0; SI_FOREACH_WAVEFRONT_IN_WORK_GROUP(work_group, wavefront_id) { wavefront = ndrange->wavefronts[wavefront_id]; wavefront->barrier = 0; wavefront->ready = 1; } } else { /* Wavefront is waiting at barrier */ } } else {
/** * Function to get the number of presets in the list. * @return number of presets in the preset list. */ int presets_get_count(){ return linked_list_count(presets); }
int timers_get_count() { return linked_list_count(timers); }