void thorium_transport_destroy(struct thorium_transport *self) { /* * Print the report if requested. */ if (core_bitmap_get_bit_uint32_t(&self->flags, FLAG_PROFILE)) { thorium_transport_profiler_print_report(&self->transport_profiler); } thorium_transport_profiler_destroy(&self->transport_profiler); CORE_DEBUGGER_ASSERT(thorium_transport_get_active_request_count(self) == 0); if (self->transport_interface != NULL) { self->transport_interface->destroy(self); core_memory_free(self->concrete_transport, MEMORY_TRANSPORT); self->concrete_transport = NULL; } self->node = NULL; self->rank = -1; self->size = -1; core_timer_destroy(&self->timer); }
void thorium_cfs_scheduler_print(struct thorium_scheduler *self) { struct thorium_cfs_scheduler *concrete_self; struct core_red_black_tree_iterator iterator; uint64_t virtual_runtime; struct thorium_actor *actor; int i; struct core_timer timer; core_timer_init(&timer); concrete_self = self->concrete_self; core_red_black_tree_iterator_init(&iterator, &concrete_self->tree); printf("[cfs_scheduler] %" PRIu64 " ns, timeline contains %d actors\n", core_timer_get_nanoseconds(&timer), core_red_black_tree_size(&concrete_self->tree)); i = 0; while (core_red_black_tree_iterator_get_next_key_and_value(&iterator, &virtual_runtime, &actor)) { printf("[%d] virtual_runtime= %" PRIu64 " actor= %s/%d\n", i, virtual_runtime, thorium_actor_script_name(actor), thorium_actor_name(actor)); ++i; } core_red_black_tree_iterator_destroy(&iterator); core_timer_destroy(&timer); }
void biosal_input_controller_destroy(struct thorium_actor *actor) { struct biosal_input_controller *concrete_actor; int i; char *pointer; struct core_map_iterator iterator; struct core_vector *vector; concrete_actor = (struct biosal_input_controller *)thorium_actor_concrete_actor(actor); core_timer_destroy(&concrete_actor->input_timer); core_timer_destroy(&concrete_actor->counting_timer); core_timer_destroy(&concrete_actor->distribution_timer); biosal_dna_codec_destroy(&concrete_actor->codec); for (i = 0; i < core_vector_size(&concrete_actor->files); i++) { pointer = *(char **)core_vector_at(&concrete_actor->files, i); core_memory_free(pointer, MEMORY_CONTROLLER); } core_vector_destroy(&concrete_actor->mega_block_vector); core_vector_destroy(&concrete_actor->counting_streams); core_vector_destroy(&concrete_actor->reading_streams); core_vector_destroy(&concrete_actor->partition_commands); core_vector_destroy(&concrete_actor->consumer_active_requests); core_vector_destroy(&concrete_actor->stream_consumers); core_vector_destroy(&concrete_actor->files); core_vector_destroy(&concrete_actor->spawners); core_vector_destroy(&concrete_actor->counts); core_vector_destroy(&concrete_actor->consumers); core_vector_destroy(&concrete_actor->stores_per_spawner); core_queue_destroy(&concrete_actor->unprepared_spawners); core_map_iterator_init(&iterator, &concrete_actor->mega_blocks); while (core_map_iterator_has_next(&iterator)) { core_map_iterator_next(&iterator, NULL, (void **)&vector); core_vector_destroy(vector); } core_map_iterator_destroy(&iterator); core_map_destroy(&concrete_actor->mega_blocks); core_map_destroy(&concrete_actor->assigned_blocks); }
void test_allocator(struct core_memory_pool *memory) { int i; int size; void *pointer; struct core_vector vector; struct core_timer timer; uint64_t elapsed; i = 1000000; size = 45; core_vector_init(&vector, sizeof(void *)); core_timer_init(&timer); core_timer_start(&timer); while (i--) { if (memory != NULL) { pointer = core_memory_pool_allocate(memory, size); } else { pointer = core_memory_allocate(size, -1); } core_vector_push_back(&vector, &pointer); } core_timer_stop(&timer); elapsed = core_timer_get_elapsed_nanoseconds(&timer); if (memory == NULL) { printf("Not using memory pool... "); } else { printf("Using memory pool... "); } printf("Elapsed : %" PRIu64 " milliseconds\n", elapsed / 1000 / 1000); size = core_vector_size(&vector); for (i = 0; i < size; ++i) { pointer = core_vector_at_as_void_pointer(&vector, i); if (memory != NULL) { core_memory_pool_free(memory, pointer); } else { core_memory_free(pointer, -1); } } core_vector_destroy(&vector); core_timer_destroy(&timer); }
void spate_destroy(struct thorium_actor *self) { struct spate *concrete_self; concrete_self = (struct spate *)thorium_actor_concrete_actor(self); core_timer_destroy(&concrete_self->timer); concrete_self->input_controller = THORIUM_ACTOR_NOBODY; concrete_self->manager_for_sequence_stores = THORIUM_ACTOR_NOBODY; concrete_self->assembly_graph = THORIUM_ACTOR_NOBODY; concrete_self->assembly_graph_builder = THORIUM_ACTOR_NOBODY; core_vector_destroy(&concrete_self->initial_actors); core_vector_destroy(&concrete_self->sequence_stores); core_vector_destroy(&concrete_self->graph_stores); }
void biosal_unitig_manager_destroy(struct thorium_actor *self) { struct biosal_unitig_manager *concrete_self; concrete_self = (struct biosal_unitig_manager *)thorium_actor_concrete_actor(self); core_vector_destroy(&concrete_self->spawners); core_vector_destroy(&concrete_self->graph_stores); core_vector_destroy(&concrete_self->walkers); core_vector_destroy(&concrete_self->visitors); concrete_self->completed = 0; concrete_self->manager = THORIUM_ACTOR_NOBODY; core_timer_destroy(&concrete_self->timer); }
void thorium_message_multiplexer_destroy(struct thorium_message_multiplexer *self) { int i; int size; struct thorium_multiplexed_buffer *multiplexed_buffer; float ratio; if (thorium_node_must_print_data(self->node)) { ratio = 0.0; if (self->original_message_count != 0) { ratio = self->real_message_count / (0.0 + self->original_message_count); /* * Jack M. Nilles * "Traffic reduction by telecommuting: A status review and selected bibliography" * Transportation Research Part A: General * Volume 22, Issue 4, July 1988, Pages 301–317. * * @see http://www.sciencedirect.com/science/article/pii/0191260788900088 * @see http://ww2.cityofpasadena.net/councilagendas/2007%20agendas/feb_26_07/pasadena%20traffic%20reduction%20strategies%2011-20-06%20draft.pdf */ thorium_printf("[thorium] node %d worker %d message_multiplexer:" " original_message_count %d real_message_count %d (traffic reduction: %.2f%%)\n", thorium_node_name(self->node), thorium_worker_name(self->worker), self->original_message_count, self->real_message_count, (1.0 - ratio) * 100); thorium_message_multiplexer_print_traffic_reduction(self); } } #ifdef CORE_DEBUGGER_ASSERT_ENABLED #endif size = core_vector_size(&self->buffers); #ifdef THORIUM_MULTIPLEXER_TRACK_BUFFERS_WITH_CONTENT /* * There can be no messages that are not flushed already. */ CORE_DEBUGGER_ASSERT(core_set_empty(&self->buffers_with_content)); core_set_destroy(&self->buffers_with_content); #endif for (i = 0; i < size; ++i) { multiplexed_buffer = core_vector_at(&self->buffers, i); CORE_DEBUGGER_ASSERT(thorium_multiplexed_buffer_current_size(multiplexed_buffer) == 0); thorium_multiplexed_buffer_destroy(multiplexed_buffer); } core_vector_destroy(&self->buffers); self->node = NULL; self->buffer_size_in_bytes = -1; self->timeout_in_nanoseconds = -1; core_timer_destroy(&self->timer); #ifdef THORIUM_MULTIPLEXER_USE_TREE core_red_black_tree_destroy(&self->timeline); #elif defined(THORIUM_MULTIPLEXER_USE_HEAP) core_binary_heap_destroy(&self->timeline); #elif defined(THORIUM_MULTIPLEXER_USE_QUEUE) core_queue_destroy(&self->timeline); #endif thorium_decision_maker_destroy(&self->decision_maker); thorium_router_destroy(&self->router); }
void thorium_worker_destroy(struct thorium_worker *worker) { void *buffer; thorium_load_profiler_destroy(&worker->profiler); if (core_bitmap_get_bit_uint32_t(&worker->flags, FLAG_ENABLE_ACTOR_LOAD_PROFILER)) { core_buffered_file_writer_destroy(&worker->load_profile_writer); } core_map_destroy(&worker->actor_received_messages); /* thorium_worker_print_balance(worker); */ while (thorium_worker_fetch_clean_outbound_buffer(worker, &buffer)) { core_memory_pool_free(&worker->outbound_message_memory_pool, buffer); #ifdef THORIUM_WORKER_DEBUG_INJECTION ++worker->counter_freed_outbound_buffers_from_other_workers; #endif } #ifdef THORIUM_WORKER_DEBUG_INJECTION printf("AFTER COLLECTION\n"); thorium_worker_print_balance(worker); printf("THORIUM-> clean_message_queue_for_triage has %d items\n", core_fast_queue_size(&worker->clean_message_queue_for_triage)); printf("THORIUM-> clean_message_ring_for_triage has %d items\n", core_fast_ring_size_from_producer(&worker->clean_message_ring_for_triage)); printf("THORIUM-> injected_clean_outbound_buffers has %d items\n", core_fast_ring_size_from_producer(&worker->injected_clean_outbound_buffers)); #endif core_timer_destroy(&worker->timer); #ifdef THORIUM_WORKER_ENABLE_LOCK core_lock_destroy(&worker->lock); #endif core_fast_ring_destroy(&worker->actors_to_schedule); #ifdef THORIUM_NODE_INJECT_CLEAN_WORKER_BUFFERS core_fast_ring_destroy(&worker->injected_clean_outbound_buffers); core_fast_ring_destroy(&worker->clean_message_ring_for_triage); core_fast_queue_destroy(&worker->clean_message_queue_for_triage); #endif thorium_scheduler_destroy(&worker->scheduler); core_fast_ring_destroy(&worker->outbound_message_queue); core_fast_queue_destroy(&worker->outbound_message_queue_buffer); core_map_destroy(&worker->actors); core_map_iterator_destroy(&worker->actor_iterator); core_set_destroy(&worker->evicted_actors); worker->node = NULL; worker->name = -1; core_bitmap_set_bit_uint32_t(&worker->flags, FLAG_DEAD); core_memory_pool_destroy(&worker->ephemeral_memory); core_memory_pool_destroy(&worker->outbound_message_memory_pool); thorium_priority_assigner_destroy(&worker->assigner); }