void thorium_mpi1_pt2pt_transport_destroy(struct thorium_transport *self)
{
struct thorium_mpi1_pt2pt_transport *concrete_self;
int result;
struct thorium_mpi1_pt2pt_active_request active_request;
concrete_self = thorium_transport_get_concrete_transport(self);
while (core_queue_dequeue(&concrete_self->active_requests, &active_request)) {
thorium_mpi1_pt2pt_active_request_destroy(&active_request);
}
core_queue_destroy(&concrete_self->active_requests);
/*
* \see http://www.mpich.org/static/docs/v3.1/www3/MPI_Comm_free.html
*/
result = MPI_Comm_free(&concrete_self->comm);
if (result != MPI_SUCCESS) {
return;
}
result = MPI_Finalize();
if (result != MPI_SUCCESS) {
return;
}
}
void biosal_sequence_partitioner_destroy(struct thorium_actor *actor)
{
struct biosal_sequence_partitioner *concrete_actor;
concrete_actor = (struct biosal_sequence_partitioner *)thorium_actor_concrete_actor(actor);
core_vector_destroy(&concrete_actor->stream_entries);
core_vector_destroy(&concrete_actor->stream_positions);
core_vector_destroy(&concrete_actor->stream_global_positions);
core_vector_destroy(&concrete_actor->store_entries);
core_queue_destroy(&concrete_actor->available_commands);
core_map_destroy(&concrete_actor->active_commands);
}
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);
}
int main(int argc, char **argv)
{
BEGIN_TESTS();
{
/* test when inserting more than array size */
struct core_queue queue;
int i;
core_queue_init(&queue, sizeof(int));
TEST_INT_EQUALS(core_queue_empty(&queue), 1);
i = 16;
while (i--) {
TEST_INT_EQUALS(core_queue_enqueue(&queue, &i), 1);
}
i = 16;
while (i--) {
TEST_INT_EQUALS(core_queue_enqueue(&queue, &i), 1);
}
TEST_INT_EQUALS(core_queue_full(&queue), 0);
i = 16;
while (i--) {
int item;
TEST_INT_EQUALS(core_queue_dequeue(&queue, &item), 1);
}
i = 16;
while (i--) {
int item;
TEST_INT_EQUALS(core_queue_dequeue(&queue, &item), 1);
}
core_queue_destroy(&queue);
}
{
/* push 1000 elements, and verify them after */
struct core_queue queue;
int i;
core_queue_init(&queue, sizeof(int));
TEST_INT_EQUALS(core_queue_empty(&queue), 1);
i = 1000;
while (i--) {
TEST_INT_EQUALS(core_queue_enqueue(&queue, &i), 1);
}
TEST_INT_EQUALS(core_queue_full(&queue), 0);
i = 1000;
while (i--) {
int item;
TEST_INT_EQUALS(core_queue_dequeue(&queue, &item), 1);
TEST_INT_EQUALS(item, i);
/* printf("%i %i\n", item, i); */
}
TEST_INT_EQUALS(core_queue_empty(&queue), 1);
core_queue_destroy(&queue);
}
{
/* use array size of 1 and 2000 elements */
struct core_queue queue;
int i;
core_queue_init(&queue, sizeof(int));
TEST_INT_EQUALS(core_queue_empty(&queue), 1);
i = 2000;
while (i--) {
TEST_INT_EQUALS(core_queue_enqueue(&queue, &i), 1);
}
TEST_INT_EQUALS(core_queue_full(&queue), 0);
i = 2000;
while (i--) {
int item;
TEST_INT_EQUALS(core_queue_dequeue(&queue, &item), 1);
TEST_INT_EQUALS(item, i);
/* printf("%i %i\n", item, i); */
}
TEST_INT_EQUALS(core_queue_empty(&queue), 1);
core_queue_destroy(&queue);
}
{
/* stress test the code by inserting one element,
and then removing. */
struct core_queue queue;
int i;
int expected;
core_queue_init(&queue, sizeof(int));
TEST_INT_EQUALS(core_queue_empty(&queue), 1);
i = 3000;
while (i--) {
expected = i;
TEST_INT_EQUALS(core_queue_enqueue(&queue, &i), 1);
TEST_INT_EQUALS(core_queue_dequeue(&queue, &i), 1);
TEST_INT_EQUALS(i, expected);
TEST_INT_EQUALS(core_queue_empty(&queue), 1);
TEST_INT_EQUALS(core_queue_enqueue(&queue, &i), 1);
TEST_INT_EQUALS(core_queue_dequeue(&queue, &i), 1);
TEST_INT_EQUALS(i, expected);
}
TEST_INT_EQUALS(core_queue_full(&queue), 0);
TEST_INT_EQUALS(core_queue_empty(&queue), 1);
/*
* At any time, there is 0 or 1 elements in the queue.
*/
/*
core_queue_print(&queue);
*/
TEST_INT_IS_LOWER_THAN(core_queue_capacity(&queue), 100);
core_queue_destroy(&queue);
}
{
struct core_queue queue;
int i;
int value;
core_queue_init(&queue, sizeof(int));
#if 0
printf("Test 3\n");
#endif
TEST_INT_EQUALS(core_queue_empty(&queue), 1);
i = 3000;
while (i--) {
value = i;
TEST_INT_EQUALS(core_queue_enqueue(&queue, &value), 1);
TEST_INT_EQUALS(core_queue_enqueue(&queue, &value), 1);
TEST_INT_EQUALS(core_queue_dequeue(&queue, &value), 1);
}
#if 0
printf("Test 3, size %d\n",
core_queue_size(&queue));
#endif
core_queue_destroy(&queue);
}
{
struct core_queue queue;
int i;
int value;
core_queue_init(&queue, sizeof(int));
#if 0
printf("Test 4\n");
#endif
TEST_INT_EQUALS(core_queue_empty(&queue), 1);
i = 3000000;
while (i--) {
value = i;
TEST_INT_EQUALS(core_queue_enqueue(&queue, &value), 1);
TEST_INT_EQUALS(core_queue_enqueue(&queue, &value), 1);
TEST_INT_EQUALS(core_queue_dequeue(&queue, &value), 1);
TEST_INT_EQUALS(core_queue_dequeue(&queue, &value), 1);
}
#if 0
printf("Test 4, size %d\n",
core_queue_size(&queue));
#endif
core_queue_destroy(&queue);
}
END_TESTS();
return 0;
}
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);
}
