void systolic_receive(struct thorium_actor *actor, struct thorium_message *message)
{
int tag;
int name;
void *buffer;
struct systolic *systolic1;
int i;
systolic1 = (struct systolic *)thorium_actor_concrete_actor(actor);
tag = thorium_message_action(message);
name = thorium_actor_name(actor);
buffer = thorium_message_buffer(message);
if (tag == ACTION_START) {
core_vector_unpack(&systolic1->initial_data, buffer);
printf("Hello world ! my name is actor:%d and I have %d acquaintances:",
name, (int)core_vector_size(&systolic1->initial_data));
for (i = 0; i < core_vector_size(&systolic1->initial_data); i++) {
printf(" actor:%d", core_vector_at_as_int(&systolic1->initial_data, i));
}
printf("\n");
thorium_actor_send_to_self_empty(actor, ACTION_STOP);
}
}
void biosal_input_controller_get_node_worker_count_reply(struct thorium_actor *actor, struct thorium_message *message)
{
int tag;
int source;
void *buffer;
int count;
int index;
struct biosal_input_controller *concrete_actor;
int spawner;
int worker_count;
int *bucket;
concrete_actor = (struct biosal_input_controller *)thorium_actor_concrete_actor(actor);
thorium_message_get_all(message, &tag, &count, &buffer, &source);
spawner = source;
thorium_message_unpack_int(message, 0, &worker_count);
index = core_vector_index_of(&concrete_actor->spawners, &spawner);
bucket = core_vector_at(&concrete_actor->stores_per_spawner, index);
*bucket = worker_count * concrete_actor->stores_per_worker_per_spawner;
printf("DEBUG spawner %d (node %d) is on a node that has %d workers\n", spawner,
index, worker_count);
thorium_actor_send_to_self_empty(actor, ACTION_INPUT_CONTROLLER_CREATE_STORES);
}
void frame_init(struct thorium_actor *actor)
{
struct frame *concrete_actor;
concrete_actor = (struct frame *)thorium_actor_concrete_actor(actor);
concrete_actor->value = rand() % 12345;
thorium_actor_send_to_self_empty(actor, ACTION_PACK_ENABLE);
concrete_actor->migrated_other = 0;
concrete_actor->pings = 0;
core_vector_init(&concrete_actor->acquaintance_vector, sizeof(int));
}
void process_stop(struct thorium_actor *self, struct thorium_message *message)
{
struct process *concrete_self;
int total;
concrete_self = (struct process *)thorium_actor_concrete_actor(self);
total = concrete_self->passed + concrete_self->failed;
printf("%s/%d PASSED %d/%d, FAILED %d/%d\n",
thorium_actor_script_name(self),
thorium_actor_name(self),
concrete_self->passed, total,
concrete_self->failed, total);
thorium_actor_send_to_self_empty(self, ACTION_STOP);
}
void framr_process_args(actor_t *actor)
{
int argc;
char **argv;
argc = thorium_actor_argc(actor);
argv = thorium_actor_argv(actor);
if (core_command_has_argument(argc, argv, "-v")) {
thorium_actor_send_to_self_empty(actor, ACTION_ENABLE_LOG_LEVEL);
}
framr_t *self = thorium_actor_concrete_actor(actor);
self->kmer_length = biosal_command_get_kmer_length(argc, argv);
pm("kmer length set to %d\n", self->kmer_length);
}
void biosal_assembly_graph_store_get_summary(struct thorium_actor *self, struct thorium_message *message)
{
struct biosal_assembly_graph_store *concrete_self;
int source;
source = thorium_message_source(message);
concrete_self = thorium_actor_concrete_actor(self);
concrete_self->summary_in_progress = 1;
concrete_self->source_for_summary = source;
thorium_actor_add_action_with_condition(self, ACTION_YIELD_REPLY,
biosal_assembly_graph_store_yield_reply_summary,
&concrete_self->summary_in_progress, 1);
core_map_iterator_init(&concrete_self->iterator, &concrete_self->table);
thorium_actor_send_to_self_empty(self, ACTION_YIELD);
}
void spate_ask_to_stop(struct thorium_actor *self, struct thorium_message *message)
{
int source;
struct spate *concrete_self;
concrete_self = (struct spate *)thorium_actor_concrete_actor(self);
source = thorium_message_source(message);
if (!spate_must_print_help(self)) {
thorium_actor_log(self, "spate %d stops", thorium_actor_name(self));
}
#if 0
thorium_actor_ask_to_stop(self, message);
#endif
/*
* Check if the source is an initial actor because each initial actor
* is its own supervisor.
*/
if (core_vector_index_of(&concrete_self->initial_actors, &source) >= 0) {
thorium_actor_send_to_self_empty(self, ACTION_STOP);
}
if (concrete_self->is_leader) {
if (concrete_self->assembly_graph_builder != THORIUM_ACTOR_NOBODY)
thorium_actor_send_empty(self, concrete_self->assembly_graph_builder,
ACTION_ASK_TO_STOP);
if (concrete_self->assembly_graph_builder != THORIUM_ACTOR_NOBODY)
thorium_actor_send_empty(self, concrete_self->manager_for_sequence_stores,
ACTION_ASK_TO_STOP);
if (!spate_must_print_help(self)) {
core_timer_stop(&concrete_self->timer);
core_timer_print_with_description(&concrete_self->timer, "Total");
}
}
}
void biosal_assembly_graph_store_push_data(struct thorium_actor *self, struct thorium_message *message)
{
struct biosal_assembly_graph_store *concrete_self;
int name;
int source;
concrete_self = thorium_actor_concrete_actor(self);
source = thorium_message_source(message);
concrete_self->source = source;
name = thorium_actor_name(self);
core_map_init(&concrete_self->coverage_distribution, sizeof(int), sizeof(uint64_t));
printf("%s/%d: local table has %" PRIu64" canonical kmers (%" PRIu64 " kmers)\n",
thorium_actor_script_name(self),
name, core_map_size(&concrete_self->table),
2 * core_map_size(&concrete_self->table));
core_memory_pool_examine(&concrete_self->persistent_memory);
core_map_iterator_init(&concrete_self->iterator, &concrete_self->table);
thorium_actor_send_to_self_empty(self, ACTION_YIELD);
}
void biosal_input_controller_add_store(struct thorium_actor *actor, struct thorium_message *message)
{
int source;
int store;
int index;
struct biosal_input_controller *concrete_actor;
int *bucket;
/*
printf("DEBUG biosal_input_controller_add_store\n");
*/
concrete_actor = (struct biosal_input_controller *)thorium_actor_concrete_actor(actor);
source = thorium_message_source(message);
thorium_message_unpack_int(message, 0, &store);
index = core_vector_index_of(&concrete_actor->spawners, &source);
/*
printf("DEBUG biosal_input_controller_add_store index %d\n", index);
*/
bucket = core_vector_at(&concrete_actor->stores_per_spawner, index);
/* the content of the bucket is initially the total number of
* stores that are desired for this spawner.
*/
*bucket = (*bucket - 1);
core_vector_push_back(&concrete_actor->consumers, &store);
thorium_actor_send_to_self_empty(actor, ACTION_INPUT_CONTROLLER_CREATE_STORES);
/*
printf("DEBUG remaining to spawn: %d (before returning)\n", *bucket);
*/
}
void frame_receive(struct thorium_actor *actor, struct thorium_message *message)
{
int tag;
int name;
void *buffer;
struct frame *concrete_actor;
int other;
struct core_vector initial_actors;
struct core_vector *acquaintance_vector;
int source;
source = thorium_message_source(message);
concrete_actor = (struct frame *)thorium_actor_concrete_actor(actor);
tag = thorium_message_action(message);
name = thorium_actor_name(actor);
buffer = thorium_message_buffer(message);
acquaintance_vector = &concrete_actor->acquaintance_vector;
if (tag == ACTION_START) {
core_vector_init(&initial_actors, sizeof(int));
core_vector_unpack(&initial_actors, buffer);
core_vector_push_back_vector(acquaintance_vector, &initial_actors);
core_vector_destroy(&initial_actors);
other = thorium_actor_spawn(actor, thorium_actor_script(actor));
core_vector_push_back_int(acquaintance_vector, other);
thorium_actor_send_empty(actor, other, ACTION_PING);
printf("actor %d sends ACTION_PING to new actor %d\n",
name, other);
} else if (tag == ACTION_PING) {
/* new acquaintance
*/
core_vector_push_back(acquaintance_vector, &source);
printf("actor %d (value %d) receives ACTION_PING from actor %d\n",
name, concrete_actor->value, source);
printf("Acquaintances of actor %d: ", name);
core_vector_print_int(acquaintance_vector);
printf("\n");
thorium_actor_send_reply_empty(actor, ACTION_PING_REPLY);
} else if (tag == ACTION_PING_REPLY) {
concrete_actor->pings++;
printf("actor %d receives ACTION_PING_REPLY from actor %d\n",
name, source);
/* kill the system
*/
if (concrete_actor->migrated_other && concrete_actor->pings == 2) {
thorium_actor_send_reply_empty(actor, ACTION_ASK_TO_STOP);
thorium_actor_send_to_self_empty(actor, ACTION_ASK_TO_STOP);
return;
}
/* migrate other actor
*/
printf("actor %d asks actor %d to migrate using actor %d as spawner\n",
name, source, name);
printf("Acquaintances of actor %d: ", name);
core_vector_print_int(acquaintance_vector);
printf("\n");
thorium_actor_send_reply_int(actor, ACTION_MIGRATE, name);
/* send a message to other while it is migrating.
* this is supposed to work !
*/
printf("actor %d sends ACTION_PING to %d while it is migrating\n",
name, source);
thorium_actor_send_reply_empty(actor, ACTION_PING);
concrete_actor->migrated_other = 1;
} else if (tag == ACTION_MIGRATE_REPLY) {
thorium_message_unpack_int(message, 0, &other);
printf("actor %d received migrated actor %d\n", name, other);
printf("Acquaintances of actor %d: ", name);
core_vector_print_int(acquaintance_vector);
printf("\n");
/* it is possible that the ACTION_PING went through
* before the migration
*/
if (concrete_actor->pings == 2) {
thorium_actor_send_reply_empty(actor, ACTION_ASK_TO_STOP);
thorium_actor_send_to_self_empty(actor, ACTION_ASK_TO_STOP);
}
} else if (tag == ACTION_PACK) {
thorium_actor_send_reply_int(actor, ACTION_PACK_REPLY, concrete_actor->value);
} else if (tag == ACTION_UNPACK) {
thorium_message_unpack_int(message, 0, &concrete_actor->value);
thorium_actor_send_reply_empty(actor, ACTION_UNPACK_REPLY);
} else if (tag == ACTION_ASK_TO_STOP) {
printf("actor %d received ACTION_ASK_TO_STOP, value: %d ",
name, concrete_actor->value);
printf("acquaintance vector: ");
core_vector_print_int(acquaintance_vector);
printf("\n");
thorium_actor_send_to_self_empty(actor, ACTION_STOP);
}
}
void reader_receive(struct thorium_actor *actor, struct thorium_message *message)
{
int tag;
int argc;
char **argv;
/*int i;*/
int name;
struct reader *reader1;
int source;
uint64_t count;
void *buffer;
int sequences;
int script;
int sequence_index;
char *received_sequence;
int error;
reader1 = (struct reader *)thorium_actor_concrete_actor(actor);
tag = thorium_message_action(message);
source = thorium_message_source(message);
buffer = thorium_message_buffer(message);
name = thorium_actor_name(actor);
if (tag == ACTION_START) {
core_vector_init(&reader1->spawners, 0);
core_vector_unpack(&reader1->spawners, buffer);
argc = thorium_actor_argc(actor);
argv = thorium_actor_argv(actor);
name = thorium_actor_name(actor);
reader1->last_report = 0;
/*
printf("actor %i received %i arguments\n", name, argc);
for (i = 0; i < argc ;i++) {
printf(" argument %i : %s\n", i, argv[i]);
}
*/
if (core_vector_index_of(&reader1->spawners, &name) != 0) {
thorium_message_init(message, ACTION_STOP, 0, NULL);
thorium_actor_send(actor, name, message);
return;
}
if (argc == 1) {
thorium_message_init(message, ACTION_STOP, 0, NULL);
thorium_actor_send(actor, name, message);
return;
}
reader1->sequence_reader = thorium_actor_spawn(actor, SCRIPT_INPUT_STREAM);
reader1->file = argv[argc - 1];
thorium_message_init(message, ACTION_INPUT_OPEN, strlen(reader1->file) + 1,
reader1->file);
printf("actor %i: asking actor %i to count entries in %s\n",
name, reader1->sequence_reader, reader1->file);
thorium_actor_send(actor, reader1->sequence_reader, message);
} else if (tag == ACTION_INPUT_COUNT_PROGRESS) {
sequences = *(int64_t *)buffer;
if (sequences < reader1->last_report + 10000000) {
return;
}
printf("Actor %i received a progress report from actor %i: %i\n",
name, source, sequences);
reader1->last_report = sequences;
} else if (tag == ACTION_INPUT_OPEN_REPLY && !reader1->counted) {
thorium_message_unpack_int(message, 0, &error);
if (error == BIOSAL_INPUT_ERROR_NO_ERROR) {
printf("Successfully opened file.\n");
thorium_actor_send_reply_empty(actor, ACTION_INPUT_COUNT);
} else if (error == BIOSAL_INPUT_ERROR_FILE_NOT_FOUND) {
printf("Error, file not found! \n");
thorium_actor_send_to_self_empty(actor, ACTION_STOP);
} else if (error == BIOSAL_INPUT_ERROR_FORMAT_NOT_SUPPORTED) {
printf("Error, format not supported! \n");
thorium_actor_send_to_self_empty(actor, ACTION_STOP);
}
} else if (tag == ACTION_INPUT_COUNT_REPLY) {
count = *(int64_t*)thorium_message_buffer(message);
printf("actor %i: file has %" PRIu64 " items\n", name, count);
thorium_message_init(message, ACTION_INPUT_CLOSE, 0, NULL);
thorium_actor_send(actor, source, message);
reader1->counted = 1;
} else if (tag == ACTION_INPUT_CLOSE_REPLY && !reader1->pulled) {
/* not necessary, it is already dead. */
thorium_actor_send_reply_empty(actor, ACTION_ASK_TO_STOP);
printf("actor %d received ACTION_INPUT_CLOSE_REPLY from actor %d, asking it to stop"
" with ACTION_ASK_TO_STOP\n", name, source);
/*
thorium_message_init(message, ACTION_STOP, 0, NULL);
thorium_actor_send(actor, name, message);
return;
*/
script = SCRIPT_INPUT_STREAM;
thorium_message_init(message, ACTION_SPAWN, sizeof(script), &script);
thorium_actor_send(actor, name, message);
} else if (tag == ACTION_INPUT_CLOSE_REPLY && reader1->pulled) {
thorium_actor_send_reply_empty(actor, ACTION_ASK_TO_STOP);
thorium_actor_send_to_self_empty(actor, ACTION_STOP);
} else if (tag == ACTION_ASK_TO_STOP_REPLY && reader1->pulled) {
/* this tag will never arrive here */
thorium_message_init(message, ACTION_STOP, 0, NULL);
thorium_actor_send(actor, name, message);
} else if (tag == ACTION_SPAWN_REPLY && source == name) {
reader1->sequence_reader = *(int *)buffer;
printf("actor %d tells actor %d to open %s to pull sequences from the file\n",
name, reader1->sequence_reader, reader1->file);
thorium_message_init(message, ACTION_INPUT_OPEN,
strlen(reader1->file) + 1, reader1->file);
thorium_actor_send(actor, reader1->sequence_reader, message);
} else if (tag == ACTION_INPUT_OPEN_REPLY && reader1->counted) {
thorium_message_init(message, ACTION_INPUT_GET_SEQUENCE, 0, NULL);
thorium_actor_send(actor, source, message);
} else if (tag == ACTION_INPUT_GET_SEQUENCE_REPLY) {
sequence_index = *(int *)buffer;
received_sequence = (char*)buffer + sizeof(sequence_index);
/*
printf("DEBUG %d %s\n", sequence_index, received_sequence);
*/
if (sequence_index == 123456) {
printf("actor %d says that sequence %d is %s.\n",
name, sequence_index, received_sequence);
} else if (sequence_index % 100000 == 0) {
printf("actor %d is pulling sequences from fellow local actor %d,"
" %d sequences pulled so far !\n",
name, reader1->sequence_reader, sequence_index);
}
if (sequence_index < 1000000) {
thorium_message_init(message, ACTION_INPUT_GET_SEQUENCE, 0, NULL);
thorium_actor_send(actor, source, message);
} else {
thorium_message_init(message, ACTION_INPUT_CLOSE, 0, NULL);
thorium_actor_send(actor, source, message);
reader1->pulled = 1;
}
} else if (tag == ACTION_INPUT_GET_SEQUENCE_END) {
printf("actor %d: reached the end...\n", name);
thorium_message_init(message, ACTION_INPUT_CLOSE, 0, NULL);
thorium_actor_send(actor, source, message);
reader1->pulled = 1;
}
}
void spate_add_file_reply(struct thorium_actor *self, struct thorium_message *message)
{
thorium_actor_send_to_self_empty(self, ACTION_SPATE_ADD_FILES);
}
void core_writer_process_receive(struct thorium_actor *self, struct thorium_message *message)
{
int action;
int count;
int source;
char *buffer;
char *file_name;
struct core_writer_process *concrete_self;
concrete_self = thorium_actor_concrete_actor(self);
action = thorium_message_action(message);
count = thorium_message_count(message);
buffer = thorium_message_buffer(message);
source = thorium_message_source(message);
if (action == ACTION_OPEN) {
if (concrete_self->has_file) {
thorium_actor_log(self, "actor error, already open, can not open\n");
return;
}
file_name = buffer;
core_buffered_file_writer_init(&concrete_self->writer, file_name);
concrete_self->has_file = 1;
thorium_actor_send_reply_empty(self, ACTION_OPEN_REPLY);
} else if (action == ACTION_WRITE) {
core_buffered_file_writer_write(&concrete_self->writer, buffer, count);
thorium_actor_send_reply_empty(self, ACTION_WRITE_REPLY);
} else if (action == ACTION_CLOSE) {
if (!concrete_self->has_file) {
thorium_actor_log(self, "Error, can not close a file that is not open\n");
return;
}
core_buffered_file_writer_destroy(&concrete_self->writer);
concrete_self->has_file = 0;
thorium_actor_send_reply_empty(self, ACTION_CLOSE_REPLY);
} else if (action == ACTION_ASK_TO_STOP
&& source == thorium_actor_supervisor(self)) {
/*
* Close the file if it is open
* right now.
*/
if (concrete_self->has_file) {
core_buffered_file_writer_destroy(&concrete_self->writer);
concrete_self->has_file = 0;
}
thorium_actor_send_to_self_empty(self, ACTION_STOP);
thorium_actor_send_reply_empty(self, ACTION_ASK_TO_STOP_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 spate_add_files(struct thorium_actor *self, struct thorium_message *message)
{
if (!spate_add_file(self)) {
thorium_actor_send_to_self_empty(self, ACTION_SPATE_ADD_FILES_REPLY);
}
}
void biosal_input_stream_receive(struct thorium_actor *actor, struct thorium_message *message)
{
int tag;
int source;
uint64_t count;
struct biosal_input_stream *concrete_self;
int i;
int has_sequence;
int sequences;
int sequence_index;
int buffer_size;
char *buffer;
char *read_buffer;
struct biosal_mega_block mega_block;
char *file_name_in_buffer;
if (thorium_actor_take_action(actor, message)) {
return;
}
concrete_self = thorium_actor_concrete_actor(actor);
tag = thorium_message_action(message);
source = thorium_message_source(message);
buffer = (char *)thorium_message_buffer(message);
/* Do nothing if there is an error.
* has_error returns the error to the source.
*/
/*
if (biosal_input_stream_has_error(actor, message)) {
return;
}
*/
if (tag == ACTION_INPUT_OPEN) {
#ifdef BIOSAL_INPUT_STREAM_DEBUG
printf("DEBUG ACTION_INPUT_OPEN\n");
#endif
if (concrete_self->open) {
concrete_self->error = BIOSAL_INPUT_ERROR_ALREADY_OPEN;
thorium_actor_send_reply_int(actor, ACTION_INPUT_OPEN_REPLY, concrete_self->error);
thorium_actor_send_to_self_empty(actor, ACTION_ASK_TO_STOP);
return;
}
concrete_self->open = 1;
/* TODO: find out the maximum read length in some way */
concrete_self->maximum_sequence_length = BIOSAL_INPUT_MAXIMUM_SEQUENCE_LENGTH;
concrete_self->buffer_for_sequence = (char *)core_memory_allocate(concrete_self->maximum_sequence_length, MEMORY_INPUT_STREAM);
/*biosal_input_stream_init(actor);*/
#ifdef BIOSAL_INPUT_STREAM_DEBUG
printf("DEBUG biosal_input_stream_receive open %s\n",
buffer);
#endif
/*core_memory_copy(&concrete_self->file_index, buffer, sizeof(concrete_self->file_index));*/
file_name_in_buffer = buffer;
printf("stream/%d (node/%d) opens file %s offset %" PRIu64 "\n", thorium_actor_name(actor),
thorium_actor_node_name(actor), file_name_in_buffer,
concrete_self->starting_offset);
#ifdef DEBUG_ISSUE_594
thorium_message_print(message);
printf("Buffer %s\n", buffer);
#endif
concrete_self->file_name = core_memory_allocate(strlen(file_name_in_buffer) + 1, MEMORY_INPUT_STREAM);
strcpy(concrete_self->file_name, file_name_in_buffer);
biosal_input_proxy_init(&concrete_self->proxy, concrete_self->file_name,
concrete_self->starting_offset, concrete_self->ending_offset);
concrete_self->proxy_ready = 1;
/* Die if there is an error...
*/
if (biosal_input_stream_has_error(actor, message)) {
#ifdef BIOSAL_INPUT_STREAM_DEBUG
printf("DEBUG has error\n");
#endif
thorium_actor_send_reply_int(actor, ACTION_INPUT_OPEN_REPLY, concrete_self->error);
thorium_actor_send_to_self_empty(actor, ACTION_ASK_TO_STOP);
return;
}
concrete_self->controller = source;
/* no error here... */
thorium_actor_send_reply_int(actor, ACTION_INPUT_OPEN_REPLY, concrete_self->error);
} else if (tag == ACTION_INPUT_COUNT) {
/* count a little bit and yield the worker */
if (concrete_self->count_customer == THORIUM_ACTOR_NOBODY) {
concrete_self->count_customer = source;
}
if (biosal_input_stream_check_open_error(actor, message)) {
thorium_actor_send_reply_int64_t(actor, ACTION_INPUT_COUNT_REPLY, concrete_self->error);
thorium_actor_send_to_self_empty(actor, ACTION_ASK_TO_STOP);
return;
}
#ifdef BIOSAL_INPUT_STREAM_DEBUG
printf("DEBUG ACTION_INPUT_COUNT received...\n");
#endif
i = 0;
/* continue counting ... */
has_sequence = 1;
while (i < concrete_self->granularity && has_sequence) {
has_sequence = biosal_input_proxy_get_sequence(&concrete_self->proxy,
concrete_self->buffer_for_sequence);
#if 0
printf("Sequence= %s\n", concrete_self->buffer_for_sequence);
#endif
i++;
}
sequences = biosal_input_proxy_size(&concrete_self->proxy);
#ifdef BIOSAL_INPUT_STREAM_DEBUG
printf("DEBUG ACTION_INPUT_COUNT sequences %d...\n", sequences);
#endif
if (!has_sequence || sequences % concrete_self->mega_block_size == 0) {
biosal_mega_block_init(&mega_block, -1, concrete_self->last_offset,
sequences - concrete_self->last_entries, sequences);
core_vector_push_back(&concrete_self->mega_blocks, &mega_block);
concrete_self->last_entries = sequences;
concrete_self->last_offset = biosal_input_proxy_offset(&concrete_self->proxy);
thorium_actor_send_int64_t(actor, concrete_self->controller, ACTION_INPUT_COUNT_PROGRESS, sequences);
}
if (has_sequence) {
/*printf("DEBUG yield\n");*/
thorium_actor_send_to_self_empty(actor, ACTION_YIELD);
/* notify the controller of our progress...
*/
} else {
thorium_actor_send_to_self_empty(actor, ACTION_INPUT_COUNT_READY);
}
} else if (tag == ACTION_YIELD_REPLY) {
if (biosal_input_stream_check_open_error(actor, message)) {
/*
* it is not clear that there can be an error when receiving YIELD.
error = concrete_self->error;
thorium_actor_send_reply_int(actor, ACTION_INPUT_COUNT_REPLY, error);
thorium_actor_send_to_self(actor, ACTION_ASK_TO_STOP);
*/
return;
}
thorium_actor_send_to_self_empty(actor, ACTION_INPUT_COUNT);
} else if (tag == ACTION_INPUT_COUNT_READY) {
if (biosal_input_stream_check_open_error(actor, message)) {
return;
}
count = biosal_input_proxy_size(&concrete_self->proxy);
thorium_actor_send_vector(actor, concrete_self->count_customer, ACTION_INPUT_COUNT_REPLY,
&concrete_self->mega_blocks);
printf("input_stream/%d on node/%d counted entries in %s, %" PRIu64 "\n",
thorium_actor_name(actor), thorium_actor_node_name(actor),
concrete_self->file_name, count);
} else if (tag == ACTION_INPUT_CLOSE) {
#ifdef BIOSAL_INPUT_STREAM_DEBUG
printf("DEBUG destroy proxy\n");
#endif
concrete_self->error = BIOSAL_INPUT_ERROR_NO_ERROR;
if (biosal_input_stream_check_open_error(actor, message)) {
concrete_self->error = BIOSAL_INPUT_ERROR_FILE_NOT_OPEN;
thorium_message_init(message, ACTION_INPUT_CLOSE_REPLY, sizeof(concrete_self->error),
&concrete_self->error);
thorium_actor_send(actor, source, message);
thorium_actor_send_to_self_empty(actor, ACTION_ASK_TO_STOP);
return;
}
thorium_message_init(message, ACTION_INPUT_CLOSE_REPLY, sizeof(concrete_self->error),
&concrete_self->error);
thorium_actor_send(actor, source, message);
thorium_actor_send_to_self_empty(actor, ACTION_ASK_TO_STOP);
#ifdef BIOSAL_INPUT_STREAM_DEBUG
printf("actor %d sending ACTION_INPUT_CLOSE_REPLY to %d\n",
thorium_actor_name(actor), source);
#endif
} else if (tag == ACTION_INPUT_GET_SEQUENCE) {
if (biosal_input_stream_check_open_error(actor, message)) {
/* the error management could be better. */
concrete_self->error = BIOSAL_INPUT_ERROR_FILE_NOT_OPEN;
thorium_message_init(message, ACTION_INPUT_GET_SEQUENCE_REPLY, sizeof(concrete_self->error),
&concrete_self->error);
thorium_actor_send(actor, source, message);
return;
}
sequence_index = biosal_input_proxy_size(&concrete_self->proxy);
/* TODO it would be clearer to use a struct to pack a int and a char []
* then to use the code below.
*/
read_buffer = concrete_self->buffer_for_sequence + sizeof(sequence_index);
has_sequence = biosal_input_proxy_get_sequence(&concrete_self->proxy,
read_buffer);
if (!has_sequence) {
thorium_message_init(message, ACTION_INPUT_GET_SEQUENCE_END, 0, NULL);
thorium_actor_send(actor, source, message);
return;
}
buffer_size = sizeof(sequence_index) + strlen(read_buffer) + 1;
core_memory_copy(concrete_self->buffer_for_sequence, &sequence_index, sizeof(sequence_index));
thorium_message_init(message, ACTION_INPUT_GET_SEQUENCE_REPLY,
buffer_size, concrete_self->buffer_for_sequence);
thorium_actor_send(actor, source, message);
} else if (tag == ACTION_INPUT_PUSH_SEQUENCES) {
biosal_input_stream_push_sequences(actor, message);
} else if (tag == ACTION_ASK_TO_STOP) {
thorium_actor_send_to_self_empty(actor, ACTION_STOP);
thorium_actor_send_range_empty(actor, &concrete_self->parallel_streams,
ACTION_ASK_TO_STOP);
thorium_actor_send_reply_empty(actor, ACTION_ASK_TO_STOP_REPLY);
} else if (tag == ACTION_INPUT_STREAM_RESET) {
/* fail silently
*/
if (!concrete_self->open) {
thorium_actor_send_reply_empty(actor, ACTION_INPUT_STREAM_RESET_REPLY);
return;
}
#ifdef BIOSAL_INPUT_STREAM_DEBUG
printf("DEBUG ACTION_INPUT_STREAM_RESET\n");
#endif
biosal_input_proxy_destroy(&concrete_self->proxy);
biosal_input_proxy_init(&concrete_self->proxy, concrete_self->file_name,
concrete_self->starting_offset,
concrete_self->ending_offset);
thorium_actor_send_reply_empty(actor, ACTION_INPUT_STREAM_RESET_REPLY);
} else if (tag == ACTION_PUSH_SEQUENCE_DATA_BLOCK_REPLY) {
thorium_actor_send_to_supervisor_int(actor, ACTION_INPUT_PUSH_SEQUENCES_REPLY,
source);
}
}
static void source_receive(struct thorium_actor *self, struct thorium_message *message)
{
int action;
void *buffer;
int leader;
int source;
int count;
struct source *concrete_self;
int name;
concrete_self = (struct source *)thorium_actor_concrete_actor(self);
action = thorium_message_action(message);
buffer = thorium_message_buffer(message);
source = thorium_message_source(message);
name = thorium_actor_name(self);
count = thorium_message_count(message);
if (action == ACTION_ASK_TO_STOP) {
thorium_actor_log(self, "sent %d ACTION_PING messages\n",
concrete_self->message_count);
thorium_actor_send_to_self_empty(self, ACTION_STOP);
} else if (action == ACTION_NOTIFY) {
#ifdef LATENCY_PROBE_USE_MULTIPLEXER
thorium_actor_send_to_self_empty(self, ACTION_ENABLE_MULTIPLEXER);
#endif
CORE_DEBUGGER_ASSERT(core_vector_empty(&concrete_self->targets));
core_vector_unpack(&concrete_self->targets, buffer);
if (source_is_important(self)) {
printf("%d (node %d worker %d) has %d targets\n", thorium_actor_name(self),
thorium_actor_node_name(self),
thorium_actor_worker_name(self),
(int)core_vector_size(&concrete_self->targets));
}
concrete_self->leader = source;
source_send_ping(self);
} else if (action == ACTION_PING_REPLY) {
CORE_DEBUGGER_ASSERT(count == 0);
++concrete_self->message_count;
CORE_DEBUGGER_ASSERT_IS_EQUAL_INT(count, 0);
CORE_DEBUGGER_ASSERT_IS_NULL(buffer);
if (concrete_self->message_count % PERIOD == 0 || concrete_self->event_count < 500) {
if (source_is_important(self)) {
printf("progress %d %d/%d\n",
name, concrete_self->message_count, concrete_self->event_count);
}
}
if (concrete_self->message_count == concrete_self->event_count) {
leader = concrete_self->leader;
thorium_actor_send_empty(self, leader, ACTION_NOTIFY_REPLY);
if (source_is_important(self))
printf("%d (ACTION_PING sent: %d)"
" sends ACTION_NOTIFY_REPLY to %d\n", thorium_actor_name(self),
concrete_self->message_count,
leader);
} else {
source_send_ping(self);
}
}
}
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 framr_ask_to_stop(actor_t *actor, message_t *message)
{
pm("received ASK_TO_STOP\n");
thorium_actor_send_to_self_empty(actor, ACTION_STOP);
}
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_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);
}
}
/*
* Basically, this actor does this:
* - spawn visitors
* - let them visit stuff
* - kill them.
* - spawn walkers
* - let them walk
* - kill the walkers
* - return OK
*/
void biosal_unitig_manager_receive(struct thorium_actor *self, struct thorium_message *message)
{
struct biosal_unitig_manager *concrete_self;
int tag;
void *buffer;
int spawner;
int expected;
int script;
int actor_count;
int source;
struct core_string file_name;
char *directory;
int argc;
char **argv;
char *path;
tag = thorium_message_action(message);
source = thorium_message_source(message);
buffer = thorium_message_buffer(message);
concrete_self = (struct biosal_unitig_manager *)thorium_actor_concrete_actor(self);
if (tag == ACTION_START) {
core_vector_unpack(&concrete_self->spawners, buffer);
spawner = thorium_actor_get_random_spawner(self, &concrete_self->spawners);
concrete_self->state = STATE_SPAWN_WRITER;
thorium_actor_send_int(self, spawner, ACTION_SPAWN, SCRIPT_WRITER_PROCESS);
} else if (tag == ACTION_SPAWN_REPLY
&& concrete_self->state == STATE_SPAWN_WRITER) {
thorium_message_unpack_int(message, 0, &concrete_self->writer_process);
/*
* open the file now.
*/
argc = thorium_actor_argc(self);
argv = thorium_actor_argv(self);
directory = core_command_get_output_directory(argc, argv);
core_string_init(&file_name, directory);
core_string_append(&file_name, "/");
core_string_append(&file_name, "unitigs.fasta");
path = core_string_get(&file_name);
thorium_actor_send_buffer(self, concrete_self->writer_process,
ACTION_OPEN, strlen(path) + 1, path);
core_string_destroy(&file_name);
} else if (tag == ACTION_OPEN_REPLY
&& source == concrete_self->writer_process) {
/*
* Spawn visitors.
*/
concrete_self->state = STATE_VISITORS;
thorium_actor_send_to_self_empty(self, ACTION_PING);
} else if (tag == ACTION_PING) {
spawner = thorium_actor_get_random_spawner(self, &concrete_self->spawners);
thorium_actor_send_int(self, spawner, ACTION_SPAWN, SCRIPT_MANAGER);
} else if (tag == ACTION_SPAWN_REPLY) {
thorium_message_unpack_int(message, 0, &concrete_self->manager);
script = SCRIPT_UNITIG_VISITOR;
if (concrete_self->state == STATE_WALKERS) {
script = SCRIPT_UNITIG_WALKER;
}
thorium_actor_send_int(self, concrete_self->manager, ACTION_MANAGER_SET_SCRIPT,
script);
} else if (tag == ACTION_ASK_TO_STOP) {
thorium_actor_send_empty(self, concrete_self->writer_process,
ACTION_ASK_TO_STOP);
thorium_actor_send_empty(self, concrete_self->manager,
ACTION_ASK_TO_STOP);
thorium_actor_send_to_self_empty(self, ACTION_STOP);
thorium_actor_send_reply_empty(self, ACTION_ASK_TO_STOP_REPLY);
} else if (tag == ACTION_MANAGER_SET_SCRIPT_REPLY) {
actor_count = UNITIG_VISITOR_COUNT_PER_WORKER;
if (concrete_self->state == STATE_WALKERS)
actor_count = UNITIG_WALKER_COUNT_PER_WORKER;
thorium_actor_send_reply_int(self, ACTION_MANAGER_SET_ACTORS_PER_WORKER,
actor_count);
} else if (tag == ACTION_MANAGER_SET_ACTORS_PER_WORKER_REPLY) {
thorium_actor_send_reply_vector(self, ACTION_START,
&concrete_self->spawners);
} else if (tag == ACTION_START_REPLY
&& concrete_self->state == STATE_VISITORS
&& core_vector_size(&concrete_self->visitors) == 0) {
core_vector_unpack(&concrete_self->visitors, buffer);
printf("DEBUG the system has %d visitors\n",
(int)core_vector_size(&concrete_self->visitors));
thorium_actor_send_to_supervisor_empty(self, ACTION_START_REPLY);
} else if (tag == ACTION_START_REPLY
&& concrete_self->state == STATE_WALKERS
&& core_vector_size(&concrete_self->walkers) == 0) {
core_vector_unpack(&concrete_self->walkers, buffer);
printf("DEBUG the system has %d walkers\n",
(int)core_vector_size(&concrete_self->walkers));
core_timer_start(&concrete_self->timer);
concrete_self->completed = 0;
thorium_actor_send_range_int(self, &concrete_self->walkers,
ACTION_SET_CONSUMER, concrete_self->writer_process);
thorium_actor_send_range_vector(self, &concrete_self->walkers,
ACTION_START, &concrete_self->graph_stores);
} else if (tag == ACTION_SET_PRODUCERS) {
core_vector_unpack(&concrete_self->graph_stores, buffer);
core_timer_start(&concrete_self->timer);
concrete_self->completed = 0;
thorium_actor_send_range_vector(self, &concrete_self->visitors,
ACTION_START, &concrete_self->graph_stores);
} else if (tag == ACTION_START_REPLY && concrete_self->state == STATE_VISITORS) {
++concrete_self->completed;
expected = core_vector_size(&concrete_self->visitors);
if (concrete_self->completed % UNITIG_VISITOR_COUNT_PER_WORKER == 0
|| concrete_self->completed == expected) {
printf("PROGRESS unitig visitors %d/%d\n",
concrete_self->completed,
expected);
}
if (concrete_self->completed == expected) {
core_timer_stop(&concrete_self->timer);
core_timer_print_with_description(&concrete_self->timer, "Visit vertices for unitigs");
/*
* Stop the visitor manager and all visitors too.
*/
thorium_actor_send_empty(self, concrete_self->manager, ACTION_ASK_TO_STOP);
/*
* Reset graph stores.
*/
thorium_actor_send_range_empty(self, &concrete_self->graph_stores,
ACTION_RESET);
concrete_self->completed = 0;
}
} else if (tag == ACTION_RESET_REPLY) {
++concrete_self->completed;
expected = core_vector_size(&concrete_self->graph_stores);
if (concrete_self->completed == expected) {
concrete_self->completed = 0;
concrete_self->state = STATE_WALKERS;
/*
* Go back at the beginning.
*/
thorium_actor_send_to_self_empty(self, ACTION_PING);
}
} else if (tag == ACTION_START_REPLY && concrete_self->state == STATE_WALKERS) {
++concrete_self->completed;
expected = core_vector_size(&concrete_self->walkers);
if (concrete_self->completed % UNITIG_WALKER_COUNT_PER_WORKER == 0
|| concrete_self->completed == expected) {
printf("PROGRESS unitig walkers %d/%d\n",
concrete_self->completed,
expected);
}
if (concrete_self->completed == expected) {
core_timer_stop(&concrete_self->timer);
core_timer_print_with_description(&concrete_self->timer, "Walk for unitigs");
thorium_actor_send_to_supervisor_empty(self, ACTION_SET_PRODUCERS_REPLY);
}
}
}
void biosal_input_controller_create_stores(struct thorium_actor *actor, struct thorium_message *message)
{
int tag;
int source;
void *buffer;
int count;
int i;
struct biosal_input_controller *concrete_actor;
int value;
int spawner;
uint64_t total;
int block_size;
int blocks;
uint64_t entries;
char *local_file;
int name;
concrete_actor = (struct biosal_input_controller *)thorium_actor_concrete_actor(actor);
thorium_message_get_all(message, &tag, &count, &buffer, &source);
/*
printf("DEBUG biosal_input_controller_create_stores\n");
*/
for (i = 0; i < core_vector_size(&concrete_actor->stores_per_spawner); i++) {
value = core_vector_at_as_int(&concrete_actor->stores_per_spawner, i);
if (value == -1) {
/*
printf("DEBUG need more information about spawner at %i\n",
i);
*/
spawner = core_vector_at_as_int(&concrete_actor->spawners, i);
thorium_actor_send_empty(actor, spawner, ACTION_GET_NODE_NAME);
return;
}
}
concrete_actor->state = BIOSAL_INPUT_CONTROLLER_STATE_SPAWN_STORES;
/* at this point, we know the worker count of every node corresponding
* to each spawner
*/
for (i = 0; i < core_vector_size(&concrete_actor->stores_per_spawner); i++) {
/*
printf("DEBUG polling spawner %i/%d\n", i,
core_vector_size(&concrete_actor->stores_per_spawner));
*/
value = core_vector_at_as_int(&concrete_actor->stores_per_spawner, i);
if (value != 0) {
spawner = core_vector_at_as_int(&concrete_actor->spawners, i);
/*
printf("DEBUG spawner %d is %d\n", i, spawner);
*/
thorium_actor_send_int(actor, spawner, ACTION_SPAWN, SCRIPT_SEQUENCE_STORE);
return;
}
/*
printf("DEBUG spawner %i spawned all its stores\n", i);
*/
}
printf("DEBUG controller %d: consumers are ready (%d)\n",
thorium_actor_name(actor),
(int)core_vector_size(&concrete_actor->consumers));
for (i = 0; i < core_vector_size(&concrete_actor->consumers); i++) {
value = core_vector_at_as_int(&concrete_actor->consumers, i);
printf("DEBUG controller %d: consumer %i is %d\n",
thorium_actor_name(actor), i, value);
}
printf("DEBUG controller %d: streams are\n",
thorium_actor_name(actor));
total = 0;
block_size = concrete_actor->block_size;
for (i = 0; i < core_vector_size(&concrete_actor->files); i++) {
entries = *(uint64_t*)core_vector_at(&concrete_actor->counts, i);
local_file = core_vector_at_as_char_pointer(&concrete_actor->files, i);
name = *(int *)core_vector_at(&concrete_actor->counting_streams, i);
printf("stream %d, %d/%d %s %" PRIu64 "\n",
name, i,
(int)core_vector_size(&concrete_actor->files),
local_file,
entries);
total += entries;
}
blocks = total / block_size;
if (total % block_size != 0) {
blocks++;
}
core_timer_stop(&concrete_actor->counting_timer);
core_timer_start(&concrete_actor->distribution_timer);
core_timer_print_with_description(&concrete_actor->counting_timer,
"Load input / Count input data");
printf("DEBUG controller %d: Partition Total: %" PRIu64 ", block_size: %d, blocks: %d\n",
thorium_actor_name(actor),
total, block_size, blocks);
#ifdef BIOSAL_INPUT_CONTROLLER_DEBUG_10355
printf("DEBUG send ACTION_INPUT_CONTROLLER_CREATE_STORES to self %d\n",
thorium_actor_name(actor));
#endif
#ifdef BIOSAL_INPUT_CONTROLLER_DEBUG
printf("DEBUG biosal_input_controller_create_stores send ACTION_INPUT_CONTROLLER_CREATE_PARTITION\n");
#endif
/* no sequences at all !
*/
if (total == 0) {
printf("Error, total is 0, can not distribute\n");
thorium_actor_send_to_supervisor_empty(actor, ACTION_INPUT_DISTRIBUTE_REPLY);
return;
} else {
thorium_actor_send_to_self_empty(actor, ACTION_INPUT_CONTROLLER_CREATE_PARTITION);
}
/*
thorium_actor_send_to_self_empty(actor, ACTION_STOP);
*/
}
void ring_receive(struct thorium_actor *actor, struct thorium_message *message)
{
int tag;
int new_actor;
int previous;
int name;
struct ring *concrete_actor;
int messages;
int previous_actor;
char *buffer;
int destination;
concrete_actor = (struct ring *)thorium_actor_concrete_actor(actor);
tag = thorium_message_action(message);
buffer = thorium_message_buffer(message);
name = thorium_actor_name(actor);
if (tag == ACTION_START) {
core_vector_init(&concrete_actor->spawners, 0);
core_vector_unpack(&concrete_actor->spawners, buffer);
printf("actor %d ACTION_START, %d spawners\n", name,
(int)core_vector_size(&concrete_actor->spawners));
destination = *(int *)core_vector_at(&concrete_actor->spawners, 0);
thorium_actor_send_empty(actor, destination, ACTION_RING_READY);
} else if (tag == ACTION_RING_READY && concrete_actor->step == RING_STEP_RECEIVE_SPAWNERS) {
concrete_actor->ready_rings++;
if (concrete_actor->ready_rings == (int)core_vector_size(&concrete_actor->spawners)) {
thorium_actor_send_range_empty(actor, &concrete_actor->spawners, ACTION_RING_SPAWN);
concrete_actor->step = RING_STEP_SPAWN;
concrete_actor->ready_rings = 0;
}
} else if (tag == ACTION_RING_SPAWN) {
printf("actor/%d is spawning %d senders\n",
thorium_actor_name(actor), concrete_actor->senders);
concrete_actor->step = RING_STEP_SPAWN;
new_actor = thorium_actor_spawn(actor, SCRIPT_SENDER);
concrete_actor->first = new_actor;
previous = new_actor;
new_actor = thorium_actor_spawn(actor, SCRIPT_SENDER);
concrete_actor->previous = new_actor;
thorium_message_init(message, ACTION_SENDER_SET_NEXT, sizeof(new_actor), &new_actor);
thorium_actor_send(actor, previous, message);
++concrete_actor->spawned_senders;
++concrete_actor->spawned_senders;
} else if (tag == ACTION_RING_READY && concrete_actor->step == RING_STEP_SPAWN) {
concrete_actor->ready_rings++;
#if 0
printf("READY: %d/%d\n", concrete_actor->ready_rings, (int)core_vector_size(&concrete_actor->spawners));
#endif
if (concrete_actor->ready_rings == core_vector_size(&concrete_actor->spawners)) {
thorium_actor_send_range_empty(actor, &concrete_actor->spawners, ACTION_RING_PUSH_NEXT);
concrete_actor->ready_rings = 0;
concrete_actor->step = RING_STEP_PUSH_NEXT;
}
} else if (tag == ACTION_RING_PUSH_NEXT) {
previous_actor = core_vector_index_of(&concrete_actor->spawners, &name) - 1;
if (previous_actor < 0) {
previous_actor = core_vector_size(&concrete_actor->spawners)- 1;
}
printf("%d received ACTION_RING_PUSH_NEXT\n", name);
thorium_message_init(message, ACTION_RING_SET_NEXT, sizeof(concrete_actor->first), &concrete_actor->first);
thorium_actor_send(actor, *(int *)core_vector_at(&concrete_actor->spawners, previous_actor),
message);
} else if (tag == ACTION_RING_SET_NEXT) {
concrete_actor->step = RING_STEP_PUSH_NEXT;
thorium_message_set_action(message, ACTION_SENDER_SET_NEXT);
thorium_actor_send(actor, concrete_actor->last, message);
} else if (tag == ACTION_SENDER_SET_NEXT_REPLY
&& concrete_actor->step == RING_STEP_SPAWN) {
#if 0
printf("ready senders %d/%d\n", concrete_actor->ready_senders, concrete_actor->senders);
#endif
if (concrete_actor->spawned_senders % 10000 == 0) {
printf("spawned %d/%d\n",
concrete_actor->spawned_senders,
concrete_actor->senders);
}
if (concrete_actor->spawned_senders == concrete_actor->senders) {
printf("RING_STEP_SPAWN completed.\n");
thorium_actor_send_empty(actor, *(int *)core_vector_at(&concrete_actor->spawners, 0), ACTION_RING_READY);
concrete_actor->ready_senders = 0;
concrete_actor->last = concrete_actor->previous;
} else {
new_actor = thorium_actor_spawn(actor, SCRIPT_SENDER);
++concrete_actor->spawned_senders;
previous = concrete_actor->previous;
thorium_message_init(message, ACTION_SENDER_SET_NEXT, sizeof(new_actor), &new_actor);
thorium_actor_send(actor, previous, message);
concrete_actor->previous = new_actor;
}
} else if (tag == ACTION_SENDER_SET_NEXT_REPLY
&& concrete_actor->step == RING_STEP_PUSH_NEXT) {
concrete_actor->ready_senders++;
printf("ACTION_SENDER_SET_NEXT_REPLY %d/%d\n",
concrete_actor->ready_senders,
1);
if (concrete_actor->ready_senders == 1) {
thorium_actor_send_empty(actor, *(int *)core_vector_at(&concrete_actor->spawners, 0), ACTION_RING_READY);
printf("RING_STEP_PUSH_NEXT completed.\n");
concrete_actor->ready_senders = 0;
}
} else if (tag == ACTION_RING_READY && concrete_actor->step == RING_STEP_PUSH_NEXT) {
concrete_actor->ready_rings++;
if (concrete_actor->ready_rings == core_vector_size(&concrete_actor->spawners)) {
printf("system is ready...\n");
messages = 2000007;
thorium_message_init(message, ACTION_SENDER_HELLO, sizeof(messages), &messages);
thorium_actor_send(actor, concrete_actor->first, message);
concrete_actor->ready_rings = 0;
}
} else if (tag == ACTION_SENDER_HELLO_REPLY) {
thorium_actor_send_range_empty(actor, &concrete_actor->spawners, ACTION_RING_KILL);
thorium_actor_send_empty(actor, concrete_actor->first, ACTION_SENDER_KILL);
} else if (tag == ACTION_RING_KILL) {
thorium_actor_send_to_self_empty(actor, ACTION_STOP);
}
}
