int main(int argc, char **argv)
{
BEGIN_TESTS();
struct core_fast_ring ring;
int capacity = 64;
int i;
int value;
int elements;
elements = 0;
#if 0
printf("Required %d\n", capacity);
#endif
core_fast_ring_init(&ring, capacity, sizeof(int));
capacity = core_fast_ring_capacity(&ring);
#if 0
printf("Provided %d\n", capacity);
#endif
TEST_BOOLEAN_EQUALS(core_fast_ring_is_empty_from_consumer(&ring), 1);
for (i = 0; i < capacity; i++) {
TEST_BOOLEAN_EQUALS(core_fast_ring_push_from_producer(&ring, &i), 1);
elements++;
TEST_INT_EQUALS(core_fast_ring_size_from_producer(&ring), elements);
TEST_INT_EQUALS(core_fast_ring_size_from_consumer(&ring), elements);
}
TEST_BOOLEAN_EQUALS(core_fast_ring_is_full_from_producer(&ring), 1);
for (i = 0; i < capacity; i++) {
TEST_BOOLEAN_EQUALS(core_fast_ring_pop_from_consumer(&ring, &value), 1);
elements--;
TEST_INT_EQUALS(value, i);
TEST_INT_EQUALS(core_fast_ring_size_from_producer(&ring), elements);
TEST_INT_EQUALS(core_fast_ring_size_from_consumer(&ring), elements);
}
core_fast_ring_destroy(&ring);
{
struct core_fast_ring ring;
int capacity = 64;
struct thorium_message message;
int action;
int count;
void *buffer;
int inserted;
int pulled;
action = 1234;
count = 0;
buffer = NULL;
thorium_message_init(&message, action, count, buffer);
core_fast_ring_init(&ring, capacity, sizeof(struct thorium_message));
core_fast_ring_use_multiple_producers(&ring);
inserted = 0;
while (core_fast_ring_push_from_producer(&ring, &message)) {
++inserted;
}
/*
* 64 + 1 = 65, 128 is the next power of 2 for the mask.
*/
/*
TEST_INT_EQUALS(inserted, capacity);
*/
pulled = 0;
while (core_fast_ring_pop_from_consumer(&ring, &message)) {
++pulled;
}
TEST_INT_EQUALS(inserted, pulled);
core_fast_ring_destroy(&ring);
thorium_message_destroy(&message);
}
END_TESTS();
return 0;
}
void thorium_worker_init(struct thorium_worker *worker, int name, struct thorium_node *node)
{
int capacity;
int ephemeral_memory_block_size;
int injected_buffer_ring_size;
int argc;
char **argv;
worker->tick_count = 0;
thorium_load_profiler_init(&worker->profiler);
argc = thorium_node_argc(node);
argv = thorium_node_argv(node);
#ifdef THORIUM_WORKER_DEBUG_INJECTION
worker->counter_allocated_outbound_buffers = 0;
worker->counter_freed_outbound_buffers_from_self = 0;
worker->counter_freed_outbound_buffers_from_other_workers = 0;
worker->counter_injected_outbound_buffers_other_local_workers= 0;
worker->counter_injected_inbound_buffers_from_thorium_core = 0;
#endif
core_map_init(&worker->actor_received_messages, sizeof(int), sizeof(int));
worker->waiting_is_enabled = 0;
worker->waiting_start_time = 0;
core_timer_init(&worker->timer);
capacity = THORIUM_WORKER_RING_CAPACITY;
/*worker->work_queue = work_queue;*/
worker->node = node;
worker->name = name;
core_bitmap_clear_bit_uint32_t(&worker->flags, FLAG_DEAD);
worker->last_warning = 0;
worker->last_wake_up_count = 0;
/*worker->work_queue = &worker->works;*/
/* There are two options:
* 1. enable atomic operations for change visibility
* 2. Use volatile head and tail.
*/
core_fast_ring_init(&worker->actors_to_schedule, capacity, sizeof(struct thorium_actor *));
#ifdef THORIUM_NODE_INJECT_CLEAN_WORKER_BUFFERS
injected_buffer_ring_size = capacity;
core_fast_ring_init(&worker->injected_clean_outbound_buffers,
injected_buffer_ring_size, sizeof(void *));
core_fast_ring_init(&worker->clean_message_ring_for_triage,
injected_buffer_ring_size,
sizeof(struct thorium_message));
core_fast_queue_init(&worker->clean_message_queue_for_triage,
sizeof(struct thorium_message));
#endif
thorium_scheduler_init(&worker->scheduler, thorium_node_name(worker->node),
worker->name);
core_map_init(&worker->actors, sizeof(int), sizeof(int));
core_map_iterator_init(&worker->actor_iterator, &worker->actors);
core_fast_ring_init(&worker->outbound_message_queue, capacity, sizeof(struct thorium_message));
core_fast_queue_init(&worker->outbound_message_queue_buffer, sizeof(struct thorium_message));
core_bitmap_clear_bit_uint32_t(&worker->flags, FLAG_DEBUG);
core_bitmap_clear_bit_uint32_t(&worker->flags, FLAG_BUSY);
core_bitmap_clear_bit_uint32_t(&node->flags, FLAG_ENABLE_ACTOR_LOAD_PROFILER);
worker->flags = 0;
core_bitmap_clear_bit_uint32_t(&worker->flags, FLAG_DEBUG_ACTORS);
if (core_command_has_argument(argc, argv, DEBUG_WORKER_OPTION)) {
#if 0
printf("DEBUG has option %s\n", DEBUG_WORKER_OPTION);
#endif
if (thorium_node_name(worker->node) == 0
&& thorium_worker_name(worker) == 0) {
#if 0
printf("DEBUG setting bit FLAG_DEBUG_ACTORS because %s\n", DEBUG_WORKER_OPTION);
#endif
core_bitmap_set_bit_uint32_t(&worker->flags, FLAG_DEBUG_ACTORS);
}
}
worker->epoch_used_nanoseconds = 0;
worker->loop_used_nanoseconds = 0;
worker->scheduling_epoch_used_nanoseconds = 0;
worker->started_in_thread = 0;
/* 2 MiB is the default size for Linux huge pages.
* \see https://wiki.debian.org/Hugepages
* \see http://lwn.net/Articles/376606/
*/
/*
* 8 MiB
*/
ephemeral_memory_block_size = 8388608;
/*ephemeral_memory_block_size = 16777216;*/
core_memory_pool_init(&worker->ephemeral_memory, ephemeral_memory_block_size,
MEMORY_POOL_NAME_WORKER_EPHEMERAL);
core_memory_pool_disable_tracking(&worker->ephemeral_memory);
core_memory_pool_enable_ephemeral_mode(&worker->ephemeral_memory);
#ifdef THORIUM_WORKER_ENABLE_LOCK
core_lock_init(&worker->lock);
#endif
core_set_init(&worker->evicted_actors, sizeof(int));
core_memory_pool_init(&worker->outbound_message_memory_pool,
CORE_MEMORY_POOL_MESSAGE_BUFFER_BLOCK_SIZE, MEMORY_POOL_NAME_WORKER_OUTBOUND);
/*
* Disable the pool so that it uses allocate and free
* directly.
*/
#ifdef CORE_MEMORY_POOL_DISABLE_MESSAGE_BUFFER_POOL
core_memory_pool_disable(&worker->outbound_message_memory_pool);
#endif
/*
* Transport message buffers are fancy objects.
*/
core_memory_pool_enable_normalization(&worker->outbound_message_memory_pool);
core_memory_pool_enable_alignment(&worker->outbound_message_memory_pool);
worker->ticks_without_production = 0;
thorium_priority_assigner_init(&worker->assigner, thorium_worker_name(worker));
/*
* This variables should be set in
* thorium_worker_start, but when running on 1 process with 1 thread,
* thorium_worker_start is never called...
*/
worker->last_report = time(NULL);
worker->epoch_start_in_nanoseconds = core_timer_get_nanoseconds(&worker->timer);
worker->loop_start_in_nanoseconds = worker->epoch_start_in_nanoseconds;
worker->loop_end_in_nanoseconds = worker->loop_start_in_nanoseconds;
worker->scheduling_epoch_start_in_nanoseconds = worker->epoch_start_in_nanoseconds;
/*
* Avoid valgrind warnings.
*/
worker->epoch_load = 0;
}
