void thorium_worker_evict_actor(struct thorium_worker *worker, int actor_name)
{
struct thorium_actor *actor;
int name;
struct core_fast_queue saved_actors;
int count;
int value;
core_set_add(&worker->evicted_actors, &actor_name);
core_map_delete(&worker->actors, &actor_name);
core_fast_queue_init(&saved_actors, sizeof(struct thorium_actor *));
/* evict the actor from the scheduling queue
*/
while (thorium_scheduler_dequeue(&worker->scheduler, &actor)) {
name = thorium_actor_name(actor);
if (name != actor_name) {
core_fast_queue_enqueue(&saved_actors,
&actor);
}
}
while (core_fast_queue_dequeue(&saved_actors, &actor)) {
thorium_scheduler_enqueue(&worker->scheduler, actor);
}
core_fast_queue_destroy(&saved_actors);
/* Evict the actor from the ring
*/
count = core_fast_ring_size_from_consumer(&worker->actors_to_schedule);
while (count-- && core_fast_ring_pop_from_consumer(&worker->actors_to_schedule,
&actor)) {
name = thorium_actor_name(actor);
if (name != actor_name) {
/*
* This can not fail logically.
*/
value = core_fast_ring_push_from_producer(&worker->actors_to_schedule,
&actor);
CORE_DEBUGGER_ASSERT(value);
}
}
core_map_iterator_destroy(&worker->actor_iterator);
core_map_iterator_init(&worker->actor_iterator, &worker->actors);
}
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 thorium_actor_pack_proxy_message(struct thorium_actor *self, struct thorium_message *message,
int real_source)
{
int real_tag;
int count;
int new_count;
void *buffer;
void *new_buffer;
int offset;
struct core_memory_pool *ephemeral_memory;
/*
* pack data in this order:
*
* - data (count bytes)
* - real_source
* - real_tag
*/
ephemeral_memory = thorium_actor_get_ephemeral_memory(self);
real_tag = thorium_message_action(message);
buffer = thorium_message_buffer(message);
count = thorium_message_count(message);
#ifdef DEBUG_BINOMIAL_TREE
printf("DEBUG_BINOMIAL_TREE pack_proxy_message count %d source %d action %x\n", count,
thorium_actor_name(self),
real_tag);
thorium_message_print(message);
#endif
new_count = count + sizeof(real_source) + sizeof(real_tag);
/* use slab allocator */
new_buffer = core_memory_pool_allocate(ephemeral_memory, new_count);
#ifdef THORIUM_ACTOR_DEBUG
printf("DEBUG12 core_memory_pool_allocate %p (pack proxy message)\n",
new_buffer);
#endif
if (count > 0)
core_memory_copy(new_buffer, buffer, count);
offset = count;
core_memory_copy((char *)new_buffer + offset, &real_source, sizeof(real_source));
offset += sizeof(real_source);
core_memory_copy((char *)new_buffer + offset, &real_tag, sizeof(real_tag));
offset += sizeof(real_tag);
thorium_message_init(message, ACTION_PROXY_MESSAGE, new_count, new_buffer);
thorium_message_set_source(message, real_source);
#if 0
/* free the old buffer
*/
core_memory_free(buffer);
buffer = NULL;
#endif
}
void thorium_actor_send_range_default(struct thorium_actor *actor, struct core_vector *actors,
int first, int last,
struct thorium_message *message)
{
#ifdef USE_BINOMIAL_TREE
struct core_vector destinations;
struct core_memory_pool *ephemeral_memory;
int name;
ephemeral_memory = thorium_actor_get_ephemeral_memory(actor);
core_vector_init(&destinations, sizeof(int));
core_vector_set_memory_pool(&destinations, ephemeral_memory);
core_vector_copy_range(actors, first, last, &destinations);
/*
* Set the source now.
*/
name = thorium_actor_name(actor);
thorium_message_set_source(message, name);
thorium_actor_send_range_binomial_tree(actor, &destinations, message);
core_vector_destroy(&destinations);
#else
thorium_actor_send_range_loop(actor, actors, first, last, message);
#endif
}
void thorium_fifo_scheduler_print_with_priority(struct thorium_fifo_scheduler *queue, int priority, const char *name,
int node, int worker)
{
struct core_fast_queue *selection;
struct thorium_actor *actor;
int size;
int i;
selection = thorium_fifo_scheduler_select_queue(queue, priority);
size = core_fast_queue_size(selection);
printf("node/%d worker/%d scheduling_queue: Priority Queue %d (%s), actors: %d\n",
node, worker,
priority, name, size);
i = 0;
while (i < size) {
core_fast_queue_dequeue(selection, &actor);
core_fast_queue_enqueue(selection, &actor);
printf("node/%d worker/%d [%i] actor %s/%d (%d messages)\n",
node, worker,
i,
thorium_actor_script_name(actor),
thorium_actor_name(actor),
thorium_actor_get_mailbox_size(actor));
++i;
}
}
void thorium_cfs_scheduler_print(struct thorium_scheduler *self)
{
struct thorium_cfs_scheduler *concrete_self;
struct core_red_black_tree_iterator iterator;
uint64_t virtual_runtime;
struct thorium_actor *actor;
int i;
struct core_timer timer;
core_timer_init(&timer);
concrete_self = self->concrete_self;
core_red_black_tree_iterator_init(&iterator, &concrete_self->tree);
printf("[cfs_scheduler] %" PRIu64 " ns, timeline contains %d actors\n",
core_timer_get_nanoseconds(&timer),
core_red_black_tree_size(&concrete_self->tree));
i = 0;
while (core_red_black_tree_iterator_get_next_key_and_value(&iterator, &virtual_runtime,
&actor)) {
printf("[%d] virtual_runtime= %" PRIu64 " actor= %s/%d\n",
i, virtual_runtime,
thorium_actor_script_name(actor), thorium_actor_name(actor));
++i;
}
core_red_black_tree_iterator_destroy(&iterator);
core_timer_destroy(&timer);
}
void spate_start_reply_builder(struct thorium_actor *self, struct thorium_message *message)
{
void *buffer;
int spawner;
struct spate *concrete_self;
concrete_self = (struct spate *)thorium_actor_concrete_actor(self);
buffer = thorium_message_buffer(message);
core_vector_unpack(&concrete_self->graph_stores, buffer);
thorium_actor_log(self, "%s/%d has %d graph stores",
thorium_actor_script_name(self),
thorium_actor_name(self),
(int)core_vector_size(&concrete_self->graph_stores));
spawner = thorium_actor_get_spawner(self, &concrete_self->initial_actors);
concrete_self->unitig_manager = THORIUM_ACTOR_SPAWNING_IN_PROGRESS;
thorium_actor_add_action_with_condition(self, ACTION_SPAWN_REPLY,
spate_spawn_reply_unitig_manager,
&concrete_self->unitig_manager, THORIUM_ACTOR_SPAWNING_IN_PROGRESS);
thorium_actor_send_int(self, spawner, ACTION_SPAWN, SCRIPT_UNITIG_MANAGER);
}
void process_init(struct thorium_actor *self)
{
struct process *concrete_self;
int argc;
char **argv;
argc = thorium_actor_argc(self);
argv = thorium_actor_argv(self);
concrete_self = thorium_actor_concrete_actor(self);
core_vector_init(&concrete_self->actors, sizeof(int));
thorium_actor_add_action(self, ACTION_START, process_start);
thorium_actor_add_action(self, ACTION_ASK_TO_STOP, process_stop);
thorium_actor_add_action(self, ACTION_PING, process_ping);
thorium_actor_add_action(self, ACTION_PING_REPLY, process_ping_reply);
thorium_actor_add_action(self, ACTION_NOTIFY, process_notify);
concrete_self->passed = 0;
concrete_self->failed = 0;
concrete_self->events = 0;
concrete_self->minimum_buffer_size = 16;
concrete_self->maximum_buffer_size = 512*1024;
if (core_command_has_argument(argc, argv, MIN_BUFFER_SIZE_OPTION)) {
concrete_self->maximum_buffer_size = core_command_get_argument_value_int(argc, argv, MIN_BUFFER_SIZE_OPTION);
}
if (core_command_has_argument(argc, argv, MAX_BUFFER_SIZE_OPTION)) {
concrete_self->maximum_buffer_size = core_command_get_argument_value_int(argc, argv, MAX_BUFFER_SIZE_OPTION);
}
concrete_self->event_count = 100000;
if (core_command_has_argument(argc, argv, EVENT_COUNT_OPTION)) {
concrete_self->event_count = core_command_get_argument_value_int(argc, argv, EVENT_COUNT_OPTION);
}
concrete_self->concurrent_event_count = 8;
if (core_command_has_argument(argc, argv, CONCURRENT_EVENT_COUNT_OPTION)) {
concrete_self->concurrent_event_count = core_command_get_argument_value_int(argc, argv, CONCURRENT_EVENT_COUNT_OPTION);
}
concrete_self->active_messages = 0;
printf("%s/%d using %s %d %s %d %s %d %s %d\n",
thorium_actor_script_name(self),
thorium_actor_name(self),
MIN_BUFFER_SIZE_OPTION,
concrete_self->minimum_buffer_size,
MAX_BUFFER_SIZE_OPTION,
concrete_self->maximum_buffer_size,
EVENT_COUNT_OPTION,
concrete_self->event_count,
CONCURRENT_EVENT_COUNT_OPTION,
concrete_self->concurrent_event_count);
}
void table_destroy(struct thorium_actor *actor)
{
struct table *table1;
table1 = (struct table *)thorium_actor_concrete_actor(actor);
core_vector_destroy(&table1->spawners);
printf("actor %d dies\n", thorium_actor_name(actor));
}
int thorium_worker_enqueue_actor_special(struct thorium_worker *worker, struct thorium_actor *actor)
{
int name;
name = thorium_actor_name(actor);
core_set_delete(&worker->evicted_actors, &name);
return thorium_worker_enqueue_actor(worker, actor);
}
void thorium_actor_send_range_default(struct thorium_actor *actor, struct core_vector *actors,
int first, int last,
struct thorium_message *message)
{
int use_binomial_tree;
struct core_vector destinations;
struct core_memory_pool *ephemeral_memory;
int name;
int action;
action = thorium_message_action(message);
use_binomial_tree = 0;
#ifdef USE_BINOMIAL_TREE
/*
* ACTION_ASK_TO_STOP basically kills actors (if they agree to).
* It is a bad idea to use a binomial tree to send this death signal
* since intermediate actors can die before acting as relays.
*/
if (action != ACTION_ASK_TO_STOP)
use_binomial_tree = 1;
#endif
if (!use_binomial_tree) {
thorium_actor_send_range_loop(actor, actors, first, last, message);
return;
}
tracepoint(thorium_binomial_tree, send_range, message, (int)core_vector_size(actors));
/*
* Otherwise, use the binomial tree code path. This algorithm is better since it distributed
* the sending operations intot a binomial tree where there are a lot of intermediate
* actors (to be exact, the number of intermediate actors is close to log2(actors.size)).
*/
ephemeral_memory = thorium_actor_get_ephemeral_memory(actor);
core_vector_init(&destinations, sizeof(int));
core_vector_set_memory_pool(&destinations, ephemeral_memory);
CORE_DEBUGGER_ASSERT(core_vector_empty(&destinations));
core_vector_copy_range(actors, first, last, &destinations);
/*
* Set the source now.
*/
name = thorium_actor_name(actor);
thorium_message_set_source(message, name);
thorium_actor_send_range_binomial_tree(actor, &destinations, message);
core_vector_destroy(&destinations);
}
void core_writer_process_init(struct thorium_actor *self)
{
struct core_writer_process *concrete_self;
concrete_self = thorium_actor_concrete_actor(self);
concrete_self->has_file = 0;
thorium_actor_log(self, "%s/%d is ready to do input/output operations\n",
thorium_actor_script_name(self),
thorium_actor_name(self));
}
int thorium_cfs_scheduler_dequeue(struct thorium_scheduler *self, struct thorium_actor **actor)
{
struct thorium_cfs_scheduler *concrete_self;
void *key;
void *value;
uint64_t virtual_runtime;
int size;
key = NULL;
value = NULL;
virtual_runtime = 0;
concrete_self = self->concrete_self;
size = core_red_black_tree_size(&concrete_self->tree);
if (size == 0) {
return 0;
}
#ifdef SHOW_TIMELINE
if (size >= 10 && self->node == 0 && self->worker == 1) {
/*
printf("[cfs_scheduler] %d actor are in the timeline\n", size);
*/
thorium_cfs_scheduler_print(self);
}
#endif
/*
* This is O(N)
*/
key = core_red_black_tree_get_lowest_key(&concrete_self->tree);
/*
* This is O(1) because the tree always keep a cache of the last node.
*/
value = core_red_black_tree_get(&concrete_self->tree, key);
/*
* This is also O(1) because the tree keeps a cache of the last node.
*/
core_red_black_tree_delete(&concrete_self->tree, key);
core_memory_copy(&virtual_runtime, key, sizeof(virtual_runtime));
core_memory_copy(actor, value, sizeof(struct thorium_actor *));
#if 0
printf("CFS dequeue -> virtual_runtime= %" PRIu64 " actor= %d\n",
virtual_runtime, thorium_actor_name(*actor));
#endif
return 1;
}
void spate_set_consumers_reply(struct thorium_actor *self, struct thorium_message *message)
{
struct spate *concrete_self;
concrete_self = (struct spate *)thorium_actor_concrete_actor(self);
thorium_actor_log(self, "spate %d sends %d spawners to controller %d",
thorium_actor_name(self),
(int)core_vector_size(&concrete_self->initial_actors),
concrete_self->input_controller);
thorium_actor_send_reply_vector(self, ACTION_START, &concrete_self->initial_actors);
}
void biosal_input_stream_set_end_offset(struct thorium_actor *self, struct thorium_message *message)
{
struct biosal_input_stream *concrete_self;
concrete_self = (struct biosal_input_stream *)thorium_actor_concrete_actor(self);
#ifdef DEBUG_ISSUE_594
printf("DEBUG %d biosal_input_stream_set_end_offset\n",
thorium_actor_name(self));
#endif
thorium_message_unpack_uint64_t(message, 0, &concrete_self->ending_offset);
thorium_actor_send_reply_empty(self, ACTION_INPUT_STREAM_SET_END_OFFSET_REPLY);
}
struct biosal_assembly_vertex *biosal_assembly_graph_store_find_vertex(struct thorium_actor *self,
struct biosal_dna_kmer *kmer)
{
struct core_memory_pool *ephemeral_memory;
struct biosal_assembly_graph_store *concrete_self;
char *sequence;
struct biosal_dna_kmer storage_kmer;
char *key;
struct biosal_assembly_vertex *canonical_vertex;
ephemeral_memory = thorium_actor_get_ephemeral_memory(self);
concrete_self = thorium_actor_concrete_actor(self);
sequence = core_memory_pool_allocate(ephemeral_memory, concrete_self->kmer_length + 1);
biosal_dna_kmer_get_sequence(kmer, sequence, concrete_self->kmer_length,
&concrete_self->transport_codec);
biosal_dna_kmer_init(&storage_kmer, sequence, &concrete_self->storage_codec,
ephemeral_memory);
key = core_memory_pool_allocate(ephemeral_memory, concrete_self->key_length_in_bytes);
biosal_dna_kmer_pack_store_key(&storage_kmer, key,
concrete_self->kmer_length, &concrete_self->storage_codec,
ephemeral_memory);
canonical_vertex = core_map_get(&concrete_self->table, key);
#ifdef CORE_DEBUGGER_ASSERT
if (canonical_vertex == NULL) {
printf("not found Seq = %s name %d kmerlength %d key_length %d hash %" PRIu64 "\n", sequence,
thorium_actor_name(self),
concrete_self->kmer_length,
concrete_self->key_length_in_bytes,
biosal_dna_kmer_hash(&storage_kmer, concrete_self->kmer_length,
&concrete_self->storage_codec));
}
#endif
CORE_DEBUGGER_ASSERT(canonical_vertex != NULL);
core_memory_pool_free(ephemeral_memory, sequence);
core_memory_pool_free(ephemeral_memory, key);
biosal_dna_kmer_destroy(&storage_kmer, ephemeral_memory);
return canonical_vertex;
}
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 thorium_balancer_update_actor_production(struct thorium_balancer *self, struct thorium_actor *actor)
{
int messages;
int name;
if (actor == NULL) {
return;
}
messages = thorium_actor_get_sum_of_received_messages(actor);
name = thorium_actor_name(actor);
if (!core_map_update_value(&self->last_actor_received_messages, &name, &messages)) {
core_map_add_value(&self->last_actor_received_messages, &name, &messages);
}
}
void buddy_receive(struct thorium_actor *actor, struct thorium_message *message)
{
int tag;
int source;
int name;
name = thorium_actor_name(actor);
source = thorium_message_source(message);
tag = thorium_message_action(message);
if (tag == ACTION_BUDDY_BOOT) {
printf("ACTION_BUDDY_BOOT\n");
thorium_actor_print(actor);
thorium_message_init(message, ACTION_BUDDY_BOOT_REPLY, 0, NULL);
thorium_actor_send(actor, source, message);
} else if (tag == ACTION_BUDDY_HELLO) {
printf("ACTION_BUDDY_HELLO\n");
/* pin the actor to the worker for no reason !
*/
/*
thorium_actor_send_to_self_empty(actor, ACTION_PIN_TO_WORKER);
*/
thorium_message_init(message, ACTION_BUDDY_HELLO_REPLY, 0, NULL);
thorium_actor_send(actor, source, message);
} else if (tag == ACTION_ASK_TO_STOP) {
printf("BUDDY_DIE\n");
printf("buddy_receive Actor %i received a message (%i BUDDY_DIE) from actor %i\n",
name, tag, source);
/*
thorium_actor_send_to_self_empty(actor, ACTION_UNPIN_FROM_WORKER);
*/
thorium_message_init(message, ACTION_STOP, 0, NULL);
thorium_actor_send(actor, name, message);
}
}
void biosal_assembly_arc_classifier_init(struct thorium_actor *self)
{
struct biosal_assembly_arc_classifier *concrete_self;
concrete_self = (struct biosal_assembly_arc_classifier *)thorium_actor_concrete_actor(self);
concrete_self->kmer_length = -1;
thorium_actor_add_action(self, ACTION_ASK_TO_STOP,
thorium_actor_ask_to_stop);
thorium_actor_add_action(self, ACTION_SET_KMER_LENGTH,
biosal_assembly_arc_classifier_set_kmer_length);
/*
*
* Configure the codec.
*/
biosal_dna_codec_init(&concrete_self->codec);
if (biosal_dna_codec_must_use_two_bit_encoding(&concrete_self->codec,
thorium_actor_get_node_count(self))) {
biosal_dna_codec_enable_two_bit_encoding(&concrete_self->codec);
}
core_vector_init(&concrete_self->consumers, sizeof(int));
thorium_actor_add_action(self, ACTION_ASSEMBLY_PUSH_ARC_BLOCK,
biosal_assembly_arc_classifier_push_arc_block);
concrete_self->received_blocks = 0;
core_vector_init(&concrete_self->pending_requests, sizeof(int));
concrete_self->active_requests = 0;
concrete_self->producer_is_waiting = 0;
concrete_self->maximum_pending_request_count = thorium_actor_active_message_limit(self);
concrete_self->consumer_count_above_threshold = 0;
printf("%s/%d is now active, ACTIVE_MESSAGE_LIMIT %d\n",
thorium_actor_script_name(self),
thorium_actor_name(self),
concrete_self->maximum_pending_request_count);
}
void spate_distribute_reply(struct thorium_actor *self, struct thorium_message *message)
{
struct spate *concrete_self;
concrete_self = (struct spate *)thorium_actor_concrete_actor(self);
thorium_actor_log(self, "spate %d: all sequence stores are ready",
thorium_actor_name(self));
thorium_actor_send_vector(self, concrete_self->assembly_graph_builder,
ACTION_SET_PRODUCERS, &concrete_self->sequence_stores);
/* kill the controller
*/
thorium_actor_send_reply_empty(self, ACTION_ASK_TO_STOP);
}
void biosal_coverage_distribution_init(struct thorium_actor *self)
{
struct biosal_coverage_distribution *concrete_actor;
concrete_actor = (struct biosal_coverage_distribution *)thorium_actor_concrete_actor(self);
core_map_init(&concrete_actor->distribution, sizeof(int), sizeof(uint64_t));
#ifdef BIOSAL_COVERAGE_DISTRIBUTION_DEBUG
thorium_actor_log(self, "DISTRIBUTION IS READY\n");
#endif
concrete_actor->actual = 0;
concrete_actor->expected = 0;
thorium_actor_log(self, "%s/%d is ready\n",
thorium_actor_script_name(self),
thorium_actor_name(self));
}
/* hello-hello_receive */
void hello_receive(struct thorium_actor *self, struct thorium_message *message)
{
int tag;
int name;
void *buffer;
struct hello *concrete_self;
struct core_vector data_vector;
int i;
int action = thorium_message_action(message);
concrete_self = thorium_actor_concrete_actor(self);
name = thorium_actor_name(self);
buffer = thorium_message_buffer(message);
thorium_actor_log(self, "received action %d\n",
action);
if (action == ACTION_START) {
thorium_message_print(message);
printf("\n");
/*
* Send a ping message to self.
*/
thorium_actor_send_reply_empty(self, ACTION_MY_PING);
}
if (action == ACTION_MY_PING) {
thorium_actor_send_reply_empty(self, ACTION_MY_PONG);
}
if (action == ACTION_MY_PONG) {
thorium_actor_send_reply_empty(self, ACTION_ASK_TO_STOP);
}
if (action == ACTION_ASK_TO_STOP) {
thorium_actor_send_reply_empty(self, ACTION_STOP);
}
}
void biosal_input_controller_receive_store_entry_counts(struct thorium_actor *actor, struct thorium_message *message)
{
struct biosal_input_controller *concrete_actor;
struct core_vector store_entries;
void *buffer;
int i;
int store;
uint64_t entries;
struct thorium_message new_message;
int name;
core_vector_init(&store_entries, sizeof(uint64_t));
concrete_actor = (struct biosal_input_controller *)thorium_actor_concrete_actor(actor);
buffer = thorium_message_buffer(message);
name = thorium_actor_name(actor);
concrete_actor->ready_consumers = 0;
#ifdef BIOSAL_INPUT_CONTROLLER_DEBUG
printf("DEBUG biosal_input_controller_receive_store_entry_counts unpacking entries\n");
#endif
core_vector_init(&store_entries, 0);
core_vector_unpack(&store_entries, buffer);
for (i = 0; i < core_vector_size(&store_entries); i++) {
store = *(int *)core_vector_at(&concrete_actor->consumers, i);
entries = *(uint64_t *)core_vector_at(&store_entries, i);
printf("DEBUG controller/%d tells consumer/%d to reserve %" PRIu64 " buckets\n",
name, store, entries);
thorium_message_init(&new_message, ACTION_RESERVE,
sizeof(entries), &entries);
thorium_actor_send(actor, store, &new_message);
}
#ifdef BIOSAL_INPUT_CONTROLLER_DEBUG
printf("DEBUG biosal_input_controller_receive_store_entry_counts will wait for replies\n");
#endif
core_vector_destroy(&store_entries);
}
void biosal_input_stream_count_reply_mock(struct thorium_actor *self, struct thorium_message *message)
{
struct biosal_input_stream *concrete_self;
void *buffer;
int count;
struct core_vector mega_blocks;
char *file;
struct core_memory_pool *ephemeral_memory;
uint64_t result;
struct biosal_mega_block *block;
concrete_self = (struct biosal_input_stream *)thorium_actor_concrete_actor(self);
buffer = thorium_message_buffer(message);
count = thorium_message_count(message);
ephemeral_memory = thorium_actor_get_ephemeral_memory(self);
core_vector_init(&mega_blocks, 0);
core_vector_set_memory_pool(&mega_blocks, ephemeral_memory);
core_vector_unpack(&mega_blocks, buffer);
block = core_vector_at_last(&mega_blocks);
result = biosal_mega_block_get_entries(block);
#if 0
file = core_string_get(&concrete_self->file_for_parallel_counting);
#endif
file = concrete_self->file_name;
printf("%s/%d COUNT_IN_PARALLEL result for %s is %" PRIu64 "\n",
thorium_actor_script_name(self),
thorium_actor_name(self),
file,
result);
core_vector_destroy(&mega_blocks);
thorium_actor_send_buffer(self, concrete_self->controller,
ACTION_INPUT_COUNT_IN_PARALLEL_REPLY, count, buffer);
}
int thorium_balancer_get_actor_production(struct thorium_balancer *self, struct thorium_actor *actor)
{
int messages;
int last_messages;
int name;
int result;
if (actor == NULL) {
return 0;
}
messages = thorium_actor_get_sum_of_received_messages(actor);
last_messages = 0;
name = thorium_actor_name(actor);
core_map_get_value(&self->last_actor_received_messages, &name, &last_messages);
result = messages - last_messages;
return result;
}
void biosal_input_stream_count_in_parallel_mock(struct thorium_actor *self, struct thorium_message *message)
{
struct biosal_input_stream *concrete_self;
void *buffer;
int count;
char *file;
concrete_self = (struct biosal_input_stream *)thorium_actor_concrete_actor(self);
buffer = thorium_message_buffer(message);
count = thorium_message_count(message);
file = concrete_self->file_name;
printf("%s/%d receives ACTION_INPUT_COUNT_IN_PARALLEL file %s\n",
thorium_actor_script_name(self),
thorium_actor_name(self),
file);
thorium_actor_send_to_self_buffer(self, ACTION_INPUT_COUNT, count, buffer);
}
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 framr_hello_reply(actor_t *actor, message_t *message)
{
message_t new_message;
int name;
int source;
int boss;
framr_t *self;
struct core_vector *spawners;
self = thorium_actor_concrete_actor(actor);
name = thorium_actor_name(actor);
source = thorium_message_source(message);
spawners = &self->spawners;
pm("Actor %d is satisfied with a reply from the neighbor %d.\n", name, source);
boss = core_vector_at_as_int(spawners, 0);
thorium_message_init(&new_message, ACTION_NOTIFY, 0, NULL);
thorium_actor_send(actor, boss, &new_message);
thorium_message_destroy(&new_message);
}
void biosal_assembly_graph_store_print_progress(struct thorium_actor *self)
{
struct biosal_assembly_graph_store *concrete_self;
uint64_t total;
uint64_t stride;
uint64_t current_value;
int steps;
float ratio;
char finished[] = " FINISHED";
char not_finished[] = "";
char *state;
concrete_self = thorium_actor_concrete_actor(self);
total = core_map_size(&concrete_self->table);
steps = 20;
stride = total / steps;
current_value = concrete_self->consumed_canonical_vertex_count;
if ((current_value == 0)
|| (current_value % stride == 0)
|| (current_value == total)) {
state = not_finished;
if (current_value == total) {
state = finished;
}
ratio = (0.0 + current_value) / total;
printf("%s/%d %.2f of vertices were consumed%s\n",
thorium_actor_script_name(self),
thorium_actor_name(self), ratio, state);
}
}
