int core_map_get_value(struct core_map *self, void *key, void *value)
{
void *bucket;
int size;
#ifdef CORE_MAP_ALIGNMENT_ENABLED
key = core_map_pad_key(self, key);
#endif
bucket = core_map_get(self, key);
if (bucket == NULL) {
return 0;
}
#ifdef CORE_MAP_ALIGNMENT_ENABLED
size = self->original_value_size;
#else
size = core_map_get_value_size(self);
#endif
if (value != NULL) {
core_memory_copy(value, bucket, size);
}
return 1;
}
int core_map_add_value(struct core_map *self, void *key, void *value)
{
void *bucket;
int value_size;
#ifdef CORE_MAP_ALIGNMENT_ENABLED
key = core_map_pad_key(self, key);
#endif
bucket = core_map_get(self, key);
/* it's already there...
*/
if (bucket != NULL) {
return 0;
}
bucket = core_map_add(self, key);
#ifdef CORE_MAP_ALIGNMENT_ENABLED
value_size = self->original_value_size;
#else
value_size = core_map_get_value_size(self);
#endif
core_memory_copy(bucket, value, value_size);
return 1;
}
int thorium_balancer_select_worker_script_round_robin(struct thorium_balancer *self, int script)
{
int worker;
int worker_count;
int next_worker;
int *bucket;
bucket = core_map_get(&self->current_script_workers, &script);
worker_count = thorium_worker_pool_worker_count(self->pool);
/* First time for this script
*/
if (bucket == NULL) {
bucket = core_map_add(&self->current_script_workers, &script);
*bucket = self->first_worker;
self->first_worker = (self->first_worker + 1) % worker_count;
}
worker = *bucket;
next_worker = (worker + 1) % worker_count;
*bucket = next_worker;
return worker;
}
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 biosal_input_controller_spawn_streams(struct thorium_actor *actor, struct thorium_message *message)
{
int spawner;
struct biosal_input_controller *concrete_actor;
struct core_vector_iterator iterator;
int i;
int j;
int block_index;
struct core_vector *vector;
struct biosal_mega_block *block;
#ifdef BIOSAL_INPUT_CONTROLLER_DEBUG_READING_STREAMS
printf("DEBUG biosal_input_controller_spawn_streams\n");
#endif
concrete_actor = (struct biosal_input_controller *)thorium_actor_concrete_actor(actor);
concrete_actor->opened_streams = 0;
concrete_actor->spawner = 0;
/* gather mega blocks
*/
block_index = 0;
printf("DEBUG received MEGA BLOCKS\n");
for (i = 0; i < core_vector_size(&concrete_actor->files); i++) {
vector = (struct core_vector *)core_map_get(&concrete_actor->mega_blocks, &i);
if (vector == NULL) {
continue;
}
for (j = 0; j < core_vector_size(vector); j++) {
block = (struct biosal_mega_block *)core_vector_at(vector, j);
printf("BLOCK # %d ", block_index);
block_index++;
biosal_mega_block_print(block);
core_vector_push_back(&concrete_actor->mega_block_vector, block);
}
}
printf("DEBUG MEGA BLOCKS (total: %d)\n", block_index);
core_vector_iterator_init(&iterator, &concrete_actor->mega_block_vector);
while (core_vector_iterator_has_next(&iterator)) {
core_vector_iterator_next(&iterator, NULL);
spawner = core_vector_at_as_int(&concrete_actor->spawners, concrete_actor->spawner);
concrete_actor->spawner++;
concrete_actor->spawner %= core_vector_size(&concrete_actor->spawners);
#ifdef BIOSAL_INPUT_CONTROLLER_DEBUG_READING_STREAMS
printf("DEBUG asking %d to spawn script %d\n", spawner, SCRIPT_INPUT_STREAM);
#endif
thorium_actor_send_int(actor, spawner, ACTION_SPAWN, SCRIPT_INPUT_STREAM);
}
core_vector_iterator_destroy(&iterator);
concrete_actor->state = BIOSAL_INPUT_CONTROLLER_STATE_SPAWN_READING_STREAMS;
}
void biosal_assembly_graph_store_add_arc(struct thorium_actor *self,
struct biosal_assembly_arc *arc, char *sequence,
void *key)
{
struct biosal_assembly_graph_store *concrete_self;
struct biosal_dna_kmer *source;
struct biosal_dna_kmer real_source;
int destination;
int type;
struct biosal_assembly_vertex *vertex;
struct core_memory_pool *ephemeral_memory;
int is_canonical;
#if 0
/*
* Don't do anything just to see if this code
* is buggy.
*/
return;
#endif
#ifdef BIOSAL_ASSEMBLY_GRAPH_STORE_DEBUG_ARC
int verbose;
#endif
ephemeral_memory = thorium_actor_get_ephemeral_memory(self);
concrete_self = thorium_actor_concrete_actor(self);
#ifdef BIOSAL_ASSEMBLY_GRAPH_STORE_DEBUG_ARC
verbose = 0;
if (concrete_self->received_arc_count == 0) {
verbose = 1;
}
if (verbose) {
printf("DEBUG BioSAL::GraphStore::AddArc\n");
biosal_assembly_arc_print(arc, concrete_self->kmer_length, &concrete_self->transport_codec,
ephemeral_memory);
}
#endif
source = biosal_assembly_arc_source(arc);
destination = biosal_assembly_arc_destination(arc);
type = biosal_assembly_arc_type(arc);
/*
* Don't convert the data if the transport codec and the
* storage codec are the same.
*/
if (concrete_self->codec_are_different) {
biosal_dna_kmer_get_sequence(source, sequence, concrete_self->kmer_length,
&concrete_self->transport_codec);
biosal_dna_kmer_init(&real_source, sequence, &concrete_self->storage_codec,
ephemeral_memory);
source = &real_source;
}
biosal_dna_kmer_pack_store_key(source, key,
concrete_self->kmer_length, &concrete_self->storage_codec,
ephemeral_memory);
vertex = core_map_get(&concrete_self->table, key);
#ifdef CORE_DEBUGGER_ENABLE_ASSERT
if (vertex == NULL) {
printf("Error: vertex is NULL, key_length_in_bytes %d size %" PRIu64 "\n",
concrete_self->key_length_in_bytes,
core_map_size(&concrete_self->table));
}
#endif
CORE_DEBUGGER_ASSERT(vertex != NULL);
#ifdef BIOSAL_ASSEMBLY_GRAPH_STORE_DEBUG_ARC
if (verbose) {
printf("DEBUG BEFORE:\n");
biosal_assembly_vertex_print(vertex);
}
#endif
/*
* Inverse the arc if the source is not canonical
*/
is_canonical = biosal_dna_kmer_is_canonical(source, concrete_self->kmer_length,
&concrete_self->storage_codec);
if (!is_canonical) {
if (type == BIOSAL_ARC_TYPE_PARENT) {
type = BIOSAL_ARC_TYPE_CHILD;
} else if (type == BIOSAL_ARC_TYPE_CHILD) {
type = BIOSAL_ARC_TYPE_PARENT;
}
destination = biosal_dna_codec_get_complement(destination);
}
if (type == BIOSAL_ARC_TYPE_PARENT) {
biosal_assembly_vertex_add_parent(vertex, destination);
} else if (type == BIOSAL_ARC_TYPE_CHILD) {
biosal_assembly_vertex_add_child(vertex, destination);
}
#ifdef BIOSAL_ASSEMBLY_GRAPH_STORE_DEBUG_ARC
if (verbose) {
printf("DEBUG AFTER:\n");
biosal_assembly_vertex_print(vertex);
}
#endif
if (concrete_self->codec_are_different) {
biosal_dna_kmer_destroy(&real_source, ephemeral_memory);
}
}
void biosal_assembly_graph_store_push_kmer_block(struct thorium_actor *self, struct thorium_message *message)
{
struct core_memory_pool *ephemeral_memory;
struct biosal_dna_kmer_frequency_block block;
struct biosal_assembly_vertex *bucket;
void *packed_kmer;
struct core_map_iterator iterator;
struct biosal_assembly_graph_store *concrete_self;
/*int tag;*/
void *key;
struct core_map *kmers;
struct biosal_dna_kmer kmer;
void *buffer;
int count;
struct biosal_dna_kmer encoded_kmer;
char *raw_kmer;
int period;
struct biosal_dna_kmer *kmer_pointer;
int *frequency;
ephemeral_memory = thorium_actor_get_ephemeral_memory(self);
concrete_self = thorium_actor_concrete_actor(self);
/*tag = thorium_message_action(message);*/
buffer = thorium_message_buffer(message);
count = thorium_message_count(message);
/*
* Handler for PUSH_DATA
*/
biosal_dna_kmer_frequency_block_init(&block, concrete_self->kmer_length,
ephemeral_memory, &concrete_self->transport_codec, 0);
biosal_dna_kmer_frequency_block_unpack(&block, buffer, ephemeral_memory,
&concrete_self->transport_codec);
key = core_memory_pool_allocate(ephemeral_memory, concrete_self->key_length_in_bytes);
kmers = biosal_dna_kmer_frequency_block_kmers(&block);
core_map_iterator_init(&iterator, kmers);
period = 2500000;
raw_kmer = core_memory_pool_allocate(thorium_actor_get_ephemeral_memory(self),
concrete_self->kmer_length + 1);
if (!concrete_self->printed_vertex_size) {
printf("DEBUG VERTEX DELIVERY %d bytes\n", count);
concrete_self->printed_vertex_size = 1;
}
while (core_map_iterator_has_next(&iterator)) {
/*
* add kmers to store
*/
core_map_iterator_next(&iterator, (void **)&packed_kmer, (void **)&frequency);
/* Store the kmer in 2 bit encoding
*/
biosal_dna_kmer_init_empty(&kmer);
biosal_dna_kmer_unpack(&kmer, packed_kmer, concrete_self->kmer_length,
ephemeral_memory,
&concrete_self->transport_codec);
kmer_pointer = &kmer;
if (concrete_self->codec_are_different) {
/*
* Get a copy of the sequence
*/
biosal_dna_kmer_get_sequence(kmer_pointer, raw_kmer, concrete_self->kmer_length,
&concrete_self->transport_codec);
biosal_dna_kmer_init(&encoded_kmer, raw_kmer, &concrete_self->storage_codec,
thorium_actor_get_ephemeral_memory(self));
kmer_pointer = &encoded_kmer;
}
biosal_dna_kmer_pack_store_key(kmer_pointer, key,
concrete_self->kmer_length, &concrete_self->storage_codec,
thorium_actor_get_ephemeral_memory(self));
#ifdef BIOSAL_DEBUG_ISSUE_540
if (strcmp(raw_kmer, "AGCTGGTAGTCATCACCAGACTGGAACAG") == 0
|| strcmp(raw_kmer, "CGCGATCTGTTGCTGGGCCTAACGTGGTA") == 0
|| strcmp(raw_kmer, "TACCACGTTAGGCCCAGCAACAGATCGCG") == 0) {
printf("Examine store key for %s\n", raw_kmer);
core_debugger_examine(key, concrete_self->key_length_in_bytes);
}
#endif
bucket = core_map_get(&concrete_self->table, key);
if (bucket == NULL) {
/* This is the first time that this kmer is seen.
*/
bucket = core_map_add(&concrete_self->table, key);
biosal_assembly_vertex_init(bucket);
#if 0
printf("DEBUG303 ADD_KEY");
biosal_dna_kmer_print(&encoded_kmer, concrete_self->kmer_length,
&concrete_self->storage_codec, ephemeral_memory);
#endif
}
if (concrete_self->codec_are_different) {
biosal_dna_kmer_destroy(&encoded_kmer,
thorium_actor_get_ephemeral_memory(self));
}
biosal_dna_kmer_destroy(&kmer, ephemeral_memory);
biosal_assembly_vertex_increase_coverage_depth(bucket, *frequency);
if (concrete_self->received >= concrete_self->last_received + period) {
printf("%s/%d received %" PRIu64 " kmers so far,"
" store has %" PRIu64 " canonical kmers, %" PRIu64 " kmers\n",
thorium_actor_script_name(self),
thorium_actor_name(self), concrete_self->received,
core_map_size(&concrete_self->table),
2 * core_map_size(&concrete_self->table));
concrete_self->last_received = concrete_self->received;
}
concrete_self->received += *frequency;
}
core_memory_pool_free(ephemeral_memory, key);
core_memory_pool_free(ephemeral_memory, raw_kmer);
core_map_iterator_destroy(&iterator);
biosal_dna_kmer_frequency_block_destroy(&block, thorium_actor_get_ephemeral_memory(self));
thorium_actor_send_reply_empty(self, ACTION_PUSH_KMER_BLOCK_REPLY);
}
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_mark_vertex_as_visited(struct thorium_actor *self, struct thorium_message *message)
{
struct biosal_assembly_graph_store *concrete_self;
char *buffer;
int source;
int path_index;
char *sequence;
struct core_memory_pool *ephemeral_memory;
struct biosal_dna_kmer kmer;
struct biosal_dna_kmer storage_kmer;
struct biosal_assembly_vertex *canonical_vertex;
int position;
void *key;
int force;
force = 1;
position = 0;
concrete_self = thorium_actor_concrete_actor(self);
source = thorium_message_source(message);
buffer = thorium_message_buffer(message);
ephemeral_memory = thorium_actor_get_ephemeral_memory(self);
/*
* Get the kmer.
*/
biosal_dna_kmer_init_empty(&kmer);
position += biosal_dna_kmer_unpack(&kmer, buffer, concrete_self->kmer_length,
ephemeral_memory, &concrete_self->transport_codec);
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);
/*
* Get store key
*/
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);
/* Get vertex. */
canonical_vertex = core_map_get(&concrete_self->table, key);
biosal_dna_kmer_destroy(&kmer, ephemeral_memory);
biosal_dna_kmer_destroy(&storage_kmer, ephemeral_memory);
core_memory_pool_free(ephemeral_memory, key);
core_memory_pool_free(ephemeral_memory, sequence);
position += thorium_message_unpack_int(message, position, &path_index);
/*
* At this point, mark the vertex with flag BIOSAL_VERTEX_FLAG_USED
* so that any other actor that attempt to grab it will have to communicate
* with the actor.
*/
/*
* This is a good idea to always update with the last one.
*/
if (force || !biosal_assembly_vertex_get_flag(canonical_vertex, BIOSAL_VERTEX_FLAG_USED)) {
biosal_assembly_graph_store_mark_as_used(self, canonical_vertex, source, path_index);
}
#if 0
#endif
thorium_actor_send_reply_empty(self, ACTION_MARK_VERTEX_AS_VISITED_REPLY);
}
void biosal_sequence_partitioner_receive(struct thorium_actor *actor, struct thorium_message *message)
{
int tag;
int source;
int count;
void *buffer;
int bytes;
struct biosal_sequence_partitioner *concrete_actor;
struct biosal_partition_command command;
struct thorium_message response;
int command_number;
struct biosal_partition_command *active_command;
int stream_index;
struct biosal_partition_command *command_bucket;
int i;
thorium_message_get_all(message, &tag, &count, &buffer, &source);
concrete_actor = (struct biosal_sequence_partitioner *)thorium_actor_concrete_actor(actor);
if (tag == ACTION_SEQUENCE_PARTITIONER_SET_BLOCK_SIZE) {
thorium_message_unpack_int(message, 0, &concrete_actor->block_size);
thorium_actor_send_reply_empty(actor, ACTION_SEQUENCE_PARTITIONER_SET_BLOCK_SIZE_REPLY);
biosal_sequence_partitioner_verify(actor);
/*
printf("DEBUG biosal_sequence_partitioner_receive received block size\n");
*/
} else if (tag == ACTION_SEQUENCE_PARTITIONER_SET_ENTRY_VECTOR) {
/*
printf("DEBUG biosal_sequence_partitioner_receive unpacking vector, %d bytes\n",
count);
*/
core_vector_init(&concrete_actor->stream_entries, 0);
core_vector_unpack(&concrete_actor->stream_entries, buffer);
/*
printf("DEBUG after unpack\n");
*/
thorium_actor_send_reply_empty(actor, ACTION_SEQUENCE_PARTITIONER_SET_ENTRY_VECTOR_REPLY);
/*
printf("DEBUG biosal_sequence_partitioner_receive received received entry vector\n");
*/
biosal_sequence_partitioner_verify(actor);
} else if (tag == ACTION_SEQUENCE_PARTITIONER_SET_ACTOR_COUNT) {
thorium_message_unpack_int(message, 0, &concrete_actor->store_count);
thorium_actor_send_reply_empty(actor, ACTION_SEQUENCE_PARTITIONER_SET_ACTOR_COUNT_REPLY);
biosal_sequence_partitioner_verify(actor);
/*
printf("DEBUG biosal_sequence_partitioner_receive received received store count\n");
*/
} else if (tag == ACTION_SEQUENCE_PARTITIONER_GET_COMMAND) {
if (core_queue_dequeue(&concrete_actor->available_commands, &command)) {
bytes = biosal_partition_command_pack_size(&command);
/*
printf("DEBUG partitioner has command, packing %d bytes!\n", bytes);
*/
buffer = thorium_actor_allocate(actor, bytes);
biosal_partition_command_pack(&command, buffer);
thorium_message_init(&response, ACTION_SEQUENCE_PARTITIONER_GET_COMMAND_REPLY,
bytes, buffer);
thorium_actor_send_reply(actor, &response);
/* store the active command
*/
command_number = biosal_partition_command_name(&command);
command_bucket = (struct biosal_partition_command *)core_map_add(&concrete_actor->active_commands,
&command_number);
*command_bucket = command;
/* there may be other command available too !
*/
}
} else if (tag == ACTION_SEQUENCE_PARTITIONER_GET_COMMAND_REPLY_REPLY) {
/*
* take the name of the command, find it in the active
* command, generate a new command, and send ACTION_SEQUENCE_PARTITIONER_COMMAND_IS_READY
* as a reply
*/
thorium_message_unpack_int(message, 0, &command_number);
active_command = core_map_get(&concrete_actor->active_commands,
&command_number);
if (active_command == NULL) {
return;
}
stream_index = biosal_partition_command_stream_index(active_command);
active_command = NULL;
core_map_delete(&concrete_actor->active_commands,
&command_number);
biosal_sequence_partitioner_generate_command(actor, stream_index);
if (core_map_size(&concrete_actor->active_commands) == 0
&& core_queue_size(&concrete_actor->available_commands) == 0) {
thorium_actor_send_reply_empty(actor, ACTION_SEQUENCE_PARTITIONER_FINISHED);
}
} else if (tag == ACTION_ASK_TO_STOP
&& source == thorium_actor_supervisor(actor)) {
#ifdef BIOSAL_SEQUENCE_PARTITIONER_DEBUG
printf("DEBUG biosal_sequence_partitioner_receive ACTION_ASK_TO_STOP\n");
#endif
thorium_actor_send_to_self_empty(actor,
ACTION_STOP);
} else if (tag == ACTION_SEQUENCE_PARTITIONER_PROVIDE_STORE_ENTRY_COUNTS_REPLY) {
/* generate commands
*/
for (i = 0; i < core_vector_size(&concrete_actor->stream_entries); i++) {
biosal_sequence_partitioner_generate_command(actor, i);
}
}
}
void biosal_coverage_distribution_receive(struct thorium_actor *self, struct thorium_message *message)
{
int tag;
struct core_map map;
struct core_map_iterator iterator;
int *coverage_from_message;
uint64_t *count_from_message;
uint64_t *frequency;
int count;
void *buffer;
struct biosal_coverage_distribution *concrete_actor;
int name;
int source;
struct core_memory_pool *ephemeral_memory;
ephemeral_memory = thorium_actor_get_ephemeral_memory(self);
name = thorium_actor_name(self);
source = thorium_message_source(message);
concrete_actor = (struct biosal_coverage_distribution *)thorium_actor_concrete_actor(self);
tag = thorium_message_action(message);
count = thorium_message_count(message);
buffer = thorium_message_buffer(message);
if (tag == ACTION_PUSH_DATA) {
core_map_init(&map, 0, 0);
core_map_set_memory_pool(&map, ephemeral_memory);
core_map_unpack(&map, buffer);
core_map_iterator_init(&iterator, &map);
while (core_map_iterator_has_next(&iterator)) {
core_map_iterator_next(&iterator, (void **)&coverage_from_message,
(void **)&count_from_message);
#ifdef BIOSAL_COVERAGE_DISTRIBUTION_DEBUG
thorium_actor_log(self, "DEBUG DATA %d %d\n", (int)*coverage_from_message, (int)*count_from_message);
#endif
frequency = core_map_get(&concrete_actor->distribution, coverage_from_message);
if (frequency == NULL) {
frequency = core_map_add(&concrete_actor->distribution, coverage_from_message);
(*frequency) = 0;
}
(*frequency) += (*count_from_message);
}
core_map_iterator_destroy(&iterator);
thorium_actor_send_reply_empty(self, ACTION_PUSH_DATA_REPLY);
concrete_actor->actual++;
thorium_actor_log(self, "distribution/%d receives coverage data from producer/%d, %d entries / %d bytes %d/%d\n",
name, source, (int)core_map_size(&map), count,
concrete_actor->actual, concrete_actor->expected);
if (concrete_actor->expected != 0 && concrete_actor->expected == concrete_actor->actual) {
thorium_actor_log(self, "received everything %d/%d\n", concrete_actor->actual, concrete_actor->expected);
biosal_coverage_distribution_write_distribution(self);
thorium_actor_send_empty(self, concrete_actor->source,
ACTION_NOTIFY);
}
core_map_destroy(&map);
} else if (tag == ACTION_ASK_TO_STOP) {
biosal_coverage_distribution_ask_to_stop(self, message);
} else if (tag == ACTION_SET_EXPECTED_MESSAGE_COUNT) {
concrete_actor->source = source;
thorium_message_unpack_int(message, 0, &concrete_actor->expected);
thorium_actor_log(self, "distribution %d expects %d messages\n",
thorium_actor_name(self),
concrete_actor->expected);
thorium_actor_send_reply_empty(self, ACTION_SET_EXPECTED_MESSAGE_COUNT_REPLY);
}
}
void biosal_coverage_distribution_write_distribution(struct thorium_actor *self)
{
struct core_map_iterator iterator;
int *coverage;
uint64_t *canonical_frequency;
uint64_t frequency;
struct biosal_coverage_distribution *concrete_actor;
struct core_vector coverage_values;
struct core_vector_iterator vector_iterator;
struct core_buffered_file_writer descriptor;
struct core_buffered_file_writer descriptor_canonical;
struct core_string file_name;
struct core_string canonical_file_name;
int argc;
char **argv;
int name;
char *directory_name;
name = thorium_actor_name(self);
argc = thorium_actor_argc(self);
argv = thorium_actor_argv(self);
directory_name = biosal_command_get_output_directory(argc, argv);
/* Create the directory if it does not exist
*/
if (!core_directory_verify_existence(directory_name)) {
core_directory_create(directory_name);
}
core_string_init(&file_name, "");
core_string_append(&file_name, directory_name);
core_string_append(&file_name, "/");
core_string_append(&file_name, BIOSAL_COVERAGE_DISTRIBUTION_DEFAULT_OUTPUT_FILE);
core_string_init(&canonical_file_name, "");
core_string_append(&canonical_file_name, directory_name);
core_string_append(&canonical_file_name, "/");
core_string_append(&canonical_file_name, BIOSAL_COVERAGE_DISTRIBUTION_DEFAULT_OUTPUT_FILE_CANONICAL);
core_buffered_file_writer_init(&descriptor, core_string_get(&file_name));
core_buffered_file_writer_init(&descriptor_canonical, core_string_get(&canonical_file_name));
concrete_actor = (struct biosal_coverage_distribution *)thorium_actor_concrete_actor(self);
core_vector_init(&coverage_values, sizeof(int));
core_map_iterator_init(&iterator, &concrete_actor->distribution);
#ifdef BIOSAL_COVERAGE_DISTRIBUTION_DEBUG
thorium_actor_log(self, "map size %d\n", (int)core_map_size(&concrete_actor->distribution));
#endif
while (core_map_iterator_has_next(&iterator)) {
core_map_iterator_next(&iterator, (void **)&coverage, (void **)&canonical_frequency);
#ifdef BIOSAL_COVERAGE_DISTRIBUTION_DEBUG
thorium_actor_log(self, "DEBUG COVERAGE %d FREQUENCY %" PRIu64 "\n", *coverage, *frequency);
#endif
core_vector_push_back(&coverage_values, coverage);
}
core_map_iterator_destroy(&iterator);
core_vector_sort_int(&coverage_values);
#ifdef BIOSAL_COVERAGE_DISTRIBUTION_DEBUG
thorium_actor_log(self, "after sort ");
core_vector_print_int(&coverage_values);
thorium_actor_log(self, "\n");
#endif
core_vector_iterator_init(&vector_iterator, &coverage_values);
#if 0
core_buffered_file_writer_printf(&descriptor_canonical, "Coverage\tFrequency\n");
#endif
core_buffered_file_writer_printf(&descriptor, "Coverage\tFrequency\n");
#ifdef BIOSAL_COVERAGE_DISTRIBUTION_DEBUG
#endif
while (core_vector_iterator_has_next(&vector_iterator)) {
core_vector_iterator_next(&vector_iterator, (void **)&coverage);
canonical_frequency = (uint64_t *)core_map_get(&concrete_actor->distribution, coverage);
frequency = 2 * *canonical_frequency;
core_buffered_file_writer_printf(&descriptor_canonical, "%d %" PRIu64 "\n",
*coverage,
*canonical_frequency);
core_buffered_file_writer_printf(&descriptor, "%d\t%" PRIu64 "\n",
*coverage,
frequency);
}
core_vector_destroy(&coverage_values);
core_vector_iterator_destroy(&vector_iterator);
thorium_actor_log(self, "distribution %d wrote %s\n", name, core_string_get(&file_name));
thorium_actor_log(self, "distribution %d wrote %s\n", name, core_string_get(&canonical_file_name));
core_buffered_file_writer_destroy(&descriptor);
core_buffered_file_writer_destroy(&descriptor_canonical);
core_string_destroy(&file_name);
core_string_destroy(&canonical_file_name);
}
