Subversion Repositories openrisc

//==========================================================================

//

//        tm_posix.cxx

//

//        Basic timing test / scaffolding

//

//==========================================================================

// ####ECOSGPLCOPYRIGHTBEGIN####                                            

// -------------------------------------------                              

// This file is part of eCos, the Embedded Configurable Operating System.   

// Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.

//

// eCos is free software; you can redistribute it and/or modify it under    

// the terms of the GNU General Public License as published by the Free     

// Software Foundation; either version 2 or (at your option) any later      

// version.                                                                 

//

// eCos is distributed in the hope that it will be useful, but WITHOUT      

// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or    

// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License    

// for more details.                                                        

//

// You should have received a copy of the GNU General Public License        

// along with eCos; if not, write to the Free Software Foundation, Inc.,    

// 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.            

//

// As a special exception, if other files instantiate templates or use      

// macros or inline functions from this file, or you compile this file      

// and link it with other works to produce a work based on this file,       

// this file does not by itself cause the resulting work to be covered by   

// the GNU General Public License. However the source code for this file    

// must still be made available in accordance with section (3) of the GNU   

// General Public License v2.                                               

//

// This exception does not invalidate any other reasons why a work based    

// on this file might be covered by the GNU General Public License.         

// -------------------------------------------                              

// ####ECOSGPLCOPYRIGHTEND####                                              

//==========================================================================

//#####DESCRIPTIONBEGIN####

//

// Author(s):     gthomas,nickg

// Contributors:  jlarmour

// Date:          1998-10-19

// Description:   Very simple kernel timing test

//####DESCRIPTIONEND####

//==========================================================================

#include <cyg/infra/testcase.h>

#include <cyg/infra/diag.h>

#include <pkgconf/posix.h>

#include <pkgconf/system.h>

#ifdef CYGPKG_KERNEL

#include <pkgconf/kernel.h>

#endif

#ifndef CYGPKG_POSIX_SIGNALS

#define NA_MSG "No POSIX signals"

#elif !defined(CYGPKG_POSIX_TIMERS)

#define NA_MSG "No POSIX timers"

#elif !defined(CYGPKG_POSIX_PTHREAD)

#define NA_MSG "POSIX threads not enabled"

#elif !defined(CYGFUN_KERNEL_API_C)

#define NA_MSG "Kernel C API not enabled"

#elif !defined(CYGSEM_KERNEL_SCHED_MLQUEUE)

#define NA_MSG "Kernel mlqueue scheduler not enabled"

#elif !defined(CYGVAR_KERNEL_COUNTERS_CLOCK)

#define NA_MSG "Kernel clock not enabled"

#elif CYGNUM_KERNEL_SCHED_PRIORITIES <= 12

#define NA_MSG "Kernel scheduler properties <= 12"

#elif !defined(CYGPKG_POSIX_SEMAPHORES)

#define NA_MSG "POSIX semaphores not enabled"

#endif

//==========================================================================

#ifdef NA_MSG

extern "C" void

cyg_start(void)

{

    CYG_TEST_INIT();

    CYG_TEST_NA(NA_MSG);

}

#else

#include <pkgconf/kernel.h>

#include <pkgconf/hal.h>

#include <cyg/kernel/sched.hxx>

#include <cyg/kernel/thread.hxx>

#include <cyg/kernel/thread.inl>

#include <cyg/kernel/mutex.hxx>

#include <cyg/kernel/sema.hxx>

#include <cyg/kernel/sched.inl>

#include <cyg/kernel/clock.hxx>

#include <cyg/kernel/clock.inl>

#include <cyg/kernel/kapi.h>

#include <cyg/infra/testcase.h>

#include <cyg/kernel/test/stackmon.h>

#include CYGHWR_MEMORY_LAYOUT_H

// POSIX headers

#include <sys/types.h>

#include <pthread.h>

#include <semaphore.h>

#include <time.h>

#include <signal.h>

#include <errno.h>

//==========================================================================

// Define this to see the statistics with the first sample datum removed.

// This can expose the effects of caches on the speed of operations.

#undef STATS_WITHOUT_FIRST_SAMPLE

//==========================================================================

// Structure used to keep track of times

typedef struct fun_times {

    cyg_uint32 start;

    cyg_uint32 end;

} fun_times;

//==========================================================================

#define STACK_SIZE (PTHREAD_STACK_MIN*2)

// Defaults

#define NTEST_THREADS    16

#define NMUTEXES         32

#define NMBOXES          32

#define NSEMAPHORES      32

#define NTIMERS          32

#define NSAMPLES         32

#define NTHREAD_SWITCHES 128

#define NSCHEDS          128

#define NSAMPLES_SIM         2

#define NTEST_THREADS_SIM    2

#define NTHREAD_SWITCHES_SIM 4

#define NMUTEXES_SIM         2

#define NMBOXES_SIM          2

#define NSEMAPHORES_SIM      2

#define NSCHEDS_SIM          4

#define NTIMERS_SIM          2

//==========================================================================

static int nsamples;

static int ntest_threads;

static int nthread_switches;

#ifdef CYGPKG_POSIX_PTHREAD_MUTEX

static int nmutexes;

#endif

static int nmboxes;

static int nsemaphores;

static int nscheds;

static int ntimers;

static char stacks[NTEST_THREADS][STACK_SIZE];

static pthread_t threads[NTEST_THREADS];

static int overhead;

static sem_t synchro;

static fun_times thread_ft[NTEST_THREADS];

static fun_times test2_ft[NTHREAD_SWITCHES];

#ifdef CYGPKG_POSIX_PTHREAD_MUTEX

static pthread_mutex_t test_mutexes[NMUTEXES];

static fun_times mutex_ft[NMUTEXES];

static pthread_t mutex_test_thread_handle;

#endif

#if 0

static cyg_mbox test_mboxes[NMBOXES];

static cyg_handle_t test_mbox_handles[NMBOXES];

static fun_times mbox_ft[NMBOXES];

static cyg_thread mbox_test_thread;

static cyg_handle_t mbox_test_thread_handle;

#endif

static sem_t test_semaphores[NSEMAPHORES];

static fun_times semaphore_ft[NSEMAPHORES];

static pthread_t semaphore_test_thread_handle;

static fun_times sched_ft[NSCHEDS];

static timer_t timers[NTIMERS];

static fun_times timer_ft[NTIMERS];

static long rtc_resolution[] = CYGNUM_KERNEL_COUNTERS_RTC_RESOLUTION;

static long ns_per_system_clock;

#if defined(CYGVAR_KERNEL_COUNTERS_CLOCK_LATENCY)

// Data kept by kernel real time clock measuring clock interrupt latency

extern cyg_tick_count total_clock_latency, total_clock_interrupts;

extern cyg_int32 min_clock_latency, max_clock_latency;

extern bool measure_clock_latency;

#endif

#if defined(CYGVAR_KERNEL_COUNTERS_CLOCK_DSR_LATENCY)

extern cyg_tick_count total_clock_dsr_latency, total_clock_dsr_calls;

extern cyg_int32 min_clock_dsr_latency, max_clock_dsr_latency;

extern bool measure_clock_latency;

#endif

//==========================================================================

void run_sched_tests(void);

void run_thread_tests(void);

void run_thread_switch_test(void);

#ifdef CYGPKG_POSIX_PTHREAD_MUTEX

void run_mutex_tests(void);

void run_mutex_circuit_test(void);

#endif

void run_mbox_tests(void);

void run_mbox_circuit_test(void);

void run_semaphore_tests(void);

void run_semaphore_circuit_test(void);

void run_timer_tests(void);

//==========================================================================

#ifndef max

#define max(n,m) (m > n ? n : m)

#endif

//==========================================================================

// Wait until a clock tick [real time clock] has passed.  This should keep it

// from happening again during a measurement, thus minimizing any fluctuations

void

wait_for_tick(void)

{

    cyg_tick_count_t tv0, tv1;

    tv0 = cyg_current_time();

    while (true) {

        tv1 = cyg_current_time();

        if (tv1 != tv0) break;

    }

}

//--------------------------------------------------------------------------

// Display a number of ticks as microseconds

// Note: for improved calculation significance, values are kept in ticks*1000

void

show_ticks_in_us(cyg_uint32 ticks)

{

    long long ns;

    ns = (ns_per_system_clock * (long long)ticks) / CYGNUM_KERNEL_COUNTERS_RTC_PERIOD;

    ns += 5;  // for rounding to .01us

    diag_printf("%5d.%02d", (int)(ns/1000), (int)((ns%1000)/10));

}

//--------------------------------------------------------------------------

//

// If the kernel is instrumented to measure clock interrupt latency, these

// measurements can be drastically perturbed by printing via "diag_printf()"

// since that code may run with interrupts disabled for long periods.

//

// In order to get accurate/reasonable latency figures _for the kernel 

// primitive functions beint tested_, the kernel's latency measurements

// are suspended while the printing actually takes place.

//

// The measurements are reenabled after the printing, thus allowing for

// fair measurements of the kernel primitives, which are not distorted

// by the printing mechanisms.

#if defined(CYGVAR_KERNEL_COUNTERS_CLOCK_LATENCY) && defined(HAL_CLOCK_LATENCY)

void

disable_clock_latency_measurement(void)

{

    wait_for_tick();

    measure_clock_latency = false;

}

void

enable_clock_latency_measurement(void)

{

    wait_for_tick();

    measure_clock_latency = true;

}

// Ensure that the measurements are reasonable (no startup anomalies)

void

reset_clock_latency_measurement(void)

{

  disable_clock_latency_measurement();

  total_clock_latency = 0;

  total_clock_interrupts = 0;

  min_clock_latency = 0x7FFFFFFF;

  max_clock_latency = 0;

#if defined(CYGVAR_KERNEL_COUNTERS_CLOCK_DSR_LATENCY)  

  total_clock_dsr_latency = 0;

  total_clock_dsr_calls = 0;

  min_clock_dsr_latency = 0x7FFFFFFF;

  max_clock_dsr_latency = 0;

#endif  

  enable_clock_latency_measurement();

}

#else

#define disable_clock_latency_measurement()

#define enable_clock_latency_measurement()

#define reset_clock_latency_measurement()

#endif

//--------------------------------------------------------------------------

void

show_times_hdr(void)

{

    disable_clock_latency_measurement();

    diag_printf("\n");

    diag_printf("                                 Confidence\n");

    diag_printf("     Ave     Min     Max     Var  Ave  Min  Function\n");

    diag_printf("  ======  ======  ======  ====== ========== ========\n");

    enable_clock_latency_measurement();

}

void

show_times_detail(fun_times ft[], int nsamples, char *title, bool ignore_first)

{

    int i, delta, min, max, con_ave, con_min, ave_dev;

    int start_sample, total_samples;

    cyg_int32 total, ave;

    if (ignore_first) {

        start_sample = 1;

        total_samples = nsamples-1;

    } else {

        start_sample = 0;

        total_samples = nsamples;

    }

    total = 0;

    min = 0x7FFFFFFF;

    max = 0;

    for (i = start_sample;  i < nsamples;  i++) {

        if (ft[i].end < ft[i].start) {

            // Clock wrapped around (timer tick)

            delta = (ft[i].end+CYGNUM_KERNEL_COUNTERS_RTC_PERIOD) - ft[i].start;

        } else {

            delta = ft[i].end - ft[i].start;

        }

        delta -= overhead;

        if (delta < 0) delta = 0;

        delta *= 1000;

        total += delta;

        if (delta < min) min = delta;

        if (delta > max) max = delta;

    }

    ave = total / total_samples;

    total = 0;

    ave_dev = 0;

    for (i = start_sample;  i < nsamples;  i++) {

        if (ft[i].end < ft[i].start) {

            // Clock wrapped around (timer tick)

            delta = (ft[i].end+CYGNUM_KERNEL_COUNTERS_RTC_PERIOD) - ft[i].start;

        } else {

            delta = ft[i].end - ft[i].start;

        }

        delta -= overhead;

        if (delta < 0) delta = 0;

        delta *= 1000;

        delta = delta - ave;

        if (delta < 0) delta = -delta;

        ave_dev += delta;

    }

    ave_dev /= total_samples;

    con_ave = 0;

    con_min = 0;

    for (i = start_sample;  i < nsamples;  i++) {

        if (ft[i].end < ft[i].start) {

            // Clock wrapped around (timer tick)

            delta = (ft[i].end+CYGNUM_KERNEL_COUNTERS_RTC_PERIOD) - ft[i].start;

        } else {

            delta = ft[i].end - ft[i].start;

        }

        delta -= overhead;

        if (delta < 0) delta = 0;

        delta *= 1000;

        if ((delta <= (ave+ave_dev)) && (delta >= (ave-ave_dev))) con_ave++;

        if ((delta <= (min+ave_dev)) && (delta >= (min-ave_dev))) con_min++;

    }

    con_ave = (con_ave * 100) / total_samples;

    con_min = (con_min * 100) / total_samples;

    show_ticks_in_us(ave);

    show_ticks_in_us(min);

    show_ticks_in_us(max);

    show_ticks_in_us(ave_dev);

    disable_clock_latency_measurement();

    diag_printf("  %3d%% %3d%%", con_ave, con_min);

    diag_printf(" %s\n", title);

    enable_clock_latency_measurement();

}

void

show_times(fun_times ft[], int nsamples, char *title)

{

    show_times_detail(ft, nsamples, title, false);

#ifdef STATS_WITHOUT_FIRST_SAMPLE

    show_times_detail(ft, nsamples, "", true);

#endif

}

//--------------------------------------------------------------------------

void

show_test_parameters(void)

{

    disable_clock_latency_measurement();

    diag_printf("\nTesting parameters:\n");

    diag_printf("   Clock samples:         %5d\n", nsamples);

    diag_printf("   Threads:               %5d\n", ntest_threads);

    diag_printf("   Thread switches:       %5d\n", nthread_switches);

#ifdef CYGPKG_POSIX_PTHREAD_MUTEX

    diag_printf("   Mutexes:               %5d\n", nmutexes);

#endif

    diag_printf("   Mailboxes:             %5d\n", nmboxes);

    diag_printf("   Semaphores:            %5d\n", nsemaphores);

    diag_printf("   Scheduler operations:  %5d\n", nscheds);

    diag_printf("   Timers:                %5d\n", ntimers);

    diag_printf("\n");

    enable_clock_latency_measurement();

}

void

end_of_test_group(void)

{

    disable_clock_latency_measurement();

    diag_printf("\n");

    enable_clock_latency_measurement();

}

//--------------------------------------------------------------------------

// Compute a name for a thread

char *

thread_name(char *basename, int indx) {

    return "<<NULL>>";  // Not currently used

}

//--------------------------------------------------------------------------

// test0 - null test, just return

void *

test0(void *indx)

{

    return indx;

}

//--------------------------------------------------------------------------

// test3 - loop, yeilding repeatedly and checking for cancellation

void *

test3(void *indx)

{

    for(;;)

    {

        sched_yield();

        pthread_testcancel();

    }

    return indx;

}

//--------------------------------------------------------------------------

// test1 - empty test, simply exit.  Last thread signals parent.

void *

test1( void *indx)

{

    if ((cyg_uint32)indx == (cyg_uint32)(ntest_threads-1)) {

        sem_post(&synchro);  // Signal that last thread is dying

    }

    return indx;

}

//--------------------------------------------------------------------------

// test2 - measure thread switch times

void *

test2(void *indx)

{

    int i;

    for (i = 0;  i < nthread_switches;  i++) {

        if ((int)indx == 0) {

            HAL_CLOCK_READ(&test2_ft[i].start);

        } else {

            HAL_CLOCK_READ(&test2_ft[i].end);

        }

        sched_yield();

    }

    if ((int)indx == 1) {

        sem_post(&synchro);

    }

    return indx;

}

#ifdef CYGPKG_POSIX_PTHREAD_MUTEX

//--------------------------------------------------------------------------

// Full-circuit mutex unlock/lock test

void *

mutex_test(void * indx)

{

    int i;

    pthread_mutex_lock(&test_mutexes[0]);

    for (i = 0;  i < nmutexes;  i++) {

        sem_wait(&synchro);

        wait_for_tick(); // Wait until the next clock tick to minimize aberations

        HAL_CLOCK_READ(&mutex_ft[i].start);

        pthread_mutex_unlock(&test_mutexes[0]);

        pthread_mutex_lock(&test_mutexes[0]);

        sem_post(&synchro);

    }

    return indx;

}

//--------------------------------------------------------------------------

// Full-circuit mbox put/get test

#if 0

void

mbox_test(cyg_uint32 indx)

{

    void *item;

    do {

        item = cyg_mbox_get(test_mbox_handles[0]);

        HAL_CLOCK_READ(&mbox_ft[(int)item].end);

        cyg_semaphore_post(&synchro);

    } while ((int)item != (nmboxes-1));

    cyg_thread_exit(0);

}

#endif

#endif

//--------------------------------------------------------------------------

// Full-circuit semaphore post/wait test

void *

semaphore_test(void * indx)

{

    int i;

    for (i = 0;  i < nsemaphores;  i++) {

        sem_wait(&test_semaphores[0]);

        HAL_CLOCK_READ(&semaphore_ft[i].end);

        sem_post(&synchro);

    }

    return indx;

}

//--------------------------------------------------------------------------

//

// This set of tests is used to measure kernel primitives that deal with threads

//

void

run_thread_tests(void)

{

    int i;

    struct sched_param schedparam;

    pthread_attr_t attr;

    int policy;

    void *retval;

    // Set my priority higher than any I plan to create

    schedparam.sched_priority = 30;

    pthread_setschedparam( pthread_self(), SCHED_RR, &schedparam );

    // Initiaize thread creation attributes

    pthread_attr_init( &attr );

    pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED );

    pthread_attr_setschedpolicy( &attr, SCHED_RR );

    schedparam.sched_priority = 10;

    pthread_attr_setschedparam( &attr, &schedparam );

    wait_for_tick(); // Wait until the next clock tick to minimize aberations

    for (i = 0;  i < ntest_threads;  i++) {

        HAL_CLOCK_READ(&thread_ft[i].start);

        pthread_attr_setstackaddr( &attr, &stacks[i][STACK_SIZE] );

        pthread_attr_setstacksize( &attr, STACK_SIZE );

        pthread_create( &threads[i],

                        &attr,

                        test0,

                        (void *)i

                        );

        HAL_CLOCK_READ(&thread_ft[i].end);

    }

    show_times(thread_ft, ntest_threads, "Create thread");

    wait_for_tick(); // Wait until the next clock tick to minimize aberations

    for (i = 0;  i < ntest_threads;  i++) {

        HAL_CLOCK_READ(&thread_ft[i].start);

        sched_yield();

        HAL_CLOCK_READ(&thread_ft[i].end);

    }

    show_times(thread_ft, ntest_threads, "Yield thread [all lower priority]");

    wait_for_tick(); // Wait until the next clock tick to minimize aberations

    for (i = 0;  i < ntest_threads;  i++) {

        HAL_CLOCK_READ(&thread_ft[i].start);

        schedparam.sched_priority = 11;

        pthread_attr_setschedparam( &attr, &schedparam );

        pthread_setschedparam(threads[i], SCHED_RR, &schedparam);

        HAL_CLOCK_READ(&thread_ft[i].end);

    }

    show_times(thread_ft, ntest_threads, "Set priority");

    wait_for_tick(); // Wait until the next clock tick to minimize aberations

    for (i = 0;  i < ntest_threads;  i++) {

        HAL_CLOCK_READ(&thread_ft[i].start);

        pthread_getschedparam( threads[i], &policy, &schedparam );

        HAL_CLOCK_READ(&thread_ft[i].end);

    }

    show_times(thread_ft, ntest_threads, "Get priority");

    cyg_thread_delay(1);        // Let the test threads run

    wait_for_tick(); // Wait until the next clock tick to minimize aberations

    for (i = 0;  i < ntest_threads;  i++) {

        HAL_CLOCK_READ(&thread_ft[i].start);

        pthread_join(threads[i], &retval);

        HAL_CLOCK_READ(&thread_ft[i].end);

    }

    show_times(thread_ft, ntest_threads, "Join exited thread");

    wait_for_tick(); // Wait until the next clock tick to minimize aberations

    for (i = 0;  i < ntest_threads;  i++) {

        HAL_CLOCK_READ(&thread_ft[i].start);

        sched_yield();

        HAL_CLOCK_READ(&thread_ft[i].end);

    }

    show_times(thread_ft, ntest_threads, "Yield [no other] thread");

    // Recreate the test set

    schedparam.sched_priority = 10;

    pthread_attr_setschedparam( &attr, &schedparam );

    for (i = 0;  i < ntest_threads;  i++) {

        pthread_attr_setstackaddr( &attr, &stacks[i][STACK_SIZE] );

        pthread_attr_setstacksize( &attr, STACK_SIZE );

        pthread_create( &threads[i],

                        &attr,

                        test3,

                        (void *)i

                        );

    }

    cyg_thread_delay(1);        // Let the test threads run    

    wait_for_tick(); // Wait until the next clock tick to minimize aberations

    for (i = 0;  i < ntest_threads;  i++) {

        HAL_CLOCK_READ(&thread_ft[i].start);

        pthread_cancel(threads[i]);

        HAL_CLOCK_READ(&thread_ft[i].end);

    }

    show_times(thread_ft, ntest_threads, "Cancel [running] thread");

    cyg_thread_delay(1);        // Let the test threads do their cancellations

    wait_for_tick(); // Wait until the next clock tick to minimize aberations

    for (i = 0;  i < ntest_threads;  i++) {

        HAL_CLOCK_READ(&thread_ft[i].start);

        pthread_join(threads[i], &retval);

        HAL_CLOCK_READ(&thread_ft[i].end);

    }

    show_times(thread_ft, ntest_threads, "Join [cancelled] thread");

    // Set my priority lower than any I plan to create

    schedparam.sched_priority = 5;

    pthread_setschedparam( pthread_self(), SCHED_RR, &schedparam );

    // Set up the end-of-threads synchronizer