int thorium_worker_get_sum_of_received_actor_messages(struct thorium_worker *worker)
{
int value;
struct core_map_iterator iterator;
int actor_name;
int messages;
struct thorium_actor *actor;
core_map_iterator_init(&iterator, &worker->actors);
value = 0;
while (core_map_iterator_get_next_key_and_value(&iterator, &actor_name, NULL)) {
actor = thorium_node_get_actor_from_name(worker->node, actor_name);
if (actor == NULL) {
continue;
}
messages = thorium_actor_get_sum_of_received_messages(actor);
value += messages;
}
core_map_iterator_destroy(&iterator);
return value;
}
int thorium_worker_get_producer_count(struct thorium_worker *worker, struct thorium_balancer *scheduler)
{
struct core_map_iterator iterator;
int name;
struct thorium_actor *actor;
int count;
count = 0;
core_map_iterator_init(&iterator, &worker->actors);
while (core_map_iterator_get_next_key_and_value(&iterator, &name, NULL)) {
actor = thorium_node_get_actor_from_name(worker->node, name);
if (actor == NULL) {
continue;
}
if (thorium_balancer_get_actor_production(scheduler, actor) > 0) {
++count;
}
}
core_map_iterator_destroy(&iterator);
return count;
}
void thorium_balancer_set_actor_worker(struct thorium_balancer *self, int name, int worker_index)
{
struct thorium_actor *actor;
actor = thorium_node_get_actor_from_name(self->pool->node, name);
if (actor != NULL)
thorium_actor_set_assigned_worker(actor, worker_index);
}
void thorium_worker_pool_assign_worker_to_actor(struct thorium_worker_pool *pool, int name)
{
int worker_index;
#ifdef THORIUM_WORKER_POOL_USE_LEAST_BUSY
int score;
#endif
#ifdef THORIUM_WORKER_POOL_USE_SCRIPT_ROUND_ROBIN
int script;
struct thorium_actor *actor;
#endif
/*
printf("DEBUG Needs to do actor placement\n");
*/
/* assign this actor to the least busy actor
*/
worker_index = -1;
#ifdef THORIUM_WORKER_POOL_USE_LEAST_BUSY
worker_index = thorium_balancer_select_worker_least_busy(&pool->scheduler, &score);
#elif defined(THORIUM_WORKER_POOL_USE_SCRIPT_ROUND_ROBIN)
actor = thorium_node_get_actor_from_name(pool->node, name);
/*
* Somehow this actor dead a while ago.
*/
if (actor == NULL) {
return;
}
/* The actor can't be dead if it does not have an initial
* placement...
*/
CORE_DEBUGGER_ASSERT(actor != NULL);
script = thorium_actor_script(actor);
worker_index = thorium_balancer_select_worker_script_round_robin(&pool->balancer, script);
#endif
CORE_DEBUGGER_ASSERT(worker_index >= 0);
#ifdef THORIUM_WORKER_POOL_DEBUG
printf("ASSIGNING %d to %d\n", name, worker_index);
#endif
thorium_balancer_set_actor_worker(&pool->balancer, name, worker_index);
}
int thorium_balancer_get_actor_worker(struct thorium_balancer *self, int name)
{
int worker_index;
struct thorium_actor *actor;
worker_index = THORIUM_WORKER_NONE;
actor = thorium_node_get_actor_from_name(self->pool->node, name);
if (actor != NULL)
worker_index = thorium_actor_assigned_worker(actor);
return worker_index;
}
void thorium_balancer_migrate(struct thorium_balancer *self, struct thorium_migration *migration)
{
struct thorium_worker *old_worker_object;
struct thorium_worker *new_worker_object;
int old_worker;
int new_worker;
int actor_name;
struct thorium_actor *actor;
old_worker = thorium_migration_get_old_worker(migration);
new_worker = thorium_migration_get_new_worker(migration);
actor_name = thorium_migration_get_actor(migration);
actor = thorium_node_get_actor_from_name(thorium_worker_pool_get_node(self->pool), actor_name);
#ifdef THORIUM_SCHEDULER_ENABLE_VERBOSITY
printf("MIGRATION node %d migrated actor %d from worker %d to worker %d\n",
thorium_node_name(thorium_worker_pool_get_node(self->pool)), actor_name,
old_worker, new_worker);
#endif
old_worker_object = thorium_worker_pool_get_worker(self->pool, old_worker);
new_worker_object = thorium_worker_pool_get_worker(self->pool, new_worker);
/* evict the actor from the old worker
*/
thorium_worker_evict_actor(old_worker_object, actor_name);
/* Redirect messages for this actor to the
* new worker
*/
thorium_actor_set_assigned_worker(actor, new_worker);
#ifdef THORIUM_WORKER_POOL_DEBUG_MIGRATION
printf("ROUTE actor %d -> worker %d\n", actor_name, new_worker);
#endif
thorium_worker_enqueue_actor_special(new_worker_object, actor);
}
int thorium_worker_pool_give_message_to_actor(struct thorium_worker_pool *pool, struct thorium_message *message)
{
int destination;
struct thorium_actor *actor;
struct thorium_worker *affinity_worker;
int worker_index;
int name;
int dead;
/*
void *buffer;
buffer = thorium_message_buffer(message);
*/
destination = thorium_message_destination(message);
actor = thorium_node_get_actor_from_name(pool->node, destination);
if (actor == NULL) {
#ifdef THORIUM_WORKER_POOL_DEBUG_DEAD_CHANNEL
printf("DEAD LETTER CHANNEL...\n");
#endif
core_fast_queue_enqueue(&pool->messages_for_triage, message);
return 0;
}
dead = thorium_actor_dead(actor);
/* If the actor is dead, don't use it.
*/
if (dead) {
core_fast_queue_enqueue(&pool->messages_for_triage, message);
return 0;
}
name = thorium_actor_name(actor);
/* give the message to the actor
*/
if (!thorium_actor_enqueue_mailbox_message(actor, message)) {
#ifdef THORIUM_WORKER_POOL_DEBUG_MESSAGE_BUFFERING
printf("DEBUG897 could not enqueue message, buffering...\n");
#endif
core_fast_queue_enqueue(&pool->inbound_message_queue_buffer, message);
} else {
/*
* At this point, the message has been pushed to the actor.
* Now, the actor must be scheduled on a worker.
*/
/*
printf("DEBUG message was enqueued in actor mailbox\n");
*/
/* Check if the actor is already assigned to a worker
*/
worker_index = thorium_balancer_get_actor_worker(&pool->balancer, name);
/* If not, ask the scheduler to assign the actor to a worker
*/
if (worker_index < 0) {
thorium_worker_pool_assign_worker_to_actor(pool, name);
worker_index = thorium_balancer_get_actor_worker(&pool->balancer, name);
}
affinity_worker = thorium_worker_pool_get_worker(pool, worker_index);
/*
printf("DEBUG actor has an assigned worker\n");
*/
/*
* Push the actor on the scheduling queue of the worker.
* If that fails, queue the actor.
*/
if (!thorium_worker_enqueue_actor(affinity_worker, actor)) {
core_fast_queue_enqueue(&pool->scheduled_actor_queue_buffer, &actor);
}
}
return 1;
}
void thorium_worker_print_actors(struct thorium_worker *worker, struct thorium_balancer *scheduler)
{
struct core_map_iterator iterator;
int name;
int count;
struct thorium_actor *actor;
int producers;
int consumers;
int received;
int difference;
int script;
struct core_map distribution;
int frequency;
struct thorium_script *script_object;
int dead;
int node_name;
int worker_name;
int previous_amount;
node_name = thorium_node_name(worker->node);
worker_name = worker->name;
core_map_iterator_init(&iterator, &worker->actors);
printf("node/%d worker/%d %d queued messages, received: %d busy: %d load: %f ring: %d scheduled actors: %d/%d\n",
node_name, worker_name,
thorium_worker_get_scheduled_message_count(worker),
thorium_worker_get_sum_of_received_actor_messages(worker),
thorium_worker_is_busy(worker),
thorium_worker_get_scheduling_epoch_load(worker),
core_fast_ring_size_from_producer(&worker->actors_to_schedule),
thorium_scheduler_size(&worker->scheduler),
(int)core_map_size(&worker->actors));
core_map_init(&distribution, sizeof(int), sizeof(int));
while (core_map_iterator_get_next_key_and_value(&iterator, &name, NULL)) {
actor = thorium_node_get_actor_from_name(worker->node, name);
if (actor == NULL) {
continue;
}
dead = thorium_actor_dead(actor);
if (dead) {
continue;
}
count = thorium_actor_get_mailbox_size(actor);
received = thorium_actor_get_sum_of_received_messages(actor);
producers = core_map_size(thorium_actor_get_received_messages(actor));
consumers = core_map_size(thorium_actor_get_sent_messages(actor));
previous_amount = 0;
core_map_get_value(&worker->actor_received_messages, &name,
&previous_amount);
difference = received - previous_amount;;
if (!core_map_update_value(&worker->actor_received_messages, &name,
&received)) {
core_map_add_value(&worker->actor_received_messages, &name, &received);
}
printf(" [%s/%d] mailbox: %d received: %d (+%d) producers: %d consumers: %d\n",
thorium_actor_script_name(actor),
name, count, received,
difference,
producers, consumers);
script = thorium_actor_script(actor);
if (core_map_get_value(&distribution, &script, &frequency)) {
++frequency;
core_map_update_value(&distribution, &script, &frequency);
} else {
frequency = 1;
core_map_add_value(&distribution, &script, &frequency);
}
}
/*printf("\n");*/
core_map_iterator_destroy(&iterator);
core_map_iterator_init(&iterator, &distribution);
printf("node/%d worker/%d Frequency list\n", node_name, worker_name);
while (core_map_iterator_get_next_key_and_value(&iterator, &script, &frequency)) {
script_object = thorium_node_find_script(worker->node, script);
CORE_DEBUGGER_ASSERT(script_object != NULL);
printf("node/%d worker/%d Frequency %s => %d\n",
node_name,
worker->name,
thorium_script_name(script_object),
frequency);
}
core_map_iterator_destroy(&iterator);
core_map_destroy(&distribution);
}
void thorium_worker_check_production(struct thorium_worker *worker, int value, int name)
{
uint64_t time;
uint64_t elapsed;
struct thorium_actor *other_actor;
int mailbox_size;
int status;
uint64_t threshold;
/*
* If no actor is scheduled to run, things are getting out of hand
* and this is bad for business.
*
* So, here, an actor is poked for inactivity
*/
if (!value) {
++worker->ticks_without_production;
} else {
worker->ticks_without_production = 0;
}
/*
* If too many cycles were spent doing nothing,
* check the fast ring since there could be issue in the
* cache coherency of the CPU, even with the memory fences.
*
* This should not happen theoretically.
*
*/
if (worker->ticks_without_production >= THORIUM_WORKER_UNPRODUCTIVE_TICK_LIMIT) {
if (core_map_iterator_get_next_key_and_value(&worker->actor_iterator, &name, NULL)) {
other_actor = thorium_node_get_actor_from_name(worker->node, name);
mailbox_size = 0;
if (other_actor != NULL) {
mailbox_size = thorium_actor_get_mailbox_size(other_actor);
}
if (mailbox_size > 0) {
thorium_scheduler_enqueue(&worker->scheduler, other_actor);
status = STATUS_QUEUED;
core_map_update_value(&worker->actors, &name, &status);
}
} else {
/* Rewind the iterator.
*/
core_map_iterator_destroy(&worker->actor_iterator);
core_map_iterator_init(&worker->actor_iterator, &worker->actors);
/*worker->ticks_without_production = 0;*/
}
/*
* If there is still nothing, tell the operating system that the thread
* needs to sleep.
*
* The operating system is:
* - Linux on Cray XE6,
* - Linux on Cray XC30,
* - IBM Compute Node Kernel (CNK) on IBM Blue Gene/Q),
*/
if (worker->waiting_is_enabled) {
/* This is a first warning
*/
if (worker->waiting_start_time == 0) {
worker->waiting_start_time = core_timer_get_nanoseconds(&worker->timer);
} else {
time = core_timer_get_nanoseconds(&worker->timer);
elapsed = time - worker->waiting_start_time;
threshold = THORIUM_WORKER_UNPRODUCTIVE_MICROSECONDS_FOR_WAIT;
/* Convert microseconds to nanoseconds
*/
threshold *= 1000;
/* Verify the elapsed time.
* There are 1000 nanoseconds in 1 microsecond.
*/
if (elapsed >= threshold) {
/*
* Here, the worker will wait until it receives a signal.
* Such a signal will mean that something is ready to be consumed.
*/
/* Reset the time
*/
worker->waiting_start_time = 0;
#ifdef THORIUM_WORKER_DEBUG_WAIT_SIGNAL
printf("DEBUG worker/%d will wait, elapsed %d\n",
worker->name, (int)elapsed);
#endif
/*
*/
thorium_worker_wait(worker);
}
}
}
}
}
void thorium_balancer_generate_symmetric_migrations(struct thorium_balancer *self, struct core_map *symmetric_actor_scripts,
struct core_vector *migrations)
{
int i;
int worker_count;
struct thorium_worker *worker;
struct core_map *set;
struct core_map_iterator iterator;
struct thorium_migration migration;
struct core_map script_current_worker;
struct core_map script_current_worker_actor_count;
int frequency;
int current_worker;
int current_worker_actor_count;
int old_worker;
#ifdef THORIUM_SCHEDULER_ENABLE_VERBOSITY
struct thorium_script *actual_script;
#endif
struct thorium_node *node;
int actor_name;
int script;
int new_worker;
struct thorium_actor *actor;
int enabled;
/* Gather symmetric actors:
*/
#ifdef THORIUM_SCHEDULER_ENABLE_SYMMETRIC_SCHEDULING
enabled = 1;
#else
enabled = 0;
#endif
core_map_init(&script_current_worker, sizeof(int), sizeof(int));
core_map_init(&script_current_worker_actor_count, sizeof(int), sizeof(int));
node = thorium_worker_pool_get_node(self->pool);
worker_count = thorium_worker_pool_worker_count(self->pool);
for (i = 0; i < worker_count; i++) {
worker = thorium_worker_pool_get_worker(self->pool, i);
set = thorium_worker_get_actors(worker);
core_map_iterator_init(&iterator, set);
while (core_map_iterator_get_next_key_and_value(&iterator, &actor_name, NULL)) {
actor = thorium_node_get_actor_from_name(node, actor_name);
if (actor == NULL) {
continue;
}
script = thorium_actor_script(actor);
/*
* Check if the actor is symmetric
*/
if (core_map_get_value(symmetric_actor_scripts, &script, &frequency)) {
current_worker = 0;
if (!core_map_get_value(&script_current_worker, &script, ¤t_worker)) {
core_map_add_value(&script_current_worker, &script, ¤t_worker);
}
current_worker_actor_count = 0;
if (!core_map_get_value(&script_current_worker_actor_count, &script, ¤t_worker_actor_count)) {
core_map_add_value(&script_current_worker_actor_count, &script, ¤t_worker_actor_count);
}
/*
* Emit migration instruction
*/
old_worker = thorium_balancer_get_actor_worker(self, actor_name);
new_worker = current_worker;
#ifdef THORIUM_SCHEDULER_ENABLE_VERBOSITY
actual_script = thorium_node_find_script(node, script);
#endif
if (enabled && old_worker != new_worker) {
thorium_migration_init(&migration, actor_name, old_worker, new_worker);
core_vector_push_back(migrations, &migration);
thorium_migration_destroy(&migration);
#ifdef THORIUM_SCHEDULER_ENABLE_VERBOSITY
printf("[EMIT] ");
#endif
} else {
#ifdef THORIUM_SCHEDULER_ENABLE_VERBOSITY
printf("[MOCK] ");
#endif
}
#ifdef THORIUM_SCHEDULER_ENABLE_VERBOSITY
printf("SCHEDULER -> symmetric placement... %s/%d scheduled for execution on worker/%d of node/%d\n",
thorium_script_description(actual_script),
actor_name,
new_worker,
thorium_node_name(node));
#endif
++current_worker_actor_count;
core_map_update_value(&script_current_worker_actor_count, &script, ¤t_worker_actor_count);
/* The current worker is full.
* Increment the current worker and set the
* worker actor count to 0.
*/
if (current_worker_actor_count == frequency) {
++current_worker;
core_map_update_value(&script_current_worker, &script, ¤t_worker);
current_worker_actor_count = 0;
core_map_update_value(&script_current_worker_actor_count, &script, ¤t_worker_actor_count);
}
}
}
core_map_iterator_destroy(&iterator);
}
core_map_destroy(&script_current_worker);
core_map_destroy(&script_current_worker_actor_count);
}
void thorium_balancer_detect_symmetric_scripts(struct thorium_balancer *self, struct core_map *symmetric_actor_scripts)
{
int i;
struct thorium_worker *worker;
struct thorium_actor *actor;
struct core_map_iterator iterator;
struct core_map *set;
int actor_name;
struct thorium_node *node;
int script;
int frequency;
struct core_map frequencies;
int worker_count;
int population_per_worker;
#ifdef THORIUM_SCHEDULER_ENABLE_VERBOSITY
struct thorium_script *actual_script;
#endif
worker_count = thorium_worker_pool_worker_count(self->pool);
core_map_init(&frequencies, sizeof(int), sizeof(int));
node = thorium_worker_pool_get_node(self->pool);
/* Gather frequencies
*/
for (i = 0; i < worker_count; i++) {
worker = thorium_worker_pool_get_worker(self->pool, i);
set = thorium_worker_get_actors(worker);
core_map_iterator_init(&iterator, set);
while (core_map_iterator_get_next_key_and_value(&iterator, &actor_name, NULL)) {
actor = thorium_node_get_actor_from_name(node, actor_name);
if (actor == NULL) {
continue;
}
script = thorium_actor_script(actor);
frequency = 0;
if (!core_map_get_value(&frequencies, &script, &frequency)) {
core_map_add_value(&frequencies, &script, &frequency);
}
++frequency;
core_map_update_value(&frequencies, &script, &frequency);
}
core_map_iterator_destroy(&iterator);
}
/*
* Detect symmetric scripts
*/
core_map_iterator_init(&iterator, &frequencies);
while (core_map_iterator_get_next_key_and_value(&iterator, &script, &frequency)) {
#ifdef THORIUM_SCHEDULER_ENABLE_VERBOSITY
actual_script = thorium_node_find_script(node, script);
#endif
#ifdef THORIUM_SCHEDULER_ENABLE_VERBOSITY
printf("SCHEDULER test symmetry %s %d\n",
thorium_script_description(actual_script),
frequency);
#endif
if (frequency % worker_count == 0) {
population_per_worker = frequency / worker_count;
core_map_add_value(symmetric_actor_scripts, &script, &population_per_worker);
#ifdef THORIUM_SCHEDULER_ENABLE_VERBOSITY
printf("SCHEDULER: script %s is symmetric, worker_count: %d, population_per_worker: %d\n",
thorium_script_description(actual_script),
worker_count,
population_per_worker);
#endif
}
}
core_map_iterator_destroy(&iterator);
core_map_destroy(&frequencies);
}
void thorium_balancer_balance(struct thorium_balancer *self)
{
/*
* The 95th percentile is useful:
* \see http://en.wikipedia.org/wiki/Burstable_billing
* \see http://www.init7.net/en/backbone/95-percent-rule
*/
int load_percentile_50;
struct core_timer timer;
int i;
struct core_vector loads;
struct core_vector loads_unsorted;
struct core_vector burdened_workers;
struct core_vector stalled_workers;
struct thorium_worker *worker;
struct thorium_node *node;
/*struct core_set *set;*/
struct core_pair pair;
struct core_vector_iterator vector_iterator;
int old_worker;
int actor_name;
int messages;
int maximum;
int with_maximum;
struct core_map *set;
struct core_map_iterator set_iterator;
int stalled_index;
int stalled_count;
int new_worker_index;
struct core_vector migrations;
struct thorium_migration migration;
struct thorium_migration *migration_to_do;
struct thorium_actor *actor;
int candidates;
int load_value;
int remaining_load;
int projected_load;
struct core_vector actors_to_migrate;
int total;
int with_messages;
int stalled_percentile;
int burdened_percentile;
int old_total;
int old_load;
int new_load;
int predicted_new_load;
struct core_pair *pair_pointer;
struct thorium_worker *new_worker;
/*int new_total;*/
int actor_load;
int test_stalled_index;
int tests;
int found_match;
int spawned_actors;
int killed_actors;
int perfect;
#ifdef THORIUM_SCHEDULER_ENABLE_SYMMETRIC_SCHEDULING
struct core_map symmetric_actor_scripts;
int script;
#endif
node = thorium_worker_pool_get_node(self->pool);
spawned_actors = thorium_node_get_counter(node, CORE_COUNTER_SPAWNED_ACTORS);
/* There is nothing to balance...
*/
if (spawned_actors == 0) {
return;
}
killed_actors = thorium_node_get_counter(node, CORE_COUNTER_KILLED_ACTORS);
/*
* The system can probably not be balanced to get in
* a better shape anyway.
*/
if (spawned_actors == self->last_spawned_actors
&& killed_actors == self->last_killed_actors
&& self->last_migrations == 0) {
printf("SCHEDULER: balance can not be improved because nothing changed.\n");
return;
}
/* Check if we have perfection
*/
perfect = 1;
for (i = 0; i < thorium_worker_pool_worker_count(self->pool); i++) {
worker = thorium_worker_pool_get_worker(self->pool, i);
load_value = thorium_worker_get_epoch_load(worker) * 100;
if (load_value != 100) {
perfect = 0;
break;
}
}
if (perfect) {
printf("SCHEDULER: perfect balance can not be improved.\n");
return;
}
/* update counters
*/
self->last_spawned_actors = spawned_actors;
self->last_killed_actors = killed_actors;
/* Otherwise, try to balance things
*/
core_timer_init(&timer);
core_timer_start(&timer);
#ifdef THORIUM_SCHEDULER_ENABLE_SYMMETRIC_SCHEDULING
core_map_init(&symmetric_actor_scripts, sizeof(int), sizeof(int));
thorium_balancer_detect_symmetric_scripts(self, &symmetric_actor_scripts);
#endif
#ifdef THORIUM_WORKER_ENABLE_LOCK
/* Lock all workers first
*/
for (i = 0; i < thorium_worker_pool_worker_count(self->pool); i++) {
worker = thorium_worker_pool_get_worker(self->pool, i);
thorium_worker_lock(worker);
}
#endif
core_vector_init(&migrations, sizeof(struct thorium_migration));
#ifdef THORIUM_SCHEDULER_ENABLE_VERBOSITY
printf("BALANCING\n");
#endif
core_vector_init(&loads, sizeof(int));
core_vector_init(&loads_unsorted, sizeof(int));
core_vector_init(&burdened_workers, sizeof(struct core_pair));
core_vector_init(&stalled_workers, sizeof(struct core_pair));
core_vector_init(&actors_to_migrate, sizeof(struct core_pair));
for (i = 0; i < thorium_worker_pool_worker_count(self->pool); i++) {
worker = thorium_worker_pool_get_worker(self->pool, i);
load_value = thorium_worker_get_scheduling_epoch_load(worker) * SCHEDULER_PRECISION;
#if 0
printf("DEBUG LOAD %d %d\n", i, load_value);
#endif
core_vector_push_back(&loads, &load_value);
core_vector_push_back(&loads_unsorted, &load_value);
}
core_vector_sort_int(&loads);
stalled_percentile = core_statistics_get_percentile_int(&loads, SCHEDULER_WINDOW);
/*load_percentile_25 = core_statistics_get_percentile_int(&loads, 25);*/
load_percentile_50 = core_statistics_get_percentile_int(&loads, 50);
/*load_percentile_75 = core_statistics_get_percentile_int(&loads, 75);*/
burdened_percentile = core_statistics_get_percentile_int(&loads, 100 - SCHEDULER_WINDOW);
#ifdef THORIUM_SCHEDULER_ENABLE_VERBOSITY
printf("Percentiles for epoch loads: ");
core_statistics_print_percentiles_int(&loads);
#endif
for (i = 0; i < thorium_worker_pool_worker_count(self->pool); i++) {
worker = thorium_worker_pool_get_worker(self->pool, i);
load_value = core_vector_at_as_int(&loads_unsorted, i);
set = thorium_worker_get_actors(worker);
if (stalled_percentile == burdened_percentile) {
#ifdef THORIUM_SCHEDULER_ENABLE_VERBOSITY
printf("scheduling_class:%s ",
THORIUM_CLASS_NORMAL_STRING);
#endif
} else if (load_value <= stalled_percentile) {
#ifdef THORIUM_SCHEDULER_ENABLE_VERBOSITY
printf("scheduling_class:%s ",
THORIUM_CLASS_STALLED_STRING);
#endif
core_pair_init(&pair, load_value, i);
core_vector_push_back(&stalled_workers, &pair);
} else if (load_value >= burdened_percentile) {
#ifdef THORIUM_SCHEDULER_ENABLE_VERBOSITY
printf("scheduling_class:%s ",
THORIUM_CLASS_BURDENED_STRING);
#endif
core_pair_init(&pair, load_value, i);
core_vector_push_back(&burdened_workers, &pair);
} else {
#ifdef THORIUM_SCHEDULER_ENABLE_VERBOSITY
printf("scheduling_class:%s ",
THORIUM_CLASS_NORMAL_STRING);
#endif
}
#ifdef THORIUM_SCHEDULER_ENABLE_VERBOSITY
thorium_worker_print_actors(worker, self);
#endif
}
core_vector_sort_int_reverse(&burdened_workers);
core_vector_sort_int(&stalled_workers);
stalled_count = core_vector_size(&stalled_workers);
#ifdef THORIUM_SCHEDULER_ENABLE_VERBOSITY
printf("MIGRATIONS (stalled: %d, burdened: %d)\n", (int)core_vector_size(&stalled_workers),
(int)core_vector_size(&burdened_workers));
#endif
stalled_index = 0;
core_vector_iterator_init(&vector_iterator, &burdened_workers);
while (stalled_count > 0
&& core_vector_iterator_get_next_value(&vector_iterator, &pair)) {
old_worker = core_pair_get_second(&pair);
worker = thorium_worker_pool_get_worker(self->pool, old_worker);
set = thorium_worker_get_actors(worker);
/*
thorium_worker_print_actors(worker);
printf("\n");
*/
/*
* Lock the worker and try to select actors for migration
*/
core_map_iterator_init(&set_iterator, set);
maximum = -1;
with_maximum = 0;
total = 0;
with_messages = 0;
while (core_map_iterator_get_next_key_and_value(&set_iterator, &actor_name, NULL)) {
actor = thorium_node_get_actor_from_name(thorium_worker_pool_get_node(self->pool), actor_name);
messages = thorium_balancer_get_actor_production(self, actor);
if (maximum == -1 || messages > maximum) {
maximum = messages;
with_maximum = 1;
} else if (messages == maximum) {
with_maximum++;
}
if (messages > 0) {
++with_messages;
}
total += messages;
}
core_map_iterator_destroy(&set_iterator);
core_map_iterator_init(&set_iterator, set);
--with_maximum;
candidates = 0;
load_value = thorium_worker_get_scheduling_epoch_load(worker) * SCHEDULER_PRECISION;
remaining_load = load_value;
#if 0
printf("maximum %d with_maximum %d\n", maximum, with_maximum);
#endif
while (core_map_iterator_get_next_key_and_value(&set_iterator, &actor_name, NULL)) {
actor = thorium_node_get_actor_from_name(thorium_worker_pool_get_node(self->pool), actor_name);
if (actor == NULL) {
continue;
}
messages = thorium_balancer_get_actor_production(self, actor);
#ifdef THORIUM_SCHEDULER_ENABLE_SYMMETRIC_SCHEDULING
script = thorium_actor_script(actor);
/* symmetric actors are migrated elsewhere.
*/
if (core_map_get_value(&symmetric_actor_scripts, &script, NULL)) {
continue;
}
#endif
/* Simulate the remaining load
*/
projected_load = remaining_load;
projected_load -= ((0.0 + messages) / total) * load_value;
#ifdef THORIUM_SCHEDULER_DEBUG
printf(" TESTING actor %d, production was %d, projected_load is %d (- %d * (1 - %d/%d)\n",
actor_name, messages, projected_load,
load_value, messages, total);
#endif
/* An actor without any queued messages should not be migrated
*/
if (messages > 0
&& ((with_maximum > 0 && messages == maximum) || messages < maximum)
/*
* Avoid removing too many actors because
* generating a stalled one is not desired
*/
&& (projected_load >= load_percentile_50
/*
* The previous rule does not apply when there
* are 2 actors.
*/
|| with_messages == 2) ) {
remaining_load = projected_load;
candidates++;
if (messages == maximum) {
--with_maximum;
}
core_pair_init(&pair, messages, actor_name);
core_vector_push_back(&actors_to_migrate, &pair);
#ifdef THORIUM_SCHEDULER_DEBUG
printf("early CANDIDATE for migration: actor %d, worker %d\n",
actor_name, old_worker);
#endif
}
}
core_map_iterator_destroy(&set_iterator);
}
core_vector_iterator_destroy(&vector_iterator);
/* Sort the candidates
*/
/*
core_vector_sort_int(&actors_to_migrate);
printf("Percentiles for production: ");
core_statistics_print_percentiles_int(&actors_to_migrate);
*/
/* Sort them in reverse order.
*/
core_vector_sort_int_reverse(&actors_to_migrate);
core_vector_iterator_init(&vector_iterator, &actors_to_migrate);
/* For each highly active actor,
* try to match it with a stalled worker
*/
while (core_vector_iterator_get_next_value(&vector_iterator, &pair)) {
actor_name = core_pair_get_second(&pair);
actor = thorium_node_get_actor_from_name(thorium_worker_pool_get_node(self->pool), actor_name);
if (actor == NULL) {
continue;
}
messages = thorium_balancer_get_actor_production(self, actor);
old_worker = thorium_actor_assigned_worker(actor);
worker = thorium_worker_pool_get_worker(self->pool, old_worker);
/* old_total can not be 0 because otherwise the would not
* be burdened.
*/
old_total = thorium_worker_get_production(worker, self);
with_messages = thorium_worker_get_producer_count(worker, self);
old_load = thorium_worker_get_scheduling_epoch_load(worker) * SCHEDULER_PRECISION;
actor_load = ((0.0 + messages) / old_total) * old_load;
/* Try to find a stalled worker that can take it.
*/
test_stalled_index = stalled_index;
tests = 0;
predicted_new_load = 0;
found_match = 0;
while (tests < stalled_count) {
core_vector_get_value(&stalled_workers, test_stalled_index, &pair);
new_worker_index = core_pair_get_second(&pair);
new_worker = thorium_worker_pool_get_worker(self->pool, new_worker_index);
new_load = thorium_worker_get_scheduling_epoch_load(new_worker) * SCHEDULER_PRECISION;
/*new_total = thorium_worker_get_production(new_worker);*/
predicted_new_load = new_load + actor_load;
if (predicted_new_load > SCHEDULER_PRECISION /* && with_messages != 2 */) {
#ifdef THORIUM_SCHEDULER_DEBUG
printf("Scheduler: skipping actor %d, predicted load is %d >= 100\n",
actor_name, predicted_new_load);
#endif
++tests;
++test_stalled_index;
if (test_stalled_index == stalled_count) {
test_stalled_index = 0;
}
continue;
}
/* Otherwise, this stalled worker is fine...
*/
stalled_index = test_stalled_index;
found_match = 1;
break;
}
/* This actor can not be migrated to any stalled worker.
*/
if (!found_match) {
continue;
}
/* Otherwise, update the load of the stalled one and go forward with the change.
*/
pair_pointer = (struct core_pair *)core_vector_at(&stalled_workers, stalled_index);
core_pair_set_first(pair_pointer, predicted_new_load);
++stalled_index;
if (stalled_index == stalled_count) {
stalled_index = 0;
}
#if 0
new_worker = thorium_worker_pool_get_worker(pool, new_worker_index);
printf(" CANDIDATE: actor %d old worker %d (%d - %d = %d) new worker %d (%d + %d = %d)\n",
actor_name,
old_worker, value, messages, 2new_score,
new_worker_index, new_worker_old_score, messages, new_worker_new_score);
#endif
thorium_migration_init(&migration, actor_name, old_worker, new_worker_index);
core_vector_push_back(&migrations, &migration);
thorium_migration_destroy(&migration);
}
core_vector_iterator_destroy(&vector_iterator);
core_vector_destroy(&stalled_workers);
core_vector_destroy(&burdened_workers);
core_vector_destroy(&loads);
core_vector_destroy(&loads_unsorted);
core_vector_destroy(&actors_to_migrate);
/* Update the last values
*/
for (i = 0; i < thorium_worker_pool_worker_count(self->pool); i++) {
worker = thorium_worker_pool_get_worker(self->pool, i);
set = thorium_worker_get_actors(worker);
core_map_iterator_init(&set_iterator, set);
while (core_map_iterator_get_next_key_and_value(&set_iterator, &actor_name, NULL)) {
actor = thorium_node_get_actor_from_name(thorium_worker_pool_get_node(self->pool), actor_name);
thorium_balancer_update_actor_production(self, actor);
}
core_map_iterator_destroy(&set_iterator);
thorium_worker_reset_scheduling_epoch(worker);
}
#ifdef THORIUM_SCHEDULER_ENABLE_SYMMETRIC_SCHEDULING
/* Generate migrations for symmetric actors.
*/
thorium_balancer_generate_symmetric_migrations(self, &symmetric_actor_scripts, &migrations);
#endif
/* Actually do the migrations
*/
core_vector_iterator_init(&vector_iterator, &migrations);
while (core_vector_iterator_next(&vector_iterator, (void **)&migration_to_do)) {
thorium_balancer_migrate(self, migration_to_do);
}
core_vector_iterator_destroy(&vector_iterator);
self->last_migrations = core_vector_size(&migrations);
core_vector_destroy(&migrations);
#ifdef THORIUM_WORKER_ENABLE_LOCK
/* Unlock all workers
*/
for (i = 0; i < thorium_worker_pool_worker_count(self->pool); i++) {
worker = thorium_worker_pool_get_worker(self->pool, i);
thorium_worker_unlock(worker);
}
#endif
#ifdef THORIUM_SCHEDULER_ENABLE_SYMMETRIC_SCHEDULING
core_map_destroy(&symmetric_actor_scripts);
#endif
core_timer_stop(&timer);
printf("SCHEDULER: elapsed time for balancing: %d us, %d migrations performed\n",
(int)(core_timer_get_elapsed_nanoseconds(&timer) / 1000),
self->last_migrations);
}
