void thorium_actor_send_int(struct thorium_actor *actor, int destination, int tag, int value)
{
struct thorium_message message;
void *buffer;
int count;
count = sizeof(value);
buffer = thorium_actor_allocate(actor, count);
core_memory_copy(buffer, &value, count);
thorium_message_init(&message, tag, count, buffer);
thorium_actor_send(actor, destination, &message);
thorium_message_destroy(&message);
}
void thorium_actor_send_empty(struct thorium_actor *actor, int destination, int tag)
{
struct thorium_message message;
#if 0
void *buffer;
/*
* Allocate a buffer for metadata.
*/
buffer = thorium_actor_allocate(actor, 0);
#endif
thorium_message_init(&message, tag, 0, NULL);
thorium_actor_send(actor, destination, &message);
thorium_message_destroy(&message);
}
void thorium_actor_send_then_int(struct thorium_actor *actor, int destination, int action, int value,
thorium_actor_receive_fn_t handler)
{
struct thorium_message message;
int count;
int offset;
count = sizeof(value);
void *buffer = thorium_actor_allocate(actor, count);
core_memory_copy(buffer, &value, sizeof(value));
thorium_message_init(&message, action, count, buffer);
thorium_actor_send_then(actor, destination, &message, handler);
thorium_message_destroy(&message);
}
void thorium_actor_send_vector(struct thorium_actor *actor, int destination,
int tag, struct core_vector *vector)
{
int count;
struct thorium_message message;
void *buffer;
count = core_vector_pack_size(vector);
buffer = thorium_actor_allocate(actor, count);
core_vector_pack(vector, buffer);
thorium_message_init(&message, tag, count, buffer);
thorium_actor_send(actor, destination, &message);
thorium_message_destroy(&message);
}
void process_send_ping(struct thorium_actor *self)
{
struct process *concrete_self;
int destination;
int size;
int index;
int buffer_size;
int range;
uint64_t checksum;
int count;
char *buffer;
int i;
uint64_t *bucket;
concrete_self = thorium_actor_concrete_actor(self);
range = concrete_self->maximum_buffer_size - concrete_self->minimum_buffer_size;
buffer_size = rand() % range;
buffer_size += concrete_self->minimum_buffer_size;
count = buffer_size + sizeof(checksum);
buffer = thorium_actor_allocate(self, count);
/*
* Generate content;
*/
for (i = 0; i < buffer_size; ++i) {
buffer[i] = i % 256;
}
checksum = core_hash_data_uint64_t(buffer, buffer_size, SEED);
bucket = (uint64_t *)(buffer + buffer_size);
*bucket = checksum;
size = core_vector_size(&concrete_self->actors);
index = rand() % size;
destination = core_vector_at_as_int(&concrete_self->actors, index);
thorium_actor_send_buffer(self, destination, ACTION_PING, count, buffer);
++concrete_self->active_messages;
}
void thorium_actor_send_2_int(struct thorium_actor *actor, int destination, int action, int value1, int value2)
{
struct thorium_message message;
char *buffer;
int count;
int offset;
count = sizeof(value1) + sizeof(value2);
buffer = thorium_actor_allocate(actor, count);
offset = 0;
core_memory_copy(buffer + offset, &value1, sizeof(value1));
offset += sizeof(value1);
core_memory_copy(buffer + offset, &value2, sizeof(value2));
offset += sizeof(value2);
thorium_message_init(&message, action, count, buffer);
thorium_actor_send(actor, destination, &message);
thorium_message_destroy(&message);
}
void biosal_input_controller_receive(struct thorium_actor *actor, struct thorium_message *message)
{
int tag;
int count;
char *file;
void *buffer;
struct biosal_input_controller *controller;
struct biosal_input_controller *concrete_actor;
int destination;
int script;
int stream;
char *local_file;
int i;
int name;
int source;
int destination_index;
struct thorium_message new_message;
int error;
int stream_index;
int64_t entries;
int64_t *bucket;
int *int_bucket;
int spawner;
int command_name;
int stream_name;
int consumer;
int consumer_index;
int *bucket_for_requests;
char *new_buffer;
int new_count;
int file_index;
struct core_vector mega_blocks;
struct core_vector_iterator vector_iterator;
struct biosal_mega_block *mega_block;
struct core_vector *vector_bucket;
struct core_vector block_counts;
uint64_t block_entries;
int mega_block_index;
uint64_t offset;
struct biosal_mega_block *block;
int acquaintance_index;
if (thorium_actor_take_action(actor, message)) {
return;
}
thorium_message_get_all(message, &tag, &count, &buffer, &source);
name = thorium_actor_name(actor);
controller = (struct biosal_input_controller *)thorium_actor_concrete_actor(actor);
concrete_actor = controller;
if (tag == ACTION_START) {
core_vector_init(&concrete_actor->spawners, 0);
core_vector_unpack(&concrete_actor->spawners, buffer);
core_vector_resize(&concrete_actor->stores_per_spawner,
core_vector_size(&concrete_actor->spawners));
for (i = 0; i < core_vector_size(&concrete_actor->spawners); i++) {
int_bucket = (int *)core_vector_at(&concrete_actor->stores_per_spawner, i);
*int_bucket = 0;
spawner = core_vector_at_as_int(&concrete_actor->spawners, i);
core_queue_enqueue(&concrete_actor->unprepared_spawners, &spawner);
}
concrete_actor->state = BIOSAL_INPUT_CONTROLLER_STATE_PREPARE_SPAWNERS;
#ifdef BIOSAL_INPUT_CONTROLLER_DEBUG_LEVEL
printf("DEBUG preparing first spawner\n");
#endif
thorium_actor_send_to_self_empty(actor, ACTION_INPUT_CONTROLLER_PREPARE_SPAWNERS);
/*
thorium_dispatcher_print(thorium_actor_dispatcher(actor));
*/
} else if (tag == ACTION_ADD_FILE) {
file = (char *)buffer;
local_file = core_memory_allocate(strlen(file) + 1, MEMORY_CONTROLLER);
strcpy(local_file, file);
printf("controller %d ACTION_ADD_FILE %s\n",
thorium_actor_name(actor),
local_file);
core_vector_push_back(&concrete_actor->files, &local_file);
bucket = core_vector_at(&concrete_actor->files, core_vector_size(&concrete_actor->files) - 1);
local_file = *(char **)bucket;
#ifdef BIOSAL_INPUT_CONTROLLER_DEBUG_LEVEL_2
printf("DEBUG11 ACTION_ADD_FILE %s %p bucket %p index %d\n",
local_file, local_file, (void *)bucket, core_vector_size(&concrete_actor->files) - 1);
#endif
thorium_actor_send_reply_empty(actor, ACTION_ADD_FILE_REPLY);
} else if (tag == ACTION_SPAWN_REPLY) {
if (concrete_actor->state == BIOSAL_INPUT_CONTROLLER_STATE_SPAWN_STORES) {
biosal_input_controller_add_store(actor, message);
return;
} else if (concrete_actor->state == BIOSAL_INPUT_CONTROLLER_STATE_PREPARE_SPAWNERS) {
concrete_actor->ready_spawners++;
thorium_message_unpack_int(message, 0, &name);
thorium_actor_send_empty(actor, name, ACTION_ASK_TO_STOP);
thorium_actor_send_to_self_empty(actor, ACTION_INPUT_CONTROLLER_PREPARE_SPAWNERS);
if (concrete_actor->ready_spawners == (int)core_vector_size(&concrete_actor->spawners)) {
#ifdef BIOSAL_INPUT_CONTROLLER_DEBUG
printf("DEBUG all spawners are prepared\n");
#endif
thorium_actor_send_to_supervisor_empty(actor, ACTION_START_REPLY);
}
return;
} else if (concrete_actor->state == BIOSAL_INPUT_CONTROLLER_STATE_SPAWN_PARTITIONER) {
#ifdef BIOSAL_INPUT_CONTROLLER_DEBUG
printf("DEBUG received spawn reply, state is spawn_partitioner\n");
#endif
thorium_message_unpack_int(message, 0, &concrete_actor->partitioner);
/* configure the partitioner
*/
destination = concrete_actor->partitioner;
thorium_actor_send_int(actor, destination,
ACTION_SEQUENCE_PARTITIONER_SET_BLOCK_SIZE,
concrete_actor->block_size);
thorium_actor_send_int(actor, destination,
ACTION_SEQUENCE_PARTITIONER_SET_ACTOR_COUNT,
core_vector_size(&concrete_actor->consumers));
core_vector_init(&block_counts, sizeof(uint64_t));
for (i = 0; i < core_vector_size(&concrete_actor->mega_block_vector); i++) {
block = (struct biosal_mega_block *)core_vector_at(&concrete_actor->mega_block_vector, i);
block_entries = biosal_mega_block_get_entries(block);
core_vector_push_back_uint64_t(&block_counts, block_entries);
}
new_count = core_vector_pack_size(&block_counts);
new_buffer = thorium_actor_allocate(actor, new_count);
#ifdef BIOSAL_INPUT_CONTROLLER_DEBUG
printf("DEBUG packed counts, %d bytes\n", count);
#endif
core_vector_pack(&block_counts, new_buffer);
thorium_message_init(&new_message, ACTION_SEQUENCE_PARTITIONER_SET_ENTRY_VECTOR,
new_count, new_buffer);
thorium_actor_send(actor, destination, &new_message);
core_vector_destroy(&block_counts);
return;
} else if (concrete_actor->state == BIOSAL_INPUT_CONTROLLER_STATE_SPAWN_READING_STREAMS) {
thorium_message_unpack_int(message, 0, &stream);
stream_index = stream;
mega_block_index = core_vector_size(&concrete_actor->reading_streams);
core_vector_push_back_int(&concrete_actor->reading_streams, stream_index);
core_vector_push_back_int(&concrete_actor->partition_commands, -1);
core_vector_push_back_int(&concrete_actor->stream_consumers, -1);
stream_index = core_vector_size(&concrete_actor->reading_streams) - 1;
mega_block = (struct biosal_mega_block *)core_vector_at(&concrete_actor->mega_block_vector,
mega_block_index);
offset = biosal_mega_block_get_offset(mega_block);
core_map_add_value(&concrete_actor->assigned_blocks,
&stream_index, &mega_block_index);
#ifdef BIOSAL_INPUT_CONTROLLER_DEBUG_READING_STREAMS
printf("DEBUG setting offset to %" PRIu64 " for stream/%d\n",
offset, stream);
#endif
thorium_actor_send_uint64_t(actor, stream, ACTION_INPUT_STREAM_SET_START_OFFSET, offset);
return;
}
stream = *(int *)buffer;
file_index = core_vector_size(&concrete_actor->counting_streams);
local_file = *(char **)core_vector_at(&concrete_actor->files, file_index);
#ifdef BIOSAL_INPUT_CONTROLLER_DEBUG_READING_STREAMS
printf("DEBUG actor %d receives stream %d from spawner %d for file %s\n",
name, stream, source,
local_file);
#endif
core_vector_push_back(&concrete_actor->counting_streams, &stream);
#ifdef BIOSAL_INPUT_CONTROLLER_DEBUG_READING_STREAMS
printf("asking stream/%d to open %s\n", stream, local_file);
#endif
thorium_message_init(&new_message, ACTION_INPUT_OPEN, strlen(local_file) + 1, local_file);
#ifdef DEBUG_ISSUE_594
thorium_message_print(&new_message);
printf("SEND Buffer %s\n", local_file);
#endif
thorium_actor_send(actor, stream, &new_message);
thorium_message_destroy(&new_message);
if (core_vector_size(&concrete_actor->counting_streams) != core_vector_size(&concrete_actor->files)) {
thorium_actor_send_to_self_empty(actor, ACTION_INPUT_SPAWN);
}
#ifdef DEBUG_ISSUE_594
printf("EXIT Buffer %s\n", local_file);
#endif
} else if (tag == ACTION_INPUT_OPEN_REPLY) {
if (concrete_actor->state == BIOSAL_INPUT_CONTROLLER_STATE_SPAWN_READING_STREAMS) {
#ifdef BIOSAL_INPUT_CONTROLLER_DEBUG_READING_STREAMS
printf("DEBUG receives open.reply for reading stream/%d\n", source);
#endif
concrete_actor->opened_streams++;
if (concrete_actor->opened_streams == core_vector_size(&concrete_actor->mega_block_vector)) {
thorium_actor_send_to_self_empty(actor, ACTION_INPUT_CONTROLLER_CREATE_STORES);
}
return;
}
concrete_actor->opened_streams++;
stream = source;
thorium_message_unpack_int(message, 0, &error);
if (error == BIOSAL_INPUT_ERROR_NO_ERROR) {
#ifdef BIOSAL_INPUT_CONTROLLER_DEBUG_LEVEL_2
printf("DEBUG actor %d asks %d ACTION_INPUT_COUNT_IN_PARALLEL\n", name, stream);
#endif
thorium_actor_send_vector(actor, stream, ACTION_INPUT_COUNT_IN_PARALLEL,
&concrete_actor->spawners);
} else {
#ifdef BIOSAL_INPUT_CONTROLLER_DEBUG_LEVEL_2
printf("DEBUG actor %d received error %d from %d\n", name, error, stream);
#endif
concrete_actor->counted++;
}
/* if all streams failed, notice supervisor */
if (concrete_actor->counted == core_vector_size(&concrete_actor->files)) {
#ifdef BIOSAL_INPUT_CONTROLLER_DEBUG_LEVEL_2
#endif
printf("DEBUG %d: Error all streams failed.\n",
thorium_actor_name(actor));
thorium_actor_send_to_supervisor_empty(actor, ACTION_INPUT_DISTRIBUTE_REPLY);
}
/*
if (concrete_actor->opened_streams == core_vector_size(&concrete_actor->files)) {
#ifdef BIOSAL_INPUT_CONTROLLER_DEBUG
printf("DEBUG controller %d sends ACTION_INPUT_DISTRIBUTE_REPLY to supervisor %d [%d/%d]\n",
name, thorium_actor_supervisor(actor),
concrete_actor->opened_streams, core_vector_size(&concrete_actor->files));
#endif
}
*/
} else if (tag == ACTION_INPUT_COUNT_PROGRESS) {
stream_index = core_vector_index_of(&concrete_actor->counting_streams, &source);
local_file = core_vector_at_as_char_pointer(&concrete_actor->files, stream_index);
thorium_message_unpack_int64_t(message, 0, &entries);
bucket = (int64_t *)core_vector_at(&concrete_actor->counts, stream_index);
printf("controller/%d receives progress from stream/%d file %s %" PRIu64 " entries so far\n",
name, source, local_file, entries);
*bucket = entries;
} else if (tag == ACTION_INPUT_COUNT_IN_PARALLEL_REPLY) {
stream_index = core_vector_index_of(&concrete_actor->counting_streams, &source);
local_file = core_vector_at_as_char_pointer(&concrete_actor->files, stream_index);
core_vector_init(&mega_blocks, 0);
core_vector_unpack(&mega_blocks, buffer);
printf("DEBUG receive mega blocks from %d\n", source);
/*
* Update the file index for every mega block.
*/
core_vector_iterator_init(&vector_iterator, &mega_blocks);
bucket = (int64_t*)core_vector_at(&concrete_actor->counts, stream_index);
(*bucket) = 0;
while (core_vector_iterator_has_next(&vector_iterator)) {
core_vector_iterator_next(&vector_iterator, (void **)&mega_block);
printf("SETTING setting file to %d for mega block\n", stream_index);
biosal_mega_block_set_file(mega_block, stream_index);
entries = biosal_mega_block_get_entries_from_start(mega_block);
printf("Cataloging %d ENTRIES\n", (int)entries);
(*bucket) = entries;
biosal_mega_block_print(mega_block);
}
core_vector_iterator_destroy(&vector_iterator);
vector_bucket = (struct core_vector *)core_map_add(&concrete_actor->mega_blocks, &stream_index);
core_vector_init_copy(vector_bucket, &mega_blocks);
core_vector_destroy(&mega_blocks);
concrete_actor->counted++;
printf("controller/%d received from stream/%d for file %s %" PRIu64 " entries (final) %d/%d\n",
name, source, local_file, entries,
concrete_actor->counted, (int)core_vector_size(&concrete_actor->files));
thorium_actor_send_reply_empty(actor, ACTION_INPUT_CLOSE);
/* continue work here, tell supervisor about it */
if (concrete_actor->counted == core_vector_size(&concrete_actor->files)) {
thorium_actor_send_to_self_empty(actor, ACTION_INPUT_CONTROLLER_SPAWN_READING_STREAMS);
}
} else if (tag == ACTION_INPUT_DISTRIBUTE) {
core_timer_start(&concrete_actor->input_timer);
core_timer_start(&concrete_actor->counting_timer);
/* for each file, spawn a stream to count */
/* no files, return immediately
*/
if (core_vector_size(&concrete_actor->files) == 0) {
printf("Error: no file to distribute...\n");
thorium_actor_send_reply_empty(actor, ACTION_INPUT_DISTRIBUTE_REPLY);
return;
}
#ifdef BIOSAL_INPUT_CONTROLLER_DEBUG_LEVEL_2
printf("DEBUG actor %d receives ACTION_INPUT_DISTRIBUTE\n", name);
#endif
#ifdef BIOSAL_INPUT_CONTROLLER_DEBUG_LEVEL_2
printf("DEBUG send ACTION_INPUT_SPAWN to self\n");
#endif
thorium_actor_send_to_self_empty(actor, ACTION_INPUT_SPAWN);
#ifdef BIOSAL_INPUT_CONTROLLER_DEBUG_LEVEL_2
printf("DEBUG resizing counts to %d\n", core_vector_size(&concrete_actor->files));
#endif
core_vector_resize(&concrete_actor->counts, core_vector_size(&concrete_actor->files));
for (i = 0; i < core_vector_size(&concrete_actor->counts); i++) {
bucket = (int64_t*)core_vector_at(&concrete_actor->counts, i);
*bucket = 0;
}
} else if (tag == ACTION_INPUT_SPAWN && source == name) {
#ifdef BIOSAL_INPUT_CONTROLLER_DEBUG_LEVEL_2
printf("DEBUG ACTION_INPUT_SPAWN\n");
#endif
script = SCRIPT_INPUT_STREAM;
concrete_actor->state = BIOSAL_INPUT_CONTROLLER_STATE_SPAWN_STREAMS;
/* the next file name to send is the current number of streams */
i = core_vector_size(&concrete_actor->counting_streams);
destination_index = i % core_vector_size(&concrete_actor->spawners);
destination = *(int *)core_vector_at(&concrete_actor->spawners, destination_index);
thorium_message_init(message, ACTION_SPAWN, sizeof(script), &script);
thorium_actor_send(actor, destination, message);
bucket = core_vector_at(&concrete_actor->files, i);
local_file = *(char **)core_vector_at(&concrete_actor->files, i);
#ifdef BIOSAL_INPUT_CONTROLLER_DEBUG_LEVEL_2
printf("DEBUG890 local_file %p bucket %p index %d\n", local_file, (void *)bucket,
i);
#endif
#ifdef BIOSAL_INPUT_CONTROLLER_DEBUG
printf("DEBUG actor %d spawns a stream for file %d/%d via spawner %d\n",
name, i, core_vector_size(&concrete_actor->files), destination);
#endif
/* also, spawn 4 stores on each node */
} else if (tag == ACTION_ASK_TO_STOP && ( source == thorium_actor_supervisor(actor)
|| source == thorium_actor_name(actor))) {
#ifdef BIOSAL_INPUT_CONTROLLER_DEBUG_LEVEL_2
#endif
/* stop streams
*/
for (i = 0; i < core_vector_size(&concrete_actor->counting_streams); i++) {
stream = *(int *)core_vector_at(&concrete_actor->counting_streams, i);
thorium_actor_send_empty(actor, stream, ACTION_ASK_TO_STOP);
}
for (i = 0; i < core_vector_size(&concrete_actor->reading_streams); i++) {
stream = *(int *)core_vector_at(&concrete_actor->reading_streams, i);
thorium_actor_send_empty(actor, stream, ACTION_ASK_TO_STOP);
}
#if 0
/* stop data stores
*/
for (i = 0; i < core_vector_size(&concrete_actor->consumers); i++) {
store = core_vector_at_as_int(&concrete_actor->consumers, i);
thorium_actor_send_empty(actor, store, ACTION_ASK_TO_STOP);
}
#endif
/* stop partitioner
*/
if (concrete_actor->partitioner != THORIUM_ACTOR_NOBODY) {
thorium_actor_send_empty(actor,
concrete_actor->partitioner,
ACTION_ASK_TO_STOP);
#ifdef BIOSAL_INPUT_CONTROLLER_DEBUG
printf("DEBUG controller %d sends ACTION_ASK_TO_STOP_REPLY to %d\n",
thorium_actor_name(actor),
thorium_message_source(message));
#endif
}
thorium_actor_send_reply_empty(actor, ACTION_ASK_TO_STOP_REPLY);
/* stop self
*/
thorium_actor_send_to_self_empty(actor, ACTION_STOP);
thorium_actor_ask_to_stop(actor, message);
printf("DEBUG controller %d dies\n", name);
#ifdef BIOSAL_INPUT_CONTROLLER_DEBUG
#endif
} else if (tag == ACTION_INPUT_CONTROLLER_CREATE_PARTITION && source == name) {
spawner = *(int *)core_vector_at(&concrete_actor->spawners,
core_vector_size(&concrete_actor->spawners) / 2);
thorium_actor_send_int(actor, spawner, ACTION_SPAWN,
SCRIPT_SEQUENCE_PARTITIONER);
concrete_actor->state = BIOSAL_INPUT_CONTROLLER_STATE_SPAWN_PARTITIONER;
#ifdef BIOSAL_INPUT_CONTROLLER_DEBUG
printf("DEBUG input controller %d spawns a partitioner via spawner %d\n",
name, spawner);
#endif
} else if (tag == ACTION_SEQUENCE_PARTITIONER_COMMAND_IS_READY) {
#ifdef BIOSAL_INPUT_CONTROLLER_DEBUG
printf("DEBUG controller receives ACTION_SEQUENCE_PARTITIONER_COMMAND_IS_READY, asks for command\n");
#endif
thorium_actor_send_reply_empty(actor, ACTION_SEQUENCE_PARTITIONER_GET_COMMAND);
} else if (tag == ACTION_SEQUENCE_PARTITIONER_GET_COMMAND_REPLY) {
biosal_input_controller_receive_command(actor, message);
} else if (tag == ACTION_SEQUENCE_PARTITIONER_FINISHED) {
thorium_actor_send_empty(actor,
concrete_actor->partitioner,
ACTION_ASK_TO_STOP);
biosal_input_controller_verify_requests(actor, message);
} else if (tag == ACTION_SEQUENCE_PARTITIONER_PROVIDE_STORE_ENTRY_COUNTS) {
biosal_input_controller_receive_store_entry_counts(actor, message);
} else if (tag == ACTION_RESERVE_REPLY) {
concrete_actor->ready_consumers++;
printf("DEBUG marker ACTION_RESERVE_REPLY %d/%d\n",
concrete_actor->ready_consumers,
(int)core_vector_size(&concrete_actor->consumers));
if (concrete_actor->ready_consumers == core_vector_size(&concrete_actor->consumers)) {
concrete_actor->ready_consumers = 0;
printf("DEBUG all consumers are ready\n");
thorium_actor_send_empty(actor,
concrete_actor->partitioner,
ACTION_SEQUENCE_PARTITIONER_PROVIDE_STORE_ENTRY_COUNTS_REPLY);
}
} else if (tag == ACTION_INPUT_PUSH_SEQUENCES_READY) {
#ifdef BIOSAL_INPUT_CONTROLLER_DEBUG
printf("DEBUG biosal_input_controller_receive received ACTION_INPUT_PUSH_SEQUENCES_READY\n");
#endif
stream_name = source;
acquaintance_index = stream_name;
stream_index = core_vector_index_of(&concrete_actor->reading_streams, &acquaintance_index);
command_name = *(int *)core_vector_at(&concrete_actor->partition_commands,
stream_index);
thorium_actor_send_int(actor,
concrete_actor->partitioner,
ACTION_SEQUENCE_PARTITIONER_GET_COMMAND_REPLY_REPLY,
command_name);
} else if (tag == ACTION_INPUT_PUSH_SEQUENCES_REPLY) {
stream_name = source;
thorium_message_unpack_int(message, 0, &consumer);
consumer_index = core_vector_index_of(&concrete_actor->consumers,
&consumer);
bucket_for_requests = (int *)core_vector_at(&concrete_actor->consumer_active_requests, consumer_index);
(*bucket_for_requests)--;
biosal_input_controller_verify_requests(actor, message);
#ifdef BIOSAL_INPUT_CONTROLLER_DEBUG_CONSUMERS
printf("DEBUG consumer # %d has %d active requests\n",
consumer_index, *bucket_for_requests);
#endif
} else if (tag == ACTION_SET_CONSUMERS) {
core_vector_init(&concrete_actor->consumers, 0);
core_vector_unpack(&concrete_actor->consumers, buffer);
printf("controller %d receives %d consumers\n",
thorium_actor_name(actor),
(int)core_vector_size(&concrete_actor->consumers));
for (i = 0; i < core_vector_size(&concrete_actor->consumers); i++) {
core_vector_push_back_int(&concrete_actor->consumer_active_requests, 0);
}
#ifdef BIOSAL_INPUT_CONTROLLER_DEBUG
core_vector_print_int(&concrete_actor->consumers);
printf("\n");
#endif
thorium_actor_send_reply_empty(actor, ACTION_SET_CONSUMERS_REPLY);
} else if (tag == ACTION_SET_BLOCK_SIZE) {
thorium_message_unpack_int(message, 0, &concrete_actor->block_size);
thorium_actor_send_reply_empty(actor, ACTION_SET_BLOCK_SIZE_REPLY);
} else if (tag == ACTION_SEQUENCE_STORE_READY) {
concrete_actor->filled_consumers++;
#ifdef BIOSAL_INPUT_CONTROLLER_DEBUG
printf("DEBUG ACTION_SEQUENCE_STORE_READY %d/%d\n", concrete_actor->filled_consumers,
(int)core_vector_size(&concrete_actor->consumers));
#endif
if (concrete_actor->filled_consumers == core_vector_size(&concrete_actor->consumers)) {
concrete_actor->filled_consumers = 0;
printf("DEBUG: all consumers are filled, sending ACTION_INPUT_DISTRIBUTE_REPLY\n");
core_timer_stop(&concrete_actor->input_timer);
core_timer_stop(&concrete_actor->distribution_timer);
core_timer_print_with_description(&concrete_actor->distribution_timer,
"Load input / Distribute input data");
core_timer_print_with_description(&concrete_actor->input_timer,
"Load input");
thorium_actor_send_to_supervisor_empty(actor, ACTION_INPUT_DISTRIBUTE_REPLY);
}
}
}
void biosal_input_controller_receive_command(struct thorium_actor *actor, struct thorium_message *message)
{
struct biosal_partition_command command;
void *buffer;
int stream_index;
int store_index;
int store_name;
uint64_t store_first;
uint64_t store_last;
int command_name;
int stream_name;
int *bucket_for_command_name;
int bytes;
struct biosal_input_command input_command;
void *new_buffer;
struct thorium_message new_message;
struct biosal_input_controller *concrete_actor;
int *bucket;
int *bucket_for_consumer;
int consumer_index;
concrete_actor = (struct biosal_input_controller *)thorium_actor_concrete_actor(actor);
buffer = thorium_message_buffer(message);
biosal_partition_command_unpack(&command, buffer);
stream_index = biosal_partition_command_stream_index(&command);
#ifdef BIOSAL_INPUT_CONTROLLER_DEBUG_COMMANDS
printf("DEBUG biosal_input_controller_receive_command controller receives command for stream %d\n", stream_index);
biosal_partition_command_print(&command);
#endif
store_index = biosal_partition_command_store_index(&command);
bucket_for_command_name = (int *)core_vector_at(&concrete_actor->partition_commands,
stream_index);
bucket_for_consumer = (int *)core_vector_at(&concrete_actor->stream_consumers,
stream_index);
stream_name = core_vector_at_as_int(&concrete_actor->reading_streams,
stream_index);
#ifdef BIOSAL_INPUT_CONTROLLER_DEBUG_COMMANDS
printf("DEBUG stream_index %d stream_name %d\n", stream_index, stream_name);
#endif
store_name = *(int *)core_vector_at(&concrete_actor->consumers, store_index);
store_first = biosal_partition_command_store_first(&command);
store_last = biosal_partition_command_store_last(&command);
biosal_input_command_init(&input_command, store_name, store_first, store_last);
bytes = biosal_input_command_pack_size(&input_command,
&concrete_actor->codec);
#ifdef BIOSAL_INPUT_CONTROLLER_DEBUG_COMMANDS
printf("DEBUG input command\n");
biosal_input_command_print(&input_command);
printf("DEBUG biosal_input_controller_receive_command bytes %d\n",
bytes);
#endif
new_buffer = thorium_actor_allocate(actor, bytes);
biosal_input_command_pack(&input_command, new_buffer,
&concrete_actor->codec);
thorium_message_init(&new_message, ACTION_INPUT_PUSH_SEQUENCES, bytes,
new_buffer);
#ifdef BIOSAL_INPUT_CONTROLLER_DEBUG_COMMANDS
printf("DEBUG biosal_input_controller_receive_command sending ACTION_INPUT_PUSH_SEQUENCES to %d (index %d)\n",
stream_name, stream_index);
biosal_input_command_print(&input_command);
printf("SENDING COMMAND TO stream/%d\n", stream_name);
#endif
thorium_actor_send(actor, stream_name, &new_message);
command_name = biosal_partition_command_name(&command);
#ifdef BIOSAL_INPUT_CONTROLLER_DEBUG_COMMANDS
printf("controller/%d processed input command %d %p\n", thorium_actor_name(actor), command_name,
(void *)bucket_for_command_name);
#endif
*bucket_for_command_name = command_name;
consumer_index = store_index;
*bucket_for_consumer = consumer_index;
bucket = (int *)core_vector_at(&concrete_actor->consumer_active_requests, consumer_index);
(*bucket)++;
#ifdef BIOSAL_INPUT_CONTROLLER_DEBUG_CONSUMERS
printf("DEBUG consumer # %d has %d active requests\n",
consumer_index, *bucket);
#endif
}
void biosal_assembly_arc_classifier_push_arc_block(struct thorium_actor *self, struct thorium_message *message)
{
struct biosal_assembly_arc_classifier *concrete_self;
int source;
struct biosal_assembly_arc_block input_block;
struct biosal_assembly_arc_block *output_block;
struct core_vector output_blocks;
struct core_memory_pool *ephemeral_memory;
int consumer_count;
struct core_vector *input_arcs;
struct core_vector *output_arcs;
int size;
int i;
struct biosal_assembly_arc *arc;
void *buffer;
int count;
struct biosal_dna_kmer *kmer;
int consumer_index;
int arc_count;
int consumer;
struct thorium_message new_message;
int new_count;
void *new_buffer;
int *bucket;
int maximum_pending_requests;
int maximum_buffer_length;
int reservation;
count = thorium_message_count(message);
buffer = thorium_message_buffer(message);
if (count == 0) {
printf("Error, count is 0 (classifier_push_arc_block)\n");
return;
}
concrete_self = (struct biosal_assembly_arc_classifier *)thorium_actor_concrete_actor(self);
source = thorium_message_source(message);
consumer_count = core_vector_size(&concrete_self->consumers);
ephemeral_memory = thorium_actor_get_ephemeral_memory(self);
CORE_DEBUGGER_LEAK_DETECTION_BEGIN(ephemeral_memory, classify_arcs);
core_vector_init(&output_blocks, sizeof(struct biosal_assembly_arc_block));
core_vector_set_memory_pool(&output_blocks, ephemeral_memory);
biosal_assembly_arc_block_init(&input_block, ephemeral_memory, concrete_self->kmer_length,
&concrete_self->codec);
#ifdef BIOSAL_ASSEMBLY_ARC_CLASSIFIER_DEBUG
printf("UNPACKING\n");
#endif
biosal_assembly_arc_block_unpack(&input_block, buffer, concrete_self->kmer_length,
&concrete_self->codec, ephemeral_memory);
#ifdef BIOSAL_ASSEMBLY_ARC_CLASSIFIER_DEBUG
printf("OK\n");
#endif
input_arcs = biosal_assembly_arc_block_get_arcs(&input_block);
/*
* Configure the ephemeral memory reservation.
*/
arc_count = core_vector_size(input_arcs);
reservation = (arc_count / consumer_count) * 2;
core_vector_resize(&output_blocks, consumer_count);
CORE_DEBUGGER_ASSERT(!core_memory_pool_has_double_free(ephemeral_memory));
/*
* Initialize output blocks.
* There is one for each destination.
*/
for (i = 0; i < consumer_count; i++) {
output_block = core_vector_at(&output_blocks, i);
biosal_assembly_arc_block_init(output_block, ephemeral_memory, concrete_self->kmer_length,
&concrete_self->codec);
biosal_assembly_arc_block_reserve(output_block, reservation);
}
size = core_vector_size(input_arcs);
/*
* Classify every arc in the input block
* and put them in output blocks.
*/
#ifdef BIOSAL_ASSEMBLY_ARC_CLASSIFIER_DEBUG
printf("ClassifyArcs arc_count= %d\n", size);
#endif
CORE_DEBUGGER_ASSERT(!core_memory_pool_has_double_free(ephemeral_memory));
for (i = 0; i < size; i++) {
arc = core_vector_at(input_arcs, i);
kmer = biosal_assembly_arc_source(arc);
consumer_index = biosal_dna_kmer_store_index(kmer, consumer_count,
concrete_self->kmer_length, &concrete_self->codec,
ephemeral_memory);
output_block = core_vector_at(&output_blocks, consumer_index);
/*
* Make a copy of the arc and copy it.
* It will be freed
*/
biosal_assembly_arc_block_add_arc_copy(output_block, arc,
concrete_self->kmer_length, &concrete_self->codec,
ephemeral_memory);
}
/*
* Input arcs are not needed anymore.
*/
biosal_assembly_arc_block_destroy(&input_block, ephemeral_memory);
CORE_DEBUGGER_ASSERT(!core_memory_pool_has_double_free(ephemeral_memory));
/*
* Finally, send these output blocks to consumers.
*/
maximum_pending_requests = 0;
maximum_buffer_length = 0;
/*
* Figure out the maximum buffer length tor
* messages.
*/
for (i = 0; i < consumer_count; i++) {
output_block = core_vector_at(&output_blocks, i);
new_count = biosal_assembly_arc_block_pack_size(output_block, concrete_self->kmer_length,
&concrete_self->codec);
if (new_count > maximum_buffer_length) {
maximum_buffer_length = new_count;
}
}
#if 0
printf("POOL_BALANCE %d\n",
core_memory_pool_profile_balance_count(ephemeral_memory));
#endif
for (i = 0; i < consumer_count; i++) {
output_block = core_vector_at(&output_blocks, i);
output_arcs = biosal_assembly_arc_block_get_arcs(output_block);
arc_count = core_vector_size(output_arcs);
/*
* Don't send an empty message.
*/
if (arc_count > 0) {
/*
* Allocation is not required because new_count <= maximum_buffer_length
*/
new_count = biosal_assembly_arc_block_pack_size(output_block, concrete_self->kmer_length,
&concrete_self->codec);
new_buffer = thorium_actor_allocate(self, maximum_buffer_length);
CORE_DEBUGGER_ASSERT(new_count <= maximum_buffer_length);
biosal_assembly_arc_block_pack(output_block, new_buffer, concrete_self->kmer_length,
&concrete_self->codec);
thorium_message_init(&new_message, ACTION_ASSEMBLY_PUSH_ARC_BLOCK,
new_count, new_buffer);
consumer = core_vector_at_as_int(&concrete_self->consumers, i);
/*
* Send the message.
*/
thorium_actor_send(self, consumer, &new_message);
thorium_message_destroy(&new_message);
/* update event counters for control.
*/
bucket = core_vector_at(&concrete_self->pending_requests, i);
++(*bucket);
++concrete_self->active_requests;
if (*bucket > maximum_pending_requests) {
maximum_pending_requests = *bucket;
}
if (*bucket > concrete_self->maximum_pending_request_count) {
++concrete_self->consumer_count_above_threshold;
}
}
CORE_DEBUGGER_ASSERT(!core_memory_pool_has_double_free(ephemeral_memory));
#if 0
printf("i = %d\n", i);
#endif
/*
* Destroy output block.
*/
biosal_assembly_arc_block_destroy(output_block,
ephemeral_memory);
CORE_DEBUGGER_LEAK_CHECK_DOUBLE_FREE(ephemeral_memory);
CORE_DEBUGGER_ASSERT(!core_memory_pool_has_double_free(ephemeral_memory));
}
core_vector_destroy(&output_blocks);
CORE_DEBUGGER_ASSERT(!core_memory_pool_has_double_free(ephemeral_memory));
CORE_DEBUGGER_LEAK_CHECK_DOUBLE_FREE(ephemeral_memory);
/*
* Check if a response must be sent now.
*/
++concrete_self->received_blocks;
concrete_self->source = source;
/*
* Only send a direct reply if there is enough memory.
*
* As long as maximum_pending_requests is lower than maximum_pending_request_count,
* there is still space for at least one additional request.
*/
if (maximum_pending_requests < concrete_self->maximum_pending_request_count
&& core_memory_has_enough_bytes()) {
thorium_actor_send_empty(self, concrete_self->source,
ACTION_ASSEMBLY_PUSH_ARC_BLOCK_REPLY);
} else {
concrete_self->producer_is_waiting = 1;
}
CORE_DEBUGGER_LEAK_DETECTION_END(ephemeral_memory, classify_arcs);
}
void biosal_input_stream_push_sequences(struct thorium_actor *actor,
struct thorium_message *message)
{
struct biosal_input_command command;
void *buffer;
int store_name;
uint64_t store_first;
uint64_t store_last;
int sequences_to_read;
void *new_buffer;
int new_count;
struct thorium_message new_message;
void *buffer_for_sequence;
struct biosal_dna_sequence dna_sequence;
/*struct core_vector *command_entries;*/
int has_sequence;
int i;
struct biosal_input_stream *concrete_self;
#ifdef BIOSAL_INPUT_STREAM_DEBUG
int count;
int actual_count;
#endif
/* answer immediately
*/
thorium_actor_send_reply_empty(actor, ACTION_INPUT_PUSH_SEQUENCES_READY);
has_sequence = 1;
#ifdef BIOSAL_INPUT_STREAM_DEBUG
printf("DEBUG stream/%d biosal_input_stream_push_sequences entering...\n",
thorium_actor_name(actor));
#endif
buffer = thorium_message_buffer(message);
concrete_self = (struct biosal_input_stream *)thorium_actor_concrete_actor(actor);
biosal_input_command_init_empty(&command);
biosal_input_command_unpack(&command, buffer, thorium_actor_get_ephemeral_memory(actor),
&concrete_self->codec);
#ifdef BIOSAL_INPUT_STREAM_DEBUG
count = thorium_message_count(message);
printf("DEBUG biosal_input_stream_push_sequences after unpack, count %d:\n",
count);
biosal_input_command_print(&command);
#endif
store_name = biosal_input_command_store_name(&command);
store_first = biosal_input_command_store_first(&command);
store_last = biosal_input_command_store_last(&command);
sequences_to_read = store_last - store_first + 1;
#ifdef BIOSAL_INPUT_STREAM_DEBUG
printf("DEBUG biosal_input_stream_push_sequences received ACTION_INPUT_PUSH_SEQUENCES\n");
printf("DEBUG Command before sending it\n");
biosal_input_command_print(&command);
#endif
/*
* add sequences to the input command
*/
buffer_for_sequence = concrete_self->buffer_for_sequence;
/*command_entries = biosal_input_command_entries(&command);*/
i = 0;
/* TODO: actually load something
*/
while (sequences_to_read-- && has_sequence) {
has_sequence = biosal_input_proxy_get_sequence(&concrete_self->proxy,
buffer_for_sequence);
biosal_dna_sequence_init(&dna_sequence, buffer_for_sequence,
&concrete_self->codec, thorium_actor_get_ephemeral_memory(actor));
biosal_input_command_add_entry(&command, &dna_sequence, &concrete_self->codec,
thorium_actor_get_ephemeral_memory(actor));
biosal_dna_sequence_destroy(&dna_sequence, thorium_actor_get_ephemeral_memory(actor));
i++;
}
#ifdef BIOSAL_INPUT_STREAM_DEBUG
printf("DEBUG prepared %d sequences for command\n",
i);
biosal_input_command_print(&command);
#endif
new_count = biosal_input_command_pack_size(&command,
&concrete_self->codec);
new_buffer = thorium_actor_allocate(actor, new_count);
biosal_input_command_pack(&command, new_buffer, &concrete_self->codec);
#ifdef BIOSAL_INPUT_STREAM_DEBUG
actual_count = biosal_input_command_pack(&command, new_buffer);
printf("DEBUG123 new_count %d actual_count %d\n", new_count,
actual_count);
#endif
thorium_message_init(&new_message, ACTION_PUSH_SEQUENCE_DATA_BLOCK,
new_count, new_buffer);
#ifdef BIOSAL_INPUT_STREAM_DEBUG
printf("DEBUG biosal_input_stream_push_sequences sending ACTION_PUSH_SEQUENCE_DATA_BLOCK to %d\n",
store_name);
#endif
thorium_actor_send(actor, store_name, &new_message);
/*
* send sequences to store.
* The required information is the input command
*/
/*
thorium_actor_send_reply_empty(actor, ACTION_INPUT_PUSH_SEQUENCES_REPLY);
*/
/* free memory
*/
#ifdef BIOSAL_INPUT_STREAM_DEBUG
printf("DEBUG freeing %d entries\n",
(int)core_vector_size(command_entries));
#endif
biosal_input_command_destroy(&command, thorium_actor_get_ephemeral_memory(actor));
#if 0
for (i = 0; i < core_vector_size(command_entries); i++) {
a_sequence = (struct biosal_dna_sequence *)core_vector_at(command_entries, i);
biosal_dna_sequence_destroy(a_sequence, thorium_actor_get_ephemeral_memory(actor));
}
core_vector_destroy(command_entries);
#endif
#ifdef BIOSAL_INPUT_STREAM_DEBUG
printf("DEBUG biosal_input_stream_push_sequences EXIT\n");
#endif
}
void biosal_assembly_graph_store_get_starting_vertex(struct thorium_actor *self, struct thorium_message *message)
{
struct biosal_assembly_graph_store *concrete_self;
struct biosal_dna_kmer transport_kmer;
struct biosal_dna_kmer storage_kmer;
struct core_memory_pool *ephemeral_memory;
struct thorium_message new_message;
int new_count;
void *new_buffer;
char *sequence;
void *storage_key;
struct biosal_assembly_vertex *vertex;
concrete_self = thorium_actor_concrete_actor(self);
ephemeral_memory = thorium_actor_get_ephemeral_memory(self);
while (core_map_iterator_has_next(&concrete_self->iterator)) {
storage_key = NULL;
vertex = NULL;
core_map_iterator_next(&concrete_self->iterator, (void **)&storage_key,
(void **)&vertex);
/*
* Skip the vertex if it does have the status
* BIOSAL_VERTEX_FLAG_USED.
*/
if (biosal_assembly_vertex_get_flag(vertex, BIOSAL_VERTEX_FLAG_USED)) {
continue;
}
CORE_DEBUGGER_ASSERT(storage_key != NULL);
#ifdef BIOSAL_ASSEMBLY_GRAPH_STORE_DEBUG_GET_STARTING_VERTEX
printf("From storage\n");
biosal_assembly_vertex_print(vertex);
core_debugger_examine(storage_key, concrete_self->key_length_in_bytes);
#endif
biosal_dna_kmer_init_empty(&storage_kmer);
biosal_dna_kmer_unpack(&storage_kmer, storage_key, concrete_self->kmer_length,
ephemeral_memory,
&concrete_self->storage_codec);
#ifdef BIOSAL_ASSEMBLY_GRAPH_STORE_DEBUG_GET_STARTING_VERTEX
printf("DEBUG starting kmer Storage kmer hash %" PRIu64 "\n",
biosal_dna_kmer_hash(&storage_kmer, concrete_self->kmer_length,
&concrete_self->storage_codec));
biosal_dna_kmer_print(&storage_kmer, concrete_self->kmer_length, &concrete_self->storage_codec,
ephemeral_memory);
#endif
sequence = core_memory_pool_allocate(ephemeral_memory, concrete_self->kmer_length + 1);
biosal_dna_kmer_get_sequence(&storage_kmer, sequence, concrete_self->kmer_length,
&concrete_self->storage_codec);
#ifdef BIOSAL_ASSEMBLY_GRAPH_STORE_DEBUG_GET_STARTING_VERTEX
printf("SEQUENCE %s\n", sequence);
#endif
biosal_dna_kmer_init(&transport_kmer, sequence, &concrete_self->transport_codec,
ephemeral_memory);
new_count = biosal_dna_kmer_pack_size(&transport_kmer, concrete_self->kmer_length,
&concrete_self->transport_codec);
new_buffer = thorium_actor_allocate(self, new_count);
biosal_dna_kmer_pack(&transport_kmer, new_buffer, concrete_self->kmer_length,
&concrete_self->transport_codec);
#ifdef BIOSAL_ASSEMBLY_GRAPH_STORE_DEBUG_GET_STARTING_VERTEX
printf("Packed version:\n");
core_debugger_examine(new_buffer, new_count);
printf("TRANSPORT Kmer new_count %d\n", new_count);
biosal_dna_kmer_print(&transport_kmer, concrete_self->kmer_length, &concrete_self->transport_codec,
ephemeral_memory);
#endif
thorium_message_init(&new_message, ACTION_ASSEMBLY_GET_STARTING_KMER_REPLY,
new_count, new_buffer);
thorium_actor_send_reply(self, &new_message);
thorium_message_destroy(&new_message);
biosal_dna_kmer_destroy(&transport_kmer, ephemeral_memory);
core_memory_pool_free(ephemeral_memory, sequence);
biosal_dna_kmer_destroy(&storage_kmer, ephemeral_memory);
return;
}
/*
* An empty reply means that the store has nothing more to yield.
*/
thorium_actor_send_reply_empty(self, ACTION_ASSEMBLY_GET_STARTING_KMER_REPLY);
}
void biosal_assembly_graph_store_get_vertex(struct thorium_actor *self, struct thorium_message *message)
{
struct biosal_assembly_vertex vertex;
struct biosal_dna_kmer kmer;
void *buffer;
struct biosal_assembly_graph_store *concrete_self;
struct core_memory_pool *ephemeral_memory;
struct thorium_message new_message;
int new_count;
void *new_buffer;
struct biosal_assembly_vertex *canonical_vertex;
int is_canonical;
int path;
int position;
int count;
path = -1;
ephemeral_memory = thorium_actor_get_ephemeral_memory(self);
concrete_self = thorium_actor_concrete_actor(self);
buffer = thorium_message_buffer(message);
count = thorium_message_count(message);
biosal_dna_kmer_init_empty(&kmer);
position = 0;
position += biosal_dna_kmer_unpack(&kmer, buffer, concrete_self->kmer_length,
ephemeral_memory,
&concrete_self->transport_codec);
/*
* Check if a path index was provided too.
*/
if (position < count) {
position += thorium_message_unpack_int(message, position, &path);
}
CORE_DEBUGGER_ASSERT_IS_EQUAL_INT(position, count);
CORE_DEBUGGER_ASSERT(position == count);
canonical_vertex = biosal_assembly_graph_store_find_vertex(self, &kmer);
biosal_assembly_vertex_init_copy(&vertex, canonical_vertex);
is_canonical = biosal_dna_kmer_is_canonical(&kmer, concrete_self->kmer_length,
&concrete_self->transport_codec);
if (!is_canonical) {
biosal_assembly_vertex_invert_arcs(&vertex);
}
biosal_dna_kmer_destroy(&kmer, ephemeral_memory);
new_count = biosal_assembly_vertex_pack_size(&vertex);
new_buffer = thorium_actor_allocate(self, new_count);
biosal_assembly_vertex_pack(&vertex, new_buffer);
thorium_message_init(&new_message, ACTION_ASSEMBLY_GET_VERTEX_REPLY,
new_count, new_buffer);
thorium_actor_send_reply(self, &new_message);
thorium_message_destroy(&new_message);
}
void biosal_assembly_graph_store_yield_reply_summary(struct thorium_actor *self, struct thorium_message *message)
{
struct biosal_assembly_graph_store *concrete_self;
int limit;
int processed;
int new_count;
void *new_buffer;
struct biosal_assembly_vertex *vertex;
int coverage;
int parent_count;
int child_count;
/*int child_count;*/
concrete_self = thorium_actor_concrete_actor(self);
limit = 4321;
processed = 0;
/*
* This loop gather canonical information only.
*/
while (processed < limit
&& core_map_iterator_has_next(&concrete_self->iterator)) {
core_map_iterator_next(&concrete_self->iterator, NULL, (void **)&vertex);
coverage = biosal_assembly_vertex_coverage_depth(vertex);
parent_count = biosal_assembly_vertex_parent_count(vertex);
child_count = biosal_assembly_vertex_child_count(vertex);
/*
* Don't count any real arc twice.
*/
/*
child_count = biosal_assembly_vertex_child_count(vertex);
concrete_self->arc_count += child_count;
*/
/*
* Gather degree information too !
*/
biosal_assembly_graph_summary_add(&concrete_self->graph_summary, coverage, parent_count, child_count);
biosal_assembly_graph_summary_add(&concrete_self->graph_summary, coverage, child_count, parent_count);
++processed;
}
if (core_map_iterator_has_next(&concrete_self->iterator)) {
thorium_actor_send_to_self_empty(self, ACTION_YIELD);
} else {
/*
* Send the answer
*/
new_count = biosal_assembly_graph_summary_pack_size(&concrete_self->graph_summary);
new_buffer = thorium_actor_allocate(self, new_count);
biosal_assembly_graph_summary_pack(&concrete_self->graph_summary, new_buffer);
thorium_actor_send_buffer(self, concrete_self->source_for_summary,
ACTION_ASSEMBLY_GET_SUMMARY_REPLY, new_count, new_buffer);
/*
* Reset the iterator.
*/
core_map_iterator_destroy(&concrete_self->iterator);
core_map_iterator_init(&concrete_self->iterator, &concrete_self->table);
}
}
void biosal_assembly_graph_store_yield_reply(struct thorium_actor *self, struct thorium_message *message)
{
struct biosal_dna_kmer kmer;
void *key;
struct biosal_assembly_vertex *value;
int coverage;
int customer;
uint64_t *count;
int new_count;
void *new_buffer;
struct thorium_message new_message;
struct core_memory_pool *ephemeral_memory;
struct biosal_assembly_graph_store *concrete_self;
int i;
int max;
ephemeral_memory = thorium_actor_get_ephemeral_memory(self);
concrete_self = thorium_actor_concrete_actor(self);
customer = concrete_self->customer;
#if 0
printf("YIELD REPLY\n");
#endif
i = 0;
max = 1024;
key = NULL;
value = NULL;
while (i < max
&& core_map_iterator_has_next(&concrete_self->iterator)) {
core_map_iterator_next(&concrete_self->iterator, (void **)&key, (void **)&value);
biosal_dna_kmer_init_empty(&kmer);
biosal_dna_kmer_unpack(&kmer, key, concrete_self->kmer_length,
ephemeral_memory,
&concrete_self->storage_codec);
coverage = biosal_assembly_vertex_coverage_depth(value);
count = (uint64_t *)core_map_get(&concrete_self->coverage_distribution, &coverage);
if (count == NULL) {
count = (uint64_t *)core_map_add(&concrete_self->coverage_distribution, &coverage);
(*count) = 0;
}
/* increment for the lowest kmer (canonical) */
(*count)++;
biosal_dna_kmer_destroy(&kmer, ephemeral_memory);
++i;
}
/* yield again if the iterator is not at the end
*/
if (core_map_iterator_has_next(&concrete_self->iterator)) {
#if 0
printf("yield ! %d\n", i);
#endif
thorium_actor_send_to_self_empty(self, ACTION_YIELD);
return;
}
/*
printf("ready...\n");
*/
core_map_iterator_destroy(&concrete_self->iterator);
new_count = core_map_pack_size(&concrete_self->coverage_distribution);
new_buffer = thorium_actor_allocate(self, new_count);
core_map_pack(&concrete_self->coverage_distribution, new_buffer);
printf("SENDING %s/%d sends map to %d, %d bytes / %d entries\n",
thorium_actor_script_name(self),
thorium_actor_name(self),
customer, new_count,
(int)core_map_size(&concrete_self->coverage_distribution));
thorium_message_init(&new_message, ACTION_PUSH_DATA, new_count, new_buffer);
thorium_actor_send(self, customer, &new_message);
thorium_message_destroy(&new_message);
core_map_destroy(&concrete_self->coverage_distribution);
thorium_actor_send_empty(self, concrete_self->source,
ACTION_PUSH_DATA_REPLY);
}
void biosal_sequence_partitioner_receive(struct thorium_actor *actor, struct thorium_message *message)
{
int tag;
int source;
int count;
void *buffer;
int bytes;
struct biosal_sequence_partitioner *concrete_actor;
struct biosal_partition_command command;
struct thorium_message response;
int command_number;
struct biosal_partition_command *active_command;
int stream_index;
struct biosal_partition_command *command_bucket;
int i;
thorium_message_get_all(message, &tag, &count, &buffer, &source);
concrete_actor = (struct biosal_sequence_partitioner *)thorium_actor_concrete_actor(actor);
if (tag == ACTION_SEQUENCE_PARTITIONER_SET_BLOCK_SIZE) {
thorium_message_unpack_int(message, 0, &concrete_actor->block_size);
thorium_actor_send_reply_empty(actor, ACTION_SEQUENCE_PARTITIONER_SET_BLOCK_SIZE_REPLY);
biosal_sequence_partitioner_verify(actor);
/*
printf("DEBUG biosal_sequence_partitioner_receive received block size\n");
*/
} else if (tag == ACTION_SEQUENCE_PARTITIONER_SET_ENTRY_VECTOR) {
/*
printf("DEBUG biosal_sequence_partitioner_receive unpacking vector, %d bytes\n",
count);
*/
core_vector_init(&concrete_actor->stream_entries, 0);
core_vector_unpack(&concrete_actor->stream_entries, buffer);
/*
printf("DEBUG after unpack\n");
*/
thorium_actor_send_reply_empty(actor, ACTION_SEQUENCE_PARTITIONER_SET_ENTRY_VECTOR_REPLY);
/*
printf("DEBUG biosal_sequence_partitioner_receive received received entry vector\n");
*/
biosal_sequence_partitioner_verify(actor);
} else if (tag == ACTION_SEQUENCE_PARTITIONER_SET_ACTOR_COUNT) {
thorium_message_unpack_int(message, 0, &concrete_actor->store_count);
thorium_actor_send_reply_empty(actor, ACTION_SEQUENCE_PARTITIONER_SET_ACTOR_COUNT_REPLY);
biosal_sequence_partitioner_verify(actor);
/*
printf("DEBUG biosal_sequence_partitioner_receive received received store count\n");
*/
} else if (tag == ACTION_SEQUENCE_PARTITIONER_GET_COMMAND) {
if (core_queue_dequeue(&concrete_actor->available_commands, &command)) {
bytes = biosal_partition_command_pack_size(&command);
/*
printf("DEBUG partitioner has command, packing %d bytes!\n", bytes);
*/
buffer = thorium_actor_allocate(actor, bytes);
biosal_partition_command_pack(&command, buffer);
thorium_message_init(&response, ACTION_SEQUENCE_PARTITIONER_GET_COMMAND_REPLY,
bytes, buffer);
thorium_actor_send_reply(actor, &response);
/* store the active command
*/
command_number = biosal_partition_command_name(&command);
command_bucket = (struct biosal_partition_command *)core_map_add(&concrete_actor->active_commands,
&command_number);
*command_bucket = command;
/* there may be other command available too !
*/
}
} else if (tag == ACTION_SEQUENCE_PARTITIONER_GET_COMMAND_REPLY_REPLY) {
/*
* take the name of the command, find it in the active
* command, generate a new command, and send ACTION_SEQUENCE_PARTITIONER_COMMAND_IS_READY
* as a reply
*/
thorium_message_unpack_int(message, 0, &command_number);
active_command = core_map_get(&concrete_actor->active_commands,
&command_number);
if (active_command == NULL) {
return;
}
stream_index = biosal_partition_command_stream_index(active_command);
active_command = NULL;
core_map_delete(&concrete_actor->active_commands,
&command_number);
biosal_sequence_partitioner_generate_command(actor, stream_index);
if (core_map_size(&concrete_actor->active_commands) == 0
&& core_queue_size(&concrete_actor->available_commands) == 0) {
thorium_actor_send_reply_empty(actor, ACTION_SEQUENCE_PARTITIONER_FINISHED);
}
} else if (tag == ACTION_ASK_TO_STOP
&& source == thorium_actor_supervisor(actor)) {
#ifdef BIOSAL_SEQUENCE_PARTITIONER_DEBUG
printf("DEBUG biosal_sequence_partitioner_receive ACTION_ASK_TO_STOP\n");
#endif
thorium_actor_send_to_self_empty(actor,
ACTION_STOP);
} else if (tag == ACTION_SEQUENCE_PARTITIONER_PROVIDE_STORE_ENTRY_COUNTS_REPLY) {
/* generate commands
*/
for (i = 0; i < core_vector_size(&concrete_actor->stream_entries); i++) {
biosal_sequence_partitioner_generate_command(actor, i);
}
}
}
void biosal_sequence_partitioner_verify(struct thorium_actor *actor)
{
struct biosal_sequence_partitioner *concrete_actor;
int i;
int64_t entries;
uint64_t position;
uint64_t stream_entries;
int bytes;
void *buffer;
struct thorium_message message;
int64_t remaining;
int remainder;
uint64_t *bucket_for_store_count;
struct core_vector_iterator iterator;
concrete_actor = (struct biosal_sequence_partitioner *)thorium_actor_concrete_actor(actor);
/*
* check if parameters are
* initialized
*/
if (concrete_actor->block_size == -1) {
return;
}
if (concrete_actor->store_count == -1) {
return;
}
if (core_vector_size(&concrete_actor->stream_entries) == 0) {
return;
}
/* at this point, all parameters are ready.
* prepare <stream_entries.size> commands
*/
position = 0;
entries = 0;
/*
printf("DEBUG generating initial positions\n");
*/
/* generate stream positions, stream global positions, and total
*/
for (i = 0; i < core_vector_size(&concrete_actor->stream_entries); i++) {
core_vector_push_back(&concrete_actor->stream_positions, &position);
core_vector_push_back(&concrete_actor->stream_global_positions, &entries);
stream_entries = *(uint64_t *)core_vector_at(&concrete_actor->stream_entries, i);
#ifdef BIOSAL_SEQUENCE_PARTITIONER_DEBUG
printf("DEBUG stream_entries %i %" PRIu64 "\n",
i, stream_entries);
#endif
entries += stream_entries;
}
concrete_actor->total = entries;
/* compute the number of entries for each store
*/
entries = concrete_actor->total / concrete_actor->store_count;
/* make sure that this is a multiple of block size
* examples:
* total= 20000
* store_count= 2
* block_size= 8192
* 20000 / 2 = 10000
* 10000 % 8192 = 1808
* difference = 8192 - 1808 = 6384
* 10000 + 6384 = 16384
*/
if (entries % concrete_actor->block_size != 0) {
remainder = entries % concrete_actor->block_size;
entries -= remainder;
}
/* make sure that at most one store has less
* than block size
*/
if (entries < concrete_actor->block_size) {
entries = concrete_actor->block_size;
}
#ifdef BIOSAL_SEQUENCE_PARTITIONER_DEBUG
printf("DEBUG93 entries for stores %d\n", (int)entries);
#endif
remaining = concrete_actor->total;
if (remaining <= entries) {
entries = remaining;
}
/* example: 10000, block_size 4096, 3 stores
*
* total entries remaining
* 10000 4096 5904
* 10000 4096 1808
* 10000 1808 0
*/
for (i = 0; i < concrete_actor->store_count; i++) {
core_vector_push_back(&concrete_actor->store_entries, &entries);
remaining -= entries;
if (remaining < entries) {
entries = remaining;
}
}
core_vector_iterator_init(&iterator, &concrete_actor->store_entries);
while (core_vector_iterator_has_next(&iterator)) {
core_vector_iterator_next(&iterator, (void **)&bucket_for_store_count);
if (remaining >= concrete_actor->block_size) {
*bucket_for_store_count += concrete_actor->block_size;
remaining -= concrete_actor->block_size;
} else if (remaining == 0) {
break;
} else {
/* between 1 and block_size - 1 inclusively
*/
*bucket_for_store_count += remaining;
remaining = 0;
}
}
core_vector_iterator_destroy(&iterator);
#ifdef BIOSAL_SEQUENCE_PARTITIONER_DEBUG
printf("DEBUG biosal_sequence_partitioner_verify sending store counts\n");
#endif
bytes = core_vector_pack_size(&concrete_actor->store_entries);
buffer = thorium_actor_allocate(actor, bytes);
core_vector_pack(&concrete_actor->store_entries, buffer);
thorium_message_init(&message, ACTION_SEQUENCE_PARTITIONER_PROVIDE_STORE_ENTRY_COUNTS,
bytes, buffer);
thorium_actor_send_reply(actor, &message);
}