void spate_stop(struct thorium_actor *self)
{
struct spate *concrete_self;
concrete_self = (struct spate *)thorium_actor_concrete_actor(self);
thorium_actor_send_range_empty(self, &concrete_self->initial_actors, ACTION_ASK_TO_STOP);
}
void process_notify(struct thorium_actor *self, struct thorium_message *message)
{
struct process *concrete_self;
concrete_self = (struct process *)thorium_actor_concrete_actor(self);
++concrete_self->ready;
if (concrete_self->ready == core_vector_size(&concrete_self->actors)) {
thorium_actor_send_range_empty(self, &concrete_self->actors,
ACTION_ASK_TO_STOP);
}
}
void framr_notify(actor_t *actor, message_t *message)
{
int size;
framr_t *self;
struct core_vector *spawners;
self = thorium_actor_concrete_actor(actor);
spawners = &self->spawners;
size = core_vector_size(spawners);
pm("Boss received NOTIFY\n");
++self->completed;
if (self->completed == size) {
thorium_actor_send_range_empty(actor, spawners, ACTION_ASK_TO_STOP);
}
}
void biosal_input_stream_open_reply(struct thorium_actor *self, struct thorium_message *message)
{
struct biosal_input_stream *concrete_self;
int i;
int size;
struct core_vector *vector;
concrete_self = (struct biosal_input_stream *)thorium_actor_concrete_actor(self);
++concrete_self->finished_parallel_stream_count;
#if 0
printf("DEBUG open_reply\n");
#endif
if (concrete_self->finished_parallel_stream_count ==
core_vector_size(&concrete_self->parallel_streams)) {
concrete_self->finished_parallel_stream_count = 0;
size = core_vector_size(&concrete_self->parallel_streams);
core_vector_resize(&concrete_self->parallel_mega_blocks,
size);
for (i = 0; i < size; i++) {
vector = core_vector_at(&concrete_self->parallel_mega_blocks, i);
core_vector_init(vector, sizeof(struct biosal_mega_block));
}
thorium_actor_send_range_empty(self, &concrete_self->parallel_streams,
ACTION_INPUT_COUNT);
}
}
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);
}
}
/*
* 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 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);
}
}
