void thorium_message_multiplexer_set_worker(struct thorium_message_multiplexer *self,
struct thorium_worker *worker)
{
struct core_memory_pool *pool;
self->worker = worker;
pool = thorium_worker_get_memory_pool(self->worker,
MEMORY_POOL_NAME_WORKER_PERSISTENT);
#ifdef THORIUM_MULTIPLEXER_USE_TREE
core_red_black_tree_init(&self->timeline, sizeof(uint64_t), sizeof(int),
pool);
core_red_black_tree_use_uint64_t_keys(&self->timeline);
#elif defined(THORIUM_MULTIPLEXER_USE_HEAP)
core_binary_heap_init(&self->timeline, sizeof(uint64_t), sizeof(int),
CORE_BINARY_HEAP_MIN | CORE_BINARY_HEAP_UINT64_T_KEYS);
core_binary_heap_set_memory_pool(&self->timeline, pool);
#elif defined(THORIUM_MULTIPLEXER_USE_QUEUE)
core_queue_init(&self->timeline, sizeof(int));
#endif
if (thorium_node_name(self->node) == 0 && thorium_worker_name(self->worker) == 0
&& thorium_node_must_print_data(self->node)) {
thorium_printf("[thorium] message_multiplexer: disabled=%d buffer_size_in_bytes=%d timeout_in_nanoseconds=%d\n",
CORE_BITMAP_GET_FLAG(self->flags, FLAG_DISABLED),
self->buffer_size_in_bytes, self->timeout_in_nanoseconds);
}
}
/*
* \see http://www.mpich.org/static/docs/v3.1/www3/MPI_Comm_dup.html
* \see http://www.dartmouth.edu/~rc/classes/intro_mpi/hello_world_ex.html
* \see https://github.com/GeneAssembly/kiki/blob/master/ki.c#L960
* \see http://mpi.deino.net/mpi_functions/MPI_Comm_create.html
*/
void thorium_mpi1_pt2pt_transport_init(struct thorium_transport *self, int *argc, char ***argv)
{
int required;
struct thorium_mpi1_pt2pt_transport *concrete_self;
int result;
int provided;
concrete_self = thorium_transport_get_concrete_transport(self);
core_queue_init(&concrete_self->active_requests, sizeof(struct thorium_mpi1_pt2pt_active_request));
/*
required = MPI_THREAD_MULTIPLE;
*/
required = MPI_THREAD_FUNNELED;
result = MPI_Init_thread(argc, argv, required, &provided);
if (result != MPI_SUCCESS) {
return;
}
/*
* Set the provided level of thread support
*/
if (provided == MPI_THREAD_SINGLE) {
self->provided = THORIUM_THREAD_SINGLE;
} else if (provided == MPI_THREAD_FUNNELED) {
self->provided = THORIUM_THREAD_FUNNELED;
} else if (provided == MPI_THREAD_SERIALIZED) {
self->provided = THORIUM_THREAD_SERIALIZED;
} else if (provided == MPI_THREAD_MULTIPLE) {
self->provided = THORIUM_THREAD_MULTIPLE;
}
/* make a new communicator for the library and don't use MPI_COMM_WORLD later */
result = MPI_Comm_dup(MPI_COMM_WORLD, &concrete_self->comm);
if (result != MPI_SUCCESS) {
return;
}
result = MPI_Comm_rank(concrete_self->comm, &self->rank);
if (result != MPI_SUCCESS) {
return;
}
result = MPI_Comm_size(concrete_self->comm, &self->size);
if (result != MPI_SUCCESS) {
return;
}
concrete_self->datatype = MPI_BYTE;
}
void biosal_sequence_partitioner_init(struct thorium_actor *actor)
{
struct biosal_sequence_partitioner *concrete_actor;
concrete_actor = (struct biosal_sequence_partitioner *)thorium_actor_concrete_actor(actor);
core_vector_init(&concrete_actor->stream_entries, sizeof(uint64_t));
core_vector_init(&concrete_actor->stream_positions, sizeof(uint64_t));
core_vector_init(&concrete_actor->stream_global_positions, sizeof(uint64_t));
core_vector_init(&concrete_actor->store_entries, sizeof(uint64_t));
core_queue_init(&concrete_actor->available_commands, sizeof(struct biosal_partition_command));
core_map_init(&concrete_actor->active_commands, sizeof(int),
sizeof(struct biosal_partition_command));
concrete_actor->store_count = -1;
concrete_actor->block_size = -1;
concrete_actor->command_number = 0;
concrete_actor->last_progress = -1;
}
void biosal_input_controller_init(struct thorium_actor *actor)
{
struct biosal_input_controller *concrete_actor;
concrete_actor = (struct biosal_input_controller *)thorium_actor_concrete_actor(actor);
core_map_init(&concrete_actor->mega_blocks, sizeof(int), sizeof(struct core_vector));
core_map_init(&concrete_actor->assigned_blocks, sizeof(int), sizeof(int));
core_vector_init(&concrete_actor->mega_block_vector, sizeof(struct biosal_mega_block));
core_vector_init(&concrete_actor->counting_streams, sizeof(int));
core_vector_init(&concrete_actor->reading_streams, sizeof(int));
core_vector_init(&concrete_actor->partition_commands, sizeof(int));
core_vector_init(&concrete_actor->stream_consumers, sizeof(int));
core_vector_init(&concrete_actor->consumer_active_requests, sizeof(int));
core_vector_init(&concrete_actor->files, sizeof(char *));
core_vector_init(&concrete_actor->spawners, sizeof(int));
core_vector_init(&concrete_actor->counts, sizeof(int64_t));
core_vector_init(&concrete_actor->consumers, sizeof(int));
core_vector_init(&concrete_actor->stores_per_spawner, sizeof(int));
core_timer_init(&concrete_actor->input_timer);
core_timer_init(&concrete_actor->counting_timer);
core_timer_init(&concrete_actor->distribution_timer);
biosal_dna_codec_init(&concrete_actor->codec);
if (biosal_dna_codec_must_use_two_bit_encoding(&concrete_actor->codec,
thorium_actor_get_node_count(actor))) {
biosal_dna_codec_enable_two_bit_encoding(&concrete_actor->codec);
}
core_queue_init(&concrete_actor->unprepared_spawners, sizeof(int));
concrete_actor->opened_streams = 0;
concrete_actor->state = BIOSAL_INPUT_CONTROLLER_STATE_NONE;
#ifdef BIOSAL_INPUT_CONTROLLER_DEBUG_10355
printf("DEBUG actor %d register ACTION_INPUT_CONTROLLER_CREATE_STORES\n",
thorium_actor_name(actor));
#endif
thorium_actor_add_action(actor, ACTION_INPUT_CONTROLLER_CREATE_STORES,
biosal_input_controller_create_stores);
thorium_actor_add_action(actor, ACTION_GET_NODE_NAME_REPLY,
biosal_input_controller_get_node_name_reply);
thorium_actor_add_action(actor, ACTION_GET_NODE_WORKER_COUNT_REPLY,
biosal_input_controller_get_node_worker_count_reply);
thorium_actor_add_action(actor, ACTION_INPUT_CONTROLLER_PREPARE_SPAWNERS,
biosal_input_controller_prepare_spawners);
thorium_actor_add_action(actor, ACTION_INPUT_CONTROLLER_SPAWN_READING_STREAMS,
biosal_input_controller_spawn_streams);
thorium_actor_add_action(actor, ACTION_INPUT_STREAM_SET_START_OFFSET_REPLY,
biosal_input_controller_set_offset_reply);
thorium_actor_add_script(actor, SCRIPT_INPUT_STREAM, &biosal_input_stream_script);
thorium_actor_add_script(actor, SCRIPT_SEQUENCE_STORE, &biosal_sequence_store_script);
thorium_actor_add_script(actor, SCRIPT_SEQUENCE_PARTITIONER,
&biosal_sequence_partitioner_script);
/* configuration for the input controller
* other values for block size: 512, 1024, 2048, 4096, 8192 * /
*/
concrete_actor->block_size = 4096;
concrete_actor->stores_per_worker_per_spawner = 0;
#ifdef BIOSAL_INPUT_CONTROLLER_DEBUG
printf("DEBUG %d init controller\n",
thorium_actor_name(actor));
#endif
concrete_actor->ready_spawners = 0;
concrete_actor->ready_consumers = 0;
concrete_actor->partitioner = THORIUM_ACTOR_NOBODY;
concrete_actor->filled_consumers = 0;
concrete_actor->counted = 0;
}
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;
}
