int thorium_transport_receive(struct thorium_transport *self, struct thorium_message *message)
{
int value;
if (self->transport_interface == NULL) {
return 0;
}
value = self->transport_interface->receive(self, message);
if (value) {
#ifdef THORIUM_TRANSPORT_DEBUG
printf("TRANSPORT RECEIVE Source %d Destination %d Tag %d Count %d\n",
thorium_message_source_node(message),
thorium_message_destination_node(message),
thorium_message_action(message),
thorium_message_count(message));
#endif
if (core_bitmap_get_bit_uint32_t(&self->flags, FLAG_PRINT_TRANSPORT_EVENTS)) {
thorium_transport_print_event(self, EVENT_TYPE_RECEIVE, message);
}
}
return value;
}
int thorium_transport_send(struct thorium_transport *self, struct thorium_message *message)
{
int value;
if (self->transport_interface == NULL) {
return 0;
}
/*
* Send the message through the mock transport which is
* a transport profiler.
*/
if (core_bitmap_get_bit_uint32_t(&self->flags, FLAG_PROFILE)) {
thorium_transport_profiler_send_mock(&self->transport_profiler, message);
}
value = self->transport_interface->send(self, message);
if (value) {
#ifdef THORIUM_TRANSPORT_DEBUG
printf("TRANSPORT SEND Source %d Destination %d Tag %d Count %d\n",
thorium_message_source_node(message),
thorium_message_destination_node(message),
thorium_message_action(message),
thorium_message_count(message));
#endif
++self->active_request_count;
if (core_bitmap_get_bit_uint32_t(&self->flags, FLAG_PRINT_TRANSPORT_EVENTS)) {
thorium_transport_print_event(self, EVENT_TYPE_SEND, message);
}
}
return value;
}
void process_ping(struct thorium_actor *self, struct thorium_message *message)
{
int count;
char *buffer;
int buffer_size;
uint64_t *bucket;
uint64_t expected_checksum;
uint64_t actual_checksum;
struct process *concrete_self;
concrete_self = (struct process *)thorium_actor_concrete_actor(self);
buffer = thorium_message_buffer(message);
count = thorium_message_count(message);
buffer_size = count - sizeof(expected_checksum);
bucket = (uint64_t *)(buffer + buffer_size);
expected_checksum = *bucket;
actual_checksum = core_hash_data_uint64_t(buffer, buffer_size, SEED);
if (expected_checksum != actual_checksum) {
printf("TRANSPORT FAILED source: %d (%d) destination: %d (%d) tag: ACTION_PING count: %d"
" expected_checksum: %" PRIu64 " actual_checksum: %" PRIu64 "\n",
thorium_message_source(message),
thorium_message_source_node(message),
thorium_message_destination(message),
thorium_message_destination_node(message),
count,
expected_checksum, actual_checksum);
++concrete_self->failed;
} else {
++concrete_self->passed;
}
thorium_actor_send_reply_empty(self, ACTION_PING_REPLY);
}
/* \see http://www.mpich.org/static/docs/v3.1/www3/MPI_Isend.html */
int thorium_mpi1_pt2pt_transport_send(struct thorium_transport *self, struct thorium_message *message)
{
struct thorium_mpi1_pt2pt_transport *concrete_self;
char *buffer;
int count;
int destination;
int tag;
MPI_Request *request;
struct thorium_mpi1_pt2pt_active_request active_request;
int worker;
int result;
concrete_self = thorium_transport_get_concrete_transport(self);
worker = thorium_message_worker(message);
buffer = thorium_message_buffer(message);
count = thorium_message_count(message);
destination = thorium_message_destination_node(message);
tag = DUMMY_TAG;
thorium_mpi1_pt2pt_active_request_init(&active_request, buffer, worker);
request = thorium_mpi1_pt2pt_active_request_request(&active_request);
CORE_DEBUGGER_ASSERT(buffer == NULL || count > 0);
/* get return value */
result = MPI_Isend(buffer, count, concrete_self->datatype, destination, tag,
concrete_self->comm, request);
if (result != MPI_SUCCESS) {
return 0;
}
/* store the MPI_Request to test it later to know when
* the buffer can be reused
*/
/* \see http://blogs.cisco.com/performance/mpi_request_free-is-evil/
*/
/*MPI_Request_free(&request);*/
core_fast_queue_enqueue(&concrete_self->active_requests, &active_request);
return 1;
}
void thorium_transport_print_event(struct thorium_transport *self, int type, struct thorium_message *message)
{
char *description;
int count;
int source_rank;
int destination_rank;
uint64_t time;
description = EVENT_STRING_SEND;
if (type == EVENT_TYPE_RECEIVE)
description = EVENT_STRING_RECEIVE;
count = thorium_message_count(message);
source_rank = thorium_message_source_node(message);
destination_rank = thorium_message_destination_node(message);
time = core_timer_get_nanoseconds(&self->timer);
time -= self->start_time;
printf("thorium_transport print_event time_nanoseconds= %" PRIu64 " type= %s source= %d destination= %d count= %d\n",
time, description,
source_rank, destination_rank, count);
}
void thorium_message_multiplexer_flush(struct thorium_message_multiplexer *self, int index, int force)
{
char *buffer;
struct thorium_message message;
int tag;
int count;
int current_size;
int maximum_size;
struct thorium_multiplexed_buffer *multiplexed_buffer;
int destination_node;
/*
int elapsed;
int message_count;
*/
if (CORE_BITMAP_GET_FLAG(self->flags, FLAG_DISABLED)) {
return;
}
#ifdef THORIUM_MULTIPLEXER_TRACK_BUFFERS_WITH_CONTENT
#ifdef CORE_DEBUGGER_ASSERT_ENABLED
if (!(core_set_find(&self->buffers_with_content, &index))) {
multiplexed_buffer = core_vector_at(&self->buffers, index);
thorium_printf("index %d has no content\n", index);
thorium_multiplexed_buffer_print(multiplexed_buffer);
}
#endif
CORE_DEBUGGER_ASSERT(core_set_find(&self->buffers_with_content, &index));
#endif
multiplexed_buffer = core_vector_at(&self->buffers, index);
current_size = thorium_multiplexed_buffer_current_size(multiplexed_buffer);
maximum_size = thorium_multiplexed_buffer_maximum_size(multiplexed_buffer);
/*
* The buffer was still in the timeline, but it was flushed elsewhere.
*/
if (current_size == 0) {
return;
/*
if (force == FORCE_NO && current_size < maximum_size) {
return;
} else if (force == FORCE_YES_TIME) {
elapsed = core_timer_get_nanoseconds(&self->timer) - multiplexed_buffer->timestamp_;
if (elapsed < self->timeout_in_nanoseconds) {
return;
}
} else if (force == FORCE_YES_DOA) {
message_count = multiplexed_buffer->message_count_;
if (message_count < self->degree_of_aggregation_limit) {
return;
}
*/
}
#ifdef CORE_DEBUGGER_ASSERT_ENABLED
if (current_size <= 0)
thorium_printf("current_size %d maximum_size %d\n", current_size, maximum_size);
#endif
CORE_DEBUGGER_ASSERT(current_size > 0);
buffer = thorium_multiplexed_buffer_buffer(multiplexed_buffer);
count = current_size + THORIUM_MESSAGE_METADATA_SIZE;
tag = ACTION_MULTIPLEXER_MESSAGE;
/*
* This count does not include metadata for the final big message.
*
* Avoid this copy by using an array of pointers in the first place.
*/
destination_node = index;
thorium_message_init(&message, tag, count, buffer);
thorium_message_set_destination(&message,
destination_node);
thorium_message_set_source(&message,
thorium_node_name(self->node));
/*
* Mark the message so that the buffer is eventually sent back here
* for recycling.
*/
thorium_message_set_worker(&message, thorium_worker_name(self->worker));
thorium_message_write_metadata(&message);
#ifdef DEBUG_MULTIPLEXER_FLUSH
thorium_printf("DEBUG_MULTIPLEXER thorium_message_multiplexer_flush index %d buffer %p force %d current_size %d maximum_size %d"
" destination_node %d\n",
index, buffer, force,
current_size, maximum_size,
thorium_message_destination_node(&message));
thorium_printf("message in flush\n");
thorium_multiplexed_buffer_print(multiplexed_buffer);
thorium_message_print(&message);
#endif
CORE_DEBUGGER_ASSERT_NOT_NULL(self->worker);
/*
* Make a copy of the buffer because the multiplexer does not have communication buffers.
*/
thorium_worker_enqueue_outbound_message(self->worker, &message);
/*
thorium_printf("MULTIPLEXER FLUSH\n");
*/
++self->real_message_count;
thorium_message_destroy(&message);
thorium_multiplexed_buffer_reset(multiplexed_buffer);
#ifdef THORIUM_MULTIPLEXER_TRACK_BUFFERS_WITH_CONTENT
core_set_delete(&self->buffers_with_content, &index);
#endif
}
/*
* Returns 1 if the message was demultiplexed.
*
* This is O(1) in regard to the number of thorium nodes.
*/
int thorium_message_multiplexer_demultiplex(struct thorium_message_multiplexer *self,
struct thorium_message *message)
{
/*
* Algorithm:
*
* get tag.
* if tag is ACTION_MULTIPLEXER_MESSAGE
* for every enclosed message
* call thorium_node_prepare_received_message
* call thorium_node_dispatch_message()
* return 1
*
* return 0
*/
int count;
char *buffer;
struct thorium_message new_message;
int new_count;
void *new_buffer;
int position;
struct core_memory_pool *pool;
int messages;
int tag;
int source_node;
int destination_node;
int current_node;
int routing_destination;
#ifdef DEBUG_MULTIPLEXER
thorium_printf("demultiplex message\n");
thorium_message_print(message);
#endif
if (CORE_BITMAP_GET_FLAG(self->flags, FLAG_DISABLED)) {
return 0;
}
tag = thorium_message_action(message);
if (tag != ACTION_MULTIPLEXER_MESSAGE) {
return 0;
}
/*
thorium_printf("MULTIPLEXER demultiplex\n");
*/
messages = 0;
tracepoint(thorium_node, demultiplex_enter, self->node->name,
self->node->tick, messages);
source_node = thorium_message_source_node(message);
destination_node = thorium_message_destination_node(message);
/*
* Remove the metadata from the count.
*/
thorium_message_remove_metadata_from_count(message);
count = thorium_message_count(message);
buffer = thorium_message_buffer(message);
pool = thorium_worker_get_outbound_message_memory_pool(self->worker);
position = 0;
/*
* Inject a message for each enclosed message.
*/
while (position < count) {
core_memory_copy(&new_count, buffer + position, sizeof(new_count));
position += sizeof(new_count);
new_buffer = core_memory_pool_allocate(pool, new_count);
core_memory_copy(new_buffer, buffer + position, new_count);
thorium_message_init_with_nodes(&new_message, new_count, new_buffer,
source_node, destination_node);
thorium_node_prepare_received_message(self->node, &new_message);
/*
* For these demultiplexed messages, there are 2 outcomes:
*
* 1) the message must be delivered locally;
* 2) the message must be forward because this is a middle node in
* the route.
*/
/*
thorium_printf("demultiplex: \n");
thorium_message_print(&new_message);
thorium_printf("\n");
*/
/*
* Mark the message for recycling.
*/
thorium_message_set_worker(&new_message, thorium_worker_name(self->worker));
#ifdef CORE_DEBUGGER_ASSERT_ENABLED
if (thorium_message_action(&new_message) == ACTION_INVALID) {
thorium_printf("Error invalid action DEMUL Multiplexer position %d count %d new_count %d\n",
position, count, new_count);
thorium_message_print(&new_message);
}
#endif
CORE_DEBUGGER_ASSERT(thorium_message_action(&new_message) != ACTION_INVALID);
/*
thorium_printf("DEMULTIPLEX_MESSAGE\n");
*/
/*
thorium_printf("demultiplex, local delivery: \n");
thorium_message_print(&new_message);
*/
current_node = self->node->name;
routing_destination = new_message.routing_destination;
CORE_DEBUGGER_ASSERT(routing_destination >= 0);
/*
* This is a local delivery, nothing to see here.
*/
if (routing_destination == current_node) {
thorium_worker_send_local_delivery(self->worker, &new_message);
/*
* Otherwise, get the next node in the route and send the
* payload there since we can not do anything with it here.
*/
} else {
/*
* Export the message to another node.
* To do this, use an exporter worker.
*/
thorium_worker_send_for_multiplexer(self->worker,
&new_message);
}
/*
thorium_message_destroy(&new_message);
*/
position += new_count;
++messages;
}
CORE_DEBUGGER_ASSERT(messages > 0);
#ifdef DEBUG_MULTIPLEXER
thorium_printf("thorium_message_multiplexer_demultiplex %d messages\n",
messages);
#endif
tracepoint(thorium_node, demultiplex_exit, self->node->name,
self->node->tick, messages);
return 1;
}
/*
* Returns 1 if the message was multiplexed.
*
* This is O(1) in regard to the number of thorium nodes.
*/
int thorium_message_multiplexer_multiplex(struct thorium_message_multiplexer *self,
struct thorium_message *message)
{
/*
* If buffer is full, use thorium_node_send_with_transport
*
* get count
*
* if count is below or equal to the threshold
* multiplex the message.
* return 1
*
* return 0
*/
int count;
int current_size;
int maximum_size;
int action;
struct core_memory_pool *pool;
void *new_buffer;
int new_count;
void *buffer;
int destination_node;
int destination_actor;
int new_size;
int required_size;
struct thorium_multiplexed_buffer *real_multiplexed_buffer;
uint64_t time;
int next_node_in_route;
int source_node;
int current_node;
#ifdef DEBUG_MULTIPLEXER
thorium_printf("multiplex\n");
thorium_message_print(message);
#endif
if (CORE_BITMAP_GET_FLAG(self->flags, FLAG_DISABLED)) {
return 0;
}
action = thorium_message_action(message);
CORE_DEBUGGER_ASSERT(action != ACTION_INVALID);
#ifdef THORIUM_MULTIPLEXER_USE_ACTIONS_TO_SKIP
/*
* Don't multiplex already-multiplexed messages.
*/
if (thorium_multiplexer_policy_is_action_to_skip(self->policy, action)) {
return 0;
}
#endif
#ifdef CONFIG_MULTIPLEXER_USE_DECISION_MAKER
thorium_message_multiplexer_update_timeout(self);
#endif
++self->original_message_count;
count = thorium_message_count(message);
destination_node = thorium_message_destination_node(message);
source_node = message->routing_source;
current_node = self->node->name;
next_node_in_route = thorium_router_get_next_rank_in_route(&self->router,
source_node, current_node, destination_node);
/*
thorium_message_print(message);
thorium_printf("router: source_node %d current_node %d next_node_in_route %d"
" destination_node %d\n",
source_node, current_node,
next_node_in_route, destination_node);
*/
#ifdef CONFIG_USE_TOPOLOGY_AWARE_AGGREGATION
/*
* The next node in the route for this message is
* next_node_in_route.
*/
destination_node = next_node_in_route;
#endif
CORE_DEBUGGER_ASSERT(source_node >= 0);
real_multiplexed_buffer = core_vector_at(&self->buffers, destination_node);
CORE_DEBUGGER_ASSERT(real_multiplexed_buffer != NULL);
required_size = thorium_multiplexed_buffer_required_size(real_multiplexed_buffer, count);
buffer = thorium_message_buffer(message);
destination_actor = thorium_message_destination(message);
#ifdef DEBUG_MULTIPLEXER
thorium_printf("DEBUG multiplex count %d required_size %d action %x\n",
count, required_size, action);
#endif
/*
* Don't multiplex non-actor messages.
*/
if (destination_actor == THORIUM_ACTOR_NOBODY) {
return 0;
}
#ifdef CORE_DEBUGGER_ASSERT
if (real_multiplexed_buffer == NULL) {
thorium_printf("Error action %d destination_node %d destination_actor %d\n", action, destination_node,
destination_actor);
}
#endif
current_size = thorium_multiplexed_buffer_current_size(real_multiplexed_buffer);
maximum_size = thorium_multiplexed_buffer_maximum_size(real_multiplexed_buffer);
/*
* Don't multiplex large messages.
*/
if (required_size > maximum_size) {
#ifdef DEBUG_MULTIPLEXER
thorium_printf("too large required_size %d maximum_size %d\n", required_size, maximum_size);
#endif
return 0;
}
/*
thorium_printf("MULTIPLEX_MESSAGE\n");
*/
new_size = current_size + required_size;
/*
* Flush now if there is no space left for the <required_size> bytes
*/
if (new_size > maximum_size) {
#ifdef DEBUG_MULTIPLEXER
thorium_printf("thorium_message_multiplexer: must FLUSH thorium_message_multiplexer_multiplex required_size %d new_size %d maximum_size %d\n",
required_size, new_size, maximum_size);
#endif
thorium_message_multiplexer_flush(self, destination_node, FORCE_YES_SIZE);
current_size = thorium_multiplexed_buffer_current_size(real_multiplexed_buffer);
CORE_DEBUGGER_ASSERT(current_size == 0);
}
time = core_timer_get_nanoseconds(&self->timer);
/*
* If the buffer is empty before adding the data, it means that it is not
* in the list of buffers with content and it must be added.
*/
if (current_size == 0) {
thorium_multiplexed_buffer_set_time(real_multiplexed_buffer, time);
#ifdef THORIUM_MULTIPLEXER_TRACK_BUFFERS_WITH_CONTENT
core_set_add(&self->buffers_with_content, &destination_node);
#endif
/*
* Add it to the timeline.
*/
#ifdef THORIUM_MULTIPLEXER_USE_TREE
core_red_black_tree_add_key_and_value(&self->timeline, &time, &destination_node);
#elif defined(THORIUM_MULTIPLEXER_USE_HEAP)
core_binary_heap_insert(&self->timeline, &time, &destination_node);
#elif defined(THORIUM_MULTIPLEXER_USE_QUEUE)
core_queue_enqueue(&self->timeline, &destination_node);
#endif
}
/*
* The allocation of buffer is lazy.
* The current worker is an exporter of small message for the destination
* "destination_node".
*/
if (thorium_multiplexed_buffer_buffer(real_multiplexed_buffer) == NULL) {
pool = thorium_worker_get_outbound_message_memory_pool(self->worker);
new_count = self->buffer_size_in_bytes + THORIUM_MESSAGE_METADATA_SIZE;
new_buffer = core_memory_pool_allocate(pool, new_count);
thorium_multiplexed_buffer_set_buffer(real_multiplexed_buffer, new_buffer);
}
/*
thorium_printf("DEBUG worker_latency %d ns\n",
thorium_worker_latency(self->worker));
*/
thorium_multiplexed_buffer_append(real_multiplexed_buffer, count, buffer, time);
/*
* Try to flush. This only flushes something if the buffer is full.
*/
if (thorium_message_multiplexer_buffer_is_ready(self, real_multiplexed_buffer)) {
/*
* Try to flush here too. This is required in order to satisfy the
* technical requirement of a DOA limit.
*
* Obviously, don't flush if there is some outbound traffic congestion.
* Otherwise, there will be too many messages on the network.
*/
if (!thorium_worker_has_outbound_traffic_congestion(self->worker)) {
thorium_message_multiplexer_flush(self, destination_node, FORCE_YES_SIZE);
}
}
/*
* Verify invariant.
*/
CORE_DEBUGGER_ASSERT(thorium_multiplexed_buffer_current_size(real_multiplexed_buffer)<= maximum_size);
/*
* Inject the buffer into the worker too.
*/
return 1;
}