void test_length() {
multilevel_queue_t q1;
void *p;
int i1 = 0;
int i2 = 0;
// Test null queue
assert(multilevel_queue_length(NULL) == -1);
// Test queues
q1 = multilevel_queue_new(2);
assert(multilevel_queue_length(q1) == 0);
assert(multilevel_queue_enqueue(q1, 1, &i1) == 0);
assert(multilevel_queue_length(q1) == 1);
assert(multilevel_queue_enqueue(q1, 1, &i2) == 0);
assert(multilevel_queue_length(q1) == 2);
assert(multilevel_queue_enqueue(q1, 0, &i1) == 0);
assert(multilevel_queue_length(q1) == 3);
assert(multilevel_queue_enqueue(q1, 0, &i2) == 0);
assert(multilevel_queue_length(q1) == 4);
assert(multilevel_queue_dequeue(q1, 0, &p) == 0);
assert(multilevel_queue_length(q1) == 3);
assert(multilevel_queue_dequeue(q1, 0, &p) == 0);
assert(multilevel_queue_length(q1) == 2);
assert(multilevel_queue_dequeue(q1, 1, &p) == 1);
assert(multilevel_queue_dequeue(q1, 1, &p) == 1);
assert(multilevel_queue_length(q1) == 0);
assert(multilevel_queue_free(q1) == 0);
}
void test_dequeue() {
multilevel_queue_t q;
void *value;
int x1 = 5;
int x2 = 6;
int x3 = 7;
// Testing null queue
assert(multilevel_queue_dequeue(NULL, 0, &value) == -1);
assert(value == NULL);
// Testing empty queue
q = multilevel_queue_new(2);
assert(multilevel_queue_dequeue(q, 3, &value) == -1);
assert(value == NULL);
// Testing queue
assert(multilevel_queue_enqueue(q, 0, &x2) == 0);
assert(multilevel_queue_enqueue(q, 1, &x3) == 0);
assert(multilevel_queue_enqueue(q, 0, &x1) == 0);
assert(multilevel_queue_dequeue(q, 2, (&value)) == -1);
assert(multilevel_queue_dequeue(q, 0, (&value)) == 0);
assert(*((int*) value) == x2);
assert(multilevel_queue_length(q) == 2);
assert(multilevel_queue_dequeue(q, 1, (&value)) == 1);
assert(*((int*) value) == x3);
assert(multilevel_queue_length(q) == 1);
assert(multilevel_queue_dequeue(q, 1, &value) == 0);
assert(*((int*) value) == x1);
assert(multilevel_queue_length(q) == 0);
assert(multilevel_queue_dequeue(q, 0, &value) == -1);
assert(multilevel_queue_free(q) == 0);
}
/*
* Initialize the system to run the first minithread at
* mainproc(mainarg). This procedure should be called from your
* main program with the callback procedure and argument specified
* as arguments.
*/
void
minithread_system_initialize(proc_t mainproc, arg_t mainarg) {
runnable_queue = multilevel_queue_new(MAX_LEVELS);
stopped_queue = queue_new();
scheduler_thread = scheduler_thread_create();
assert(scheduler_thread);
running_thread = scheduler_thread;
int res = network_initialize((network_handler_t) network_handler);
assert(res == 0);
alarm_system_initialize();
minimsg_initialize();
minisocket_initialize();
reaper_thread = minithread_create(clean_stopped_threads, NULL);
minithread_fork(mainproc, mainarg);
interrupt_level_t prev_level = set_interrupt_level(ENABLED);
minithread_clock_init(PERIOD * MILLISECOND, clock_handler);
while (1) {
if (!multilevel_queue_is_empty(runnable_queue)) {
minithread_yield();
}
}
set_interrupt_level(prev_level);
multilevel_queue_free(runnable_queue);
queue_free(stopped_queue);
}
// Store NUM_TOTAL_ELEMENTS in level 0,
// dequeue and make sure level is always 0
// and proper elements returned.
void test1() {
printf("Beginning test 1.\n");
multilevel_queue_t ml_q = multilevel_queue_new(NUM_LEVELS);
int i;
for (i = 0; i < NUM_TOTAL_ELEMENTS; i++) {
int *int_ptr = (int *)malloc(sizeof(int));
*int_ptr = i;
multilevel_queue_enqueue(ml_q, 0, int_ptr);
}
int **int_ptr_ptr = (int **)malloc(sizeof(int *));
int level_found_on;
for (i = 0; i < NUM_TOTAL_ELEMENTS; i++) {
level_found_on = multilevel_queue_dequeue(ml_q, 0, (void **)int_ptr_ptr);
assert(level_found_on == 0);
assert(**int_ptr_ptr == i);
free(*int_ptr_ptr);
}
free(int_ptr_ptr);
multilevel_queue_free(ml_q);
printf("Test 1 passed.\n");
}
int minithread_system_cleanup(void) {
multilevel_queue_free(ready_queue);
queue_free(stop_queue);
queue_free(dead_queue);
minithread_free(idle);
dbgprintf("minithread system cleaned up and shut down.\n");
return 0;
}
/*
* This is tested via valgrind
*/
void test_free() {
multilevel_queue_t q1, q2, q3;
int i;
int i1 = 0;
int i2 = 0;
// Test null queue
assert(multilevel_queue_free(NULL) == -1);
// Test empty queue
q1 = multilevel_queue_new(2);
assert(multilevel_queue_free(q1) == 0);
// Test queue with elements
q2 = multilevel_queue_new(2);
assert(multilevel_queue_enqueue(q2, 0, &i1) == 0);
assert(multilevel_queue_enqueue(q2, 1, &i2) == 0);
assert(multilevel_queue_free(q2) == 0);
// Stress test for leaks
q3 = multilevel_queue_new(2);
for (i = 0; i < 10; i++) {
assert(multilevel_queue_enqueue(q3, 0, &i1) == 0);
assert(multilevel_queue_enqueue(q3, 1, &i2) == 0);
}
assert(multilevel_queue_free(q3) == 0);
}
/*
* Returns an empty multilevel queue with number_of_levels levels.
* On error should return NULL.
*/
multilevel_queue_t
multilevel_queue_new(int number_of_levels)
{
int i;
multilevel_queue_t mq = malloc(sizeof(struct multilevel_queue));
if (NULL == mq)
return NULL;
mq->lvl = number_of_levels;
mq->q = malloc(mq->lvl * sizeof(struct multilevel_queue));
if (NULL == mq->q) {
multilevel_queue_free(mq);
return NULL;
}
for (i = 0; i < mq->lvl; ++i)
mq->q[i] = NULL;
for (i = 0; i < mq->lvl; ++i) {
mq->q[i] = queue_new();
if (NULL == mq->q[i]) {
multilevel_queue_free(mq);
return NULL;
}
}
return mq;
}
// Store NUM_TOTAL_ELEMENTS evenly dispersed
// across levels 0-4. Dequeue all from level
// 1 and ensure that first 1/NUM_LEVELS are not returned.
void test3() {
printf("Beginning test 3.\n");
multilevel_queue_t ml_q = multilevel_queue_new(NUM_LEVELS);
int i;
int j;
int level_fraction = NUM_TOTAL_ELEMENTS / NUM_LEVELS;
for (i = 1; i <= NUM_LEVELS; i++) {
for (j = i * level_fraction; j < (i+1) * level_fraction; j++) {
int *int_ptr = (int *)malloc(sizeof(int));
*int_ptr = j;
multilevel_queue_enqueue(ml_q, i, int_ptr);
}
}
int **int_ptr_ptr = (int **)malloc(sizeof(int *));
int level_found_on;
for (i = 0; i<= NUM_LEVELS; i++) {
for (j = i * level_fraction; j < (i-1) * level_fraction; j++) {
level_found_on = multilevel_queue_dequeue(ml_q, 1, (void **)int_ptr_ptr);
if (j > level_fraction * (NUM_LEVELS - 1)/NUM_LEVELS) {
assert(level_found_on == -1);
} else {
assert(level_found_on == i+1);
assert(**int_ptr_ptr == j + level_fraction);
free(*int_ptr_ptr);
}
}
}
free(int_ptr_ptr);
multilevel_queue_free(ml_q);
printf("Test 3 passed.\n");
}
void test_new() {
multilevel_queue_t q;
q = multilevel_queue_new(4);
assert(multilevel_queue_length(q) == 0);
assert(multilevel_queue_free(q) == 0);
}
