Subversion Repositories openrisc

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

//

//        tm_basic.cxx

//

//        Basic timing test / scaffolding

//

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

//####ECOSGPLCOPYRIGHTBEGIN####

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

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

// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.

// Copyright (C) 2002 Gary Thomas

//

// 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.,

// 59 Temple Place, Suite 330, Boston, MA 02111-1307 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.

//

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

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

//

// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.

// at http://sources.redhat.com/ecos/ecos-license/

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

//####ECOSGPLCOPYRIGHTEND####

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

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

//

// Author(s):     gthomas

// Contributors:  gthomas

// Date:          1998-10-19

// Description:   Very simple kernel timing test

//####DESCRIPTIONEND####

#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/flag.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/infra/diag.h>

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

#include CYGHWR_MEMORY_LAYOUT_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

#if defined(CYGFUN_KERNEL_API_C) &&             \

    defined(CYGSEM_KERNEL_SCHED_MLQUEUE) &&     \

    defined(CYGVAR_KERNEL_COUNTERS_CLOCK) &&    \

    !defined(CYGDBG_INFRA_DIAG_USE_DEVICE) &&   \

    (CYGNUM_KERNEL_SCHED_PRIORITIES > 12)

#define NTHREADS 1

#include "testaux.hxx"

// Structure used to keep track of times

typedef struct fun_times {

    cyg_uint32 start;

    cyg_uint32 end;

} fun_times;

#define STACK_SIZE CYGNUM_HAL_STACK_SIZE_MINIMUM

#ifdef CYGMEM_REGION_ram_SIZE

#define CYG_THREAD_OVERHEAD  (STACK_SIZE+sizeof(cyg_thread)+(sizeof(fun_times)*2))

#define NTEST_THREADS        ((CYGMEM_REGION_ram_SIZE/16)/CYG_THREAD_OVERHEAD)

#define CYG_MUTEX_OVERHEAD   (sizeof(cyg_mutex_t)+sizeof(fun_times))

#define NMUTEXES             ((CYGMEM_REGION_ram_SIZE/16)/CYG_MUTEX_OVERHEAD)

#define CYG_MBOX_OVERHEAD    (sizeof(cyg_mbox)+sizeof(fun_times))

#define NMBOXES              ((CYGMEM_REGION_ram_SIZE/24)/CYG_MBOX_OVERHEAD)

#define CYG_SEMAPHORE_OVERHEAD (sizeof(cyg_sem_t)+sizeof(fun_times))

#define NSEMAPHORES          ((CYGMEM_REGION_ram_SIZE/16)/CYG_SEMAPHORE_OVERHEAD)

#define CYG_COUNTER_OVERHEAD (sizeof(cyg_counter)+sizeof(fun_times))

#define NCOUNTERS            ((CYGMEM_REGION_ram_SIZE/24)/CYG_COUNTER_OVERHEAD)

#define CYG_FLAG_OVERHEAD    (sizeof(cyg_flag_t)+sizeof(fun_times))

#define NFLAGS               ((CYGMEM_REGION_ram_SIZE/24)/CYG_FLAG_OVERHEAD)

#define CYG_ALARM_OVERHEAD   (sizeof(cyg_alarm)+sizeof(fun_times))

#define NALARMS              ((CYGMEM_REGION_ram_SIZE/16)/CYG_ALARM_OVERHEAD)

#else

// Defaults

#define NTEST_THREADS    16

#define NMUTEXES         32

#define NMBOXES          32

#define NSEMAPHORES      32

#define NFLAGS           32

#define NCOUNTERS        32

#define NALARMS          32

#endif

#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 NFLAGS_SIM           2

#define NCOUNTERS_SIM        2

#define NALARMS_SIM          2

static int nsamples;

static int ntest_threads;

static int nthread_switches;

static int nmutexes;

static int nmboxes;

static int nsemaphores;

static int nscheds;

static int nflags;

static int ncounters;

static int nalarms;

static char stacks[NTEST_THREADS][STACK_SIZE];

static cyg_thread test_threads[NTEST_THREADS];

static cyg_handle_t threads[NTEST_THREADS];

static int overhead;

static cyg_sem_t synchro;

static fun_times thread_ft[NTEST_THREADS];

static fun_times test2_ft[NTHREAD_SWITCHES];

static cyg_mutex_t test_mutexes[NMUTEXES];

static fun_times mutex_ft[NMUTEXES];

static cyg_thread mutex_test_thread;

static cyg_handle_t mutex_test_thread_handle;

static cyg_mbox test_mboxes[NMBOXES];

static cyg_handle_t test_mbox_handles[NMBOXES];

static fun_times mbox_ft[NMBOXES];

#ifdef CYGMFN_KERNEL_SYNCH_MBOXT_PUT_CAN_WAIT

static cyg_thread mbox_test_thread;

static cyg_handle_t mbox_test_thread_handle;

#endif

static cyg_sem_t test_semaphores[NSEMAPHORES];

static fun_times semaphore_ft[NSEMAPHORES];

static cyg_thread semaphore_test_thread;

static cyg_handle_t semaphore_test_thread_handle;

static fun_times sched_ft[NSCHEDS];

static cyg_counter test_counters[NCOUNTERS];

static cyg_handle_t counters[NCOUNTERS];

static fun_times counter_ft[NCOUNTERS];

static cyg_flag_t test_flags[NFLAGS];

static fun_times flag_ft[NFLAGS];

static cyg_alarm test_alarms[NALARMS];

static cyg_handle_t alarms[NALARMS];

static fun_times alarm_ft[NALARMS];

static long rtc_resolution[] = CYGNUM_KERNEL_COUNTERS_RTC_RESOLUTION;

static long ns_per_system_clock;

#if defined(CYGVAR_KERNEL_COUNTERS_CLOCK_LATENCY)  && defined(HAL_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) && defined(HAL_CLOCK_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);

void run_mutex_tests(void);

void run_mutex_circuit_test(void);

void run_mbox_tests(void);

void run_mbox_circuit_test(void);

void run_semaphore_tests(void);

void run_semaphore_circuit_test(void);

void run_counter_tests(void);

void run_flag_tests(void);

void run_alarm_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) && defined(HAL_CLOCK_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);

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

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

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

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

    diag_printf("   Counters:              %5d\n", ncounters);

    diag_printf("   Flags:                 %5d\n", nflags);

    diag_printf("   Alarms:                %5d\n", nalarms);

    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, never executed

void

test0(cyg_uint32 indx)

{

#ifndef CYGPKG_KERNEL_SMP_SUPPORT

    // In SMP, somw of these threads will execute

    diag_printf("test0.%d executed?\n", indx);

#endif    

    cyg_thread_exit();

}

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

void

test1(cyg_uint32 indx)

{

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

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

    }

    cyg_thread_exit();

}

// test2 - measure thread switch times

void

test2(cyg_uint32 indx)

{

    int i;

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

        if (indx == 0) {

            HAL_CLOCK_READ(&test2_ft[i].start);

        } else {

            HAL_CLOCK_READ(&test2_ft[i].end);

        }

        cyg_thread_yield();

    }

    if (indx == 1) {

        cyg_semaphore_post(&synchro);

    }

    cyg_thread_exit();

}

// Full-circuit mutex unlock/lock test

void

mutex_test(cyg_uint32 indx)

{

    int i;

    cyg_mutex_lock(&test_mutexes[0]);

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

        cyg_semaphore_wait(&synchro);

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

        HAL_CLOCK_READ(&mutex_ft[i].start);

        cyg_mutex_unlock(&test_mutexes[0]);

        cyg_mutex_lock(&test_mutexes[0]);

        cyg_semaphore_post(&synchro);

    }

    cyg_thread_exit();

}

// Full-circuit mbox put/get test

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();

}

// Full-circuit semaphore post/wait test

void

semaphore_test(cyg_uint32 indx)

{

    int i;

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

        cyg_semaphore_wait(&test_semaphores[0]);

        HAL_CLOCK_READ(&semaphore_ft[i].end);

        cyg_semaphore_post(&synchro);

    }

    cyg_thread_exit();

}

//

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

//

void

run_thread_tests(void)

{

    int i;

    cyg_priority_t prio;

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

    cyg_thread_set_priority(cyg_thread_self(), 2);

    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);

        cyg_thread_create(10,              // Priority - just a number

                          test0,           // entry

                          i,               // index

                          thread_name("thread", i),     // Name

                          &stacks[i][0],   // Stack

                          STACK_SIZE,      // Size

                          &threads[i],     // Handle

                          &test_threads[i] // Thread data structure

            );

        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);

        cyg_thread_yield();

        HAL_CLOCK_READ(&thread_ft[i].end);

    }

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

    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);

        cyg_thread_suspend(threads[i]);

        HAL_CLOCK_READ(&thread_ft[i].end);

    }

    show_times(thread_ft, ntest_threads, "Suspend [suspended] 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);

        cyg_thread_resume(threads[i]);

        HAL_CLOCK_READ(&thread_ft[i].end);

    }

    show_times(thread_ft, ntest_threads, "Resume 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);

        cyg_thread_set_priority(threads[i], 11);

        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);

        prio = cyg_thread_get_priority(threads[i]);

        HAL_CLOCK_READ(&thread_ft[i].end);

    }

    show_times(thread_ft, ntest_threads, "Get 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);

        cyg_thread_kill(threads[i]);

        HAL_CLOCK_READ(&thread_ft[i].end);

    }

    show_times(thread_ft, ntest_threads, "Kill [suspended] 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);

        cyg_thread_yield();

        HAL_CLOCK_READ(&thread_ft[i].end);

    }

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

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

    cyg_thread_set_priority(cyg_thread_self(), 2);

    // Recreate the test set

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

        cyg_thread_create(10,              // Priority - just a number

                          test0,           // entry

                          i,               // index

                          thread_name("thread", i),     // Name

                          &stacks[i][0],   // Stack

                          STACK_SIZE,      // Size

                          &threads[i],     // Handle

                          &test_threads[i] // Thread data structure

            );

    }

    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);

        cyg_thread_resume(threads[i]);

        HAL_CLOCK_READ(&thread_ft[i].end);

    }

    show_times(thread_ft, ntest_threads, "Resume [suspended low prio] 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);

        cyg_thread_resume(threads[i]);

        HAL_CLOCK_READ(&thread_ft[i].end);

    }

    show_times(thread_ft, ntest_threads, "Resume [runnable low prio] 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);

        cyg_thread_suspend(threads[i]);

        HAL_CLOCK_READ(&thread_ft[i].end);

    }

    show_times(thread_ft, ntest_threads, "Suspend [runnable] 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);

        cyg_thread_yield();

        HAL_CLOCK_READ(&thread_ft[i].end);

    }

    show_times(thread_ft, ntest_threads, "Yield [only low prio] 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);

        cyg_thread_suspend(threads[i]);

        HAL_CLOCK_READ(&thread_ft[i].end);

    }

    show_times(thread_ft, ntest_threads, "Suspend [runnable->not runnable]");

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

        cyg_thread_resume(threads[i]);

    }

    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);

        cyg_thread_kill(threads[i]);

        HAL_CLOCK_READ(&thread_ft[i].end);

    }

    show_times(thread_ft, ntest_threads, "Kill [runnable] 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);

        cyg_thread_delete(threads[i]);

        HAL_CLOCK_READ(&thread_ft[i].end);