Beispiel #1
0
void
rust_port_selector::select(rust_task *task, rust_port **dptr,
                           rust_port **ports,
                           size_t n_ports, uintptr_t *yield) {

    I(task->thread, this->ports == NULL);
    I(task->thread, this->n_ports == 0);
    I(task->thread, dptr != NULL);
    I(task->thread, ports != NULL);
    I(task->thread, n_ports != 0);
    I(task->thread, yield != NULL);

    *yield = false;
    size_t locks_taken = 0;
    bool found_msg = false;

    // Take each port's lock as we iterate through them because
    // if none of them contain a usable message then we need to
    // block the task before any of them can try to send another
    // message.

    // Start looking for ports from a different index each time.
    size_t j = isaac_rand(&task->thread->rctx);
    for (size_t i = 0; i < n_ports; i++) {
        size_t k = (i + j) % n_ports;
        rust_port *port = ports[k];
        I(task->thread, port != NULL);

        port->lock.lock();
        locks_taken++;

        if (port->buffer.size() > 0) {
            *dptr = port;
            found_msg = true;
            break;
        }
    }

    if (!found_msg) {
        this->ports = ports;
        this->n_ports = n_ports;
        I(task->thread, task->rendezvous_ptr == NULL);
        task->rendezvous_ptr = (uintptr_t*)dptr;
        task->block(this, "waiting for select rendezvous");

	// Blocking the task might fail if the task has already been
	// killed, but in the event of both failure and success the
	// task needs to yield. On success, it yields and waits to be
	// unblocked. On failure it yields and is then fails the task.

        *yield = true;
    }

    for (size_t i = 0; i < locks_taken; i++) {
        size_t k = (i + j) % n_ports;
        rust_port *port = ports[k];
        port->lock.unlock();
    }
}
Beispiel #2
0
rust_task *
rust_scheduler::create_task(rust_task *spawner, const char *name,
			    size_t init_stack_sz) {
    size_t thread_no;
    {
	scoped_lock with(lock);
	thread_no = isaac_rand(&rctx) % num_threads;
	live_tasks++;
    }
    rust_task_thread *thread = threads[thread_no];
    return thread->create_task(spawner, name, init_stack_sz);
}
Beispiel #3
0
/*
 *   generate a random number 
 */
ulong TadsServerManager::rand()
{
    /* ISAAC needs protection against multi-threaded access */
    mutex->lock();

    /* get a random number */
    ulong r = isaac_rand(ic);

    /* done with the mutex */
    mutex->unlock();

    /* return the number */
    return r;
}
Beispiel #4
0
/**
 * Schedules a running task for execution. Only running tasks can be
 * activated.  Blocked tasks have to be unblocked before they can be
 * activated.
 *
 * Returns NULL if no tasks can be scheduled.
 */
rust_task *
rust_task_thread::schedule_task() {
    I(this, this);
    // FIXME: in the face of failing tasks, this is not always right.
    // I(this, n_live_tasks() > 0);
    if (running_tasks.length() > 0) {
        size_t k = isaac_rand(&rctx);
        // Look around for a runnable task, starting at k.
        for(size_t j = 0; j < running_tasks.length(); ++j) {
            size_t  i = (j + k) % running_tasks.length();
            return (rust_task *)running_tasks[i];
        }
    }
    return NULL;
}
Beispiel #5
0
extern "C" CDECL size_t
rand_next(randctx *rctx) {
    return isaac_rand(rctx);
}
Beispiel #6
0
int main(int argc, const char *argv[])
{
    unsigned int i,j;
    unsigned long int elapsed_time;
    unsigned long int times[10];
    double mean, var;

    struct timespec tp1, tp2;

    printf("#======================================#\n");
    printf("|    Speed tests for the generators    |\n");
    printf("#======================================#\n");
    printf("#======================================#\n");
    printf("| The tests consists in measuring the  |\n");
    printf("| time it takes to each generator to   |\n");
    printf("| generate 10 million random numbers   |\n");
    printf("|                                      |\n");
    printf("+--------------------------------------+\n");
    printf("| 32 Bits                              |\n");
    printf("+--------------------------------------+\n");

#if ISAAC_RAND || RANDS_USE_ALL
    isaac_srand(time(NULL));
    for(j = 0; j < 10; j++)
    {
        clock_gettime(CLOCK_MONOTONIC,&tp1);
        for(i = 0; i < 10000000; i++)
            isaac_rand();
        clock_gettime(CLOCK_MONOTONIC,&tp2);
        elapsed_time = (unsigned long) (tp2.tv_sec-tp1.tv_sec)*1000000000 + \
                       (unsigned long) tp2.tv_nsec-tp1.tv_nsec;
        times[j] = elapsed_time;
    }
    calc_mean_var(&mean,&var,times);

    printf("| ISAAC:               %.4lf ± %.4lf |\n",mean/1e9, sqrt(var)/1e9);
#endif

#if ISAAC_X64_RAND || RANDS_USE_ALL
    isaac_srand(time(NULL));
    for(j = 0; j < 10; j++)
    {
        clock_gettime(CLOCK_MONOTONIC,&tp1);
        for(i = 0; i < 5000000; i++)
            isaac_x64_rand();
        clock_gettime(CLOCK_MONOTONIC,&tp2);
        elapsed_time = (unsigned long) (tp2.tv_sec-tp1.tv_sec)*1000000000 + \
                       (unsigned long) tp2.tv_nsec-tp1.tv_nsec;
        times[j] = elapsed_time;
    }
    calc_mean_var(&mean,&var,times);

    printf("| ISAAC (64bits):      %.4lf ± %.4lf |\n",mean/1e9, sqrt(var)/1e9);
#endif

#if PR_RAND || RANDS_USE_ALL
    pr_srand(time(NULL));
    for(j = 0; j < 10; j++)
    {
        clock_gettime(CLOCK_MONOTONIC,&tp1);
        for(i = 0; i < 10000000; i++)
            pr_rand();
        clock_gettime(CLOCK_MONOTONIC,&tp2);
        elapsed_time = (unsigned long) (tp2.tv_sec-tp1.tv_sec)*1000000000 + \
                       (unsigned long) tp2.tv_nsec-tp1.tv_nsec;
        times[j] = elapsed_time;
    }
    calc_mean_var(&mean,&var,times);

    printf("| Parisi-Rapuano:      %.4lf ± %.4lf |\n",mean/1e9, sqrt(var)/1e9);
#endif

#if __SSE2__
#if PR_SSE_RAND || RANDS_USE_ALL
    pr_sse_srand(time(NULL));
    for(j = 0; j < 10; j++)
    {
        clock_gettime(CLOCK_MONOTONIC,&tp1);
        for(i = 0; i < 10000000; i++)
            pr_sse_rand();
        clock_gettime(CLOCK_MONOTONIC,&tp2);
        elapsed_time = (unsigned long) (tp2.tv_sec-tp1.tv_sec)*1000000000 + \
                       (unsigned long) tp2.tv_nsec-tp1.tv_nsec;
        times[j] = elapsed_time;
    }
    calc_mean_var(&mean,&var,times);

    printf("| Parisi-Rapuano SSE:  %.4lf ± %.4lf |\n",mean/1e9, sqrt(var)/1e9);
#endif
#endif

    srand(time(NULL));
    for(j = 0; j < 10; j++)
    {
        clock_gettime(CLOCK_MONOTONIC,&tp1);
        for(i = 0; i < 10000000; i++)
            rand();
        clock_gettime(CLOCK_MONOTONIC,&tp2);
        elapsed_time = (unsigned long) (tp2.tv_sec-tp1.tv_sec)*1000000000 + \
                       (unsigned long) tp2.tv_nsec-tp1.tv_nsec;
        times[j] = elapsed_time;
    }
    calc_mean_var(&mean,&var,times);

    printf("| Rand (stdlib):       %.4lf ± %.4lf |\n",mean/1e9, sqrt(var)/1e9);

#if MT_RAND || RANDS_USE_ALL
    mt_srand(time(NULL));
    for(j = 0; j < 10; j++)
    {
        clock_gettime(CLOCK_MONOTONIC,&tp1);
        for(i = 0; i < 10000000; i++)
            mt_rand();
        clock_gettime(CLOCK_MONOTONIC,&tp2);
        elapsed_time = (unsigned long) (tp2.tv_sec-tp1.tv_sec)*1000000000 + \
                       (unsigned long) tp2.tv_nsec-tp1.tv_nsec;
        times[j] = elapsed_time;
    }
    calc_mean_var(&mean,&var,times);

    printf("| Mersenne Twister:    %.4lf ± %.4lf |\n",mean/1e9, sqrt(var)/1e9);
#endif

#if WELL_RAND || RANDS_USE_ALL
    well_srand(time(NULL));
    for(j = 0; j < 10; j++)
    {
        clock_gettime(CLOCK_MONOTONIC,&tp1);
        for(i = 0; i < 10000000; i++)
            well_rand();
        clock_gettime(CLOCK_MONOTONIC,&tp2);
        elapsed_time = (unsigned long) (tp2.tv_sec-tp1.tv_sec)*1000000000 + \
                       (unsigned long) tp2.tv_nsec-tp1.tv_nsec;
        times[j] = elapsed_time;
    }
    calc_mean_var(&mean,&var,times);

    printf("| WELL512:             %.4lf ± %.4lf |\n",mean/1e9, sqrt(var)/1e9);
#endif

#if WELL_X64_RAND || RANDS_USE_ALL
    well_x64_srand(time(NULL));
    for(j = 0; j < 10; j++)
    {
        clock_gettime(CLOCK_MONOTONIC,&tp1);
        for(i = 0; i < 5000000; i++)
            well_x64_rand();
        clock_gettime(CLOCK_MONOTONIC,&tp2);
        elapsed_time = (unsigned long) (tp2.tv_sec-tp1.tv_sec)*1000000000 + \
                       (unsigned long) tp2.tv_nsec-tp1.tv_nsec;
        times[j] = elapsed_time;
    }
    calc_mean_var(&mean,&var,times);

    printf("| WELL512 (64bits):    %.4lf ± %.4lf |\n",mean/1e9, sqrt(var)/1e9);
#endif

#if XOR_RAND || RANDS_USE_ALL
    xor_srand(time(NULL));
    for(j = 0; j < 10; j++)
    {
        clock_gettime(CLOCK_MONOTONIC,&tp1);
        for(i = 0; i < 10000000; i++)
            xor_rand();
        clock_gettime(CLOCK_MONOTONIC,&tp2);
        elapsed_time = (unsigned long) (tp2.tv_sec-tp1.tv_sec)*1000000000 + \
                       (unsigned long) tp2.tv_nsec-tp1.tv_nsec;
        times[j] = elapsed_time;
    }
    calc_mean_var(&mean,&var,times);

    printf("| Xorshift:            %.4lf ± %.4lf |\n",mean/1e9, sqrt(var)/1e9);
#endif

    // END OF 32 BITS
    
    printf("+--------------------------------------+\n");
    printf("+--------------------------------------+\n");
    printf("| 64 Bits                              |\n");
    printf("+--------------------------------------+\n");

#if ISAAC_RAND || RANDS_USE_ALL
    isaac_srand(time(NULL));
    for(j = 0; j < 10; j++)
    {
        clock_gettime(CLOCK_MONOTONIC,&tp1);
        for(i = 0; i < 20000000; i++)
            isaac_rand();
        clock_gettime(CLOCK_MONOTONIC,&tp2);
        elapsed_time = (unsigned long) (tp2.tv_sec-tp1.tv_sec)*1000000000 + \
                       (unsigned long) tp2.tv_nsec-tp1.tv_nsec;
        times[j] = elapsed_time;
    }
    calc_mean_var(&mean,&var,times);

    printf("| ISAAC:               %.4lf ± %.4lf |\n",mean/1e9, sqrt(var)/1e9);
#endif

#if ISAAC_X64_RAND || RANDS_USE_ALL
    isaac_srand(time(NULL));
    for(j = 0; j < 10; j++)
    {
        clock_gettime(CLOCK_MONOTONIC,&tp1);
        for(i = 0; i < 10000000; i++)
            isaac_x64_rand();
        clock_gettime(CLOCK_MONOTONIC,&tp2);
        elapsed_time = (unsigned long) (tp2.tv_sec-tp1.tv_sec)*1000000000 + \
                       (unsigned long) tp2.tv_nsec-tp1.tv_nsec;
        times[j] = elapsed_time;
    }
    calc_mean_var(&mean,&var,times);

    printf("| ISAAC (64bits):      %.4lf ± %.4lf |\n",mean/1e9, sqrt(var)/1e9);
#endif

#if PR_RAND || RANDS_USE_ALL
    pr_srand(time(NULL));
    for(j = 0; j < 10; j++)
    {
        clock_gettime(CLOCK_MONOTONIC,&tp1);
        for(i = 0; i < 20000000; i++)
            pr_rand();
        clock_gettime(CLOCK_MONOTONIC,&tp2);
        elapsed_time = (unsigned long) (tp2.tv_sec-tp1.tv_sec)*1000000000 + \
                       (unsigned long) tp2.tv_nsec-tp1.tv_nsec;
        times[j] = elapsed_time;
    }
    calc_mean_var(&mean,&var,times);

    printf("| Parisi-Rapuano:      %.4lf ± %.4lf |\n",mean/1e9, sqrt(var)/1e9);
#endif

#if __SSE2__
#if PR_SSE_RAND || RANDS_USE_ALL
    pr_sse_srand(time(NULL));
    for(j = 0; j < 10; j++)
    {
        clock_gettime(CLOCK_MONOTONIC,&tp1);
        for(i = 0; i < 20000000; i++)
            pr_sse_rand();
        clock_gettime(CLOCK_MONOTONIC,&tp2);
        elapsed_time = (unsigned long) (tp2.tv_sec-tp1.tv_sec)*1000000000 + \
                       (unsigned long) tp2.tv_nsec-tp1.tv_nsec;
        times[j] = elapsed_time;
    }
    calc_mean_var(&mean,&var,times);

    printf("| Parisi-Rapuano SSE:  %.4lf ± %.4lf |\n",mean/1e9, sqrt(var)/1e9);
#endif
#endif

    srand(time(NULL));
    for(j = 0; j < 10; j++)
    {
        clock_gettime(CLOCK_MONOTONIC,&tp1);
        for(i = 0; i < 20000000; i++)
            rand();
        clock_gettime(CLOCK_MONOTONIC,&tp2);
        elapsed_time = (unsigned long) (tp2.tv_sec-tp1.tv_sec)*1000000000 + \
                       (unsigned long) tp2.tv_nsec-tp1.tv_nsec;
        times[j] = elapsed_time;
    }
    calc_mean_var(&mean,&var,times);

    printf("| Rand (stdlib):       %.4lf ± %.4lf |\n",mean/1e9, sqrt(var)/1e9);

#if MT_RAND || RANDS_USE_ALL
    mt_srand(time(NULL));
    for(j = 0; j < 10; j++)
    {
        clock_gettime(CLOCK_MONOTONIC,&tp1);
        for(i = 0; i < 20000000; i++)
            mt_rand();
        clock_gettime(CLOCK_MONOTONIC,&tp2);
        elapsed_time = (unsigned long) (tp2.tv_sec-tp1.tv_sec)*1000000000 + \
                       (unsigned long) tp2.tv_nsec-tp1.tv_nsec;
        times[j] = elapsed_time;
    }
    calc_mean_var(&mean,&var,times);

    printf("| Mersenne Twister:    %.4lf ± %.4lf |\n",mean/1e9, sqrt(var)/1e9);
#endif

#if WELL_RAND || RANDS_USE_ALL
    well_srand(time(NULL));
    for(j = 0; j < 10; j++)
    {
        clock_gettime(CLOCK_MONOTONIC,&tp1);
        for(i = 0; i < 20000000; i++)
            well_rand();
        clock_gettime(CLOCK_MONOTONIC,&tp2);
        elapsed_time = (unsigned long) (tp2.tv_sec-tp1.tv_sec)*1000000000 + \
                       (unsigned long) tp2.tv_nsec-tp1.tv_nsec;
        times[j] = elapsed_time;
    }
    calc_mean_var(&mean,&var,times);

    printf("| WELL512:             %.4lf ± %.4lf |\n",mean/1e9, sqrt(var)/1e9);
#endif

#if WELL_X64_RAND || RANDS_USE_ALL
    well_x64_srand(time(NULL));
    for(j = 0; j < 10; j++)
    {
        clock_gettime(CLOCK_MONOTONIC,&tp1);
        for(i = 0; i < 10000000; i++)
            well_x64_rand();
        clock_gettime(CLOCK_MONOTONIC,&tp2);
        elapsed_time = (unsigned long) (tp2.tv_sec-tp1.tv_sec)*1000000000 + \
                       (unsigned long) tp2.tv_nsec-tp1.tv_nsec;
        times[j] = elapsed_time;
    }
    calc_mean_var(&mean,&var,times);

    printf("| WELL512 (64bits):    %.4lf ± %.4lf |\n",mean/1e9, sqrt(var)/1e9);
#endif

#if XOR_RAND || RANDS_USE_ALL
    xor_srand(time(NULL));
    for(j = 0; j < 10; j++)
    {
        clock_gettime(CLOCK_MONOTONIC,&tp1);
        for(i = 0; i < 20000000; i++)
            xor_rand();
        clock_gettime(CLOCK_MONOTONIC,&tp2);
        elapsed_time = (unsigned long) (tp2.tv_sec-tp1.tv_sec)*1000000000 + \
                       (unsigned long) tp2.tv_nsec-tp1.tv_nsec;
        times[j] = elapsed_time;
    }
    calc_mean_var(&mean,&var,times);

    printf("| Xorshift:            %.4lf ± %.4lf |\n",mean/1e9, sqrt(var)/1e9);
#endif

    // END OF 64 BITS

    printf("+--------------------------------------+\n");
    
    return 0;
}
Beispiel #7
0
uint32_t
rng_gen_u32(rust_rng* rng) {
    uint32_t x = isaac_rand(&rng->rctx);
    rng_maybe_reseed(rng);
    return x;
}