URL
https://opencores.org/ocsvn/openrisc/openrisc/trunk
Subversion Repositories openrisc
[/] [openrisc/] [trunk/] [rtos/] [ecos-2.0/] [packages/] [kernel/] [v2_0/] [tests/] [kmutex4.c] - Rev 565
Go to most recent revision | Compare with Previous | Blame | View Log
//========================================================================== // // kmutex4.c // // Mutex test 4 - dynamic priority inheritance protocol // //========================================================================== //####ECOSGPLCOPYRIGHTBEGIN#### // ------------------------------------------- // This file is part of eCos, the Embedded Configurable Operating System. // Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, 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., // 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): hmt // Contributors: hmt // Date: 2000-01-06, 2001-08-10, 2001-08-21 // Description: Tests mutex priority inheritance. This is an extension of // kmutex3.c, to test the new "set the protocol at run-time" // extensions. //####DESCRIPTIONEND#### #include <pkgconf/hal.h> #include <pkgconf/kernel.h> #include <cyg/infra/testcase.h> #include <cyg/hal/hal_arch.h> // CYGNUM_HAL_STACK_SIZE_TYPICAL #include <cyg/infra/diag.h> // diag_printf #ifdef CYGSEM_HAL_STOP_CONSTRUCTORS_ON_FLAG externC void cyg_hal_invoke_constructors(); #endif // ------------------------------------------------------------------------ // // These checks should be enough; any other scheduler which has priorities // should manifest as having no priority inheritance, but otherwise fine, // so the test should work correctly. #if defined(CYGVAR_KERNEL_COUNTERS_CLOCK) && \ (CYGNUM_KERNEL_SCHED_PRIORITIES > 20) && \ defined(CYGFUN_KERNEL_API_C) && \ !defined(CYGPKG_KERNEL_SMP_SUPPORT) && \ defined(CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_DYNAMIC) \ #include <cyg/kernel/kapi.h> #include <cyg/infra/cyg_ass.h> #include <cyg/infra/cyg_trac.h> #include <cyg/infra/diag.h> // diag_printf // ------------------------------------------------------------------------ #define nVERBOSE // ------------------------------------------------------------------------ // We have dynamic protocol choice, so we can set the protocol to whatever // we want. We'll do these combinations: // NONE // INHERIT // CEILING = 4 = higher than any thread === INHERIT in behaviour // CEILING = 11 = mixed in with threads === cannot check anything // CEILING = 17 = lower than any threads === NONE in behaviour #define PROTO_NONE (0) #define PROTO_INHERIT (1) #define PROTO_CEILING_HIGH (2) #define PROTO_CEILING_MID (3) #define PROTO_CEILING_LOW (4) int proto; static char * protnames[] = { "none", "inherit", "high ceiling", "medium ceiling", "low ceiling", }; // ------------------------------------------------------------------------ // Management functions // // Stolen from testaux.hxx and copied in here because I want to be able to // reset the world also. // // Translated into KAPI also. #define NTHREADS 7 #define STACKSIZE CYGNUM_HAL_STACK_SIZE_TYPICAL static cyg_handle_t thread[NTHREADS] = { 0 }; typedef cyg_uint64 CYG_ALIGNMENT_TYPE; static cyg_thread thread_obj[NTHREADS]; static CYG_ALIGNMENT_TYPE stack[NTHREADS] [ (STACKSIZE+sizeof(CYG_ALIGNMENT_TYPE)-1) / sizeof(CYG_ALIGNMENT_TYPE) ]; static volatile int nthreads = 0; #undef NULL #define NULL (0) static cyg_handle_t new_thread( cyg_thread_entry_t *entry, cyg_addrword_t data, cyg_addrword_t priority, int do_resume, char *name ) { int _nthreads = nthreads++; CYG_ASSERT(_nthreads < NTHREADS, "Attempt to create more than NTHREADS threads"); cyg_thread_create( priority, entry, data, name, (void *)(stack[_nthreads]), STACKSIZE, &thread[_nthreads], &thread_obj[_nthreads] ); if ( do_resume ) cyg_thread_resume( thread[_nthreads] ); return thread[_nthreads]; } static void kill_threads( void ) { CYG_ASSERT(nthreads <= NTHREADS, "More than NTHREADS threads"); CYG_ASSERT( cyg_thread_self() == thread[0], "kill_threads() not called from thread 0"); while ( nthreads > 1 ) { nthreads--; if ( NULL != thread[nthreads] ) { do cyg_thread_kill( thread[nthreads] ); while ( ! cyg_thread_delete ( thread[nthreads] ) ); thread[nthreads] = NULL; } } CYG_ASSERT(nthreads == 1, "No threads left"); } // ------------------------------------------------------------------------ #define DELAYFACTOR 1 // for debugging // ------------------------------------------------------------------------ static cyg_mutex_t mutex_obj; static cyg_mutex_t *mutex; // These are for reporting back to the master thread volatile int got_it = 0; volatile int t3ran = 0; volatile int t3ended = 0; volatile int extras[4] = {0,0,0,0}; volatile int go_flag = 0; // but this one controls thread 3 from thread 2 // ------------------------------------------------------------------------ // 0 to 3 of these run generally to interfere with the other processing, // to cause multiple prio inheritances, and clashes in any orders. static void extra_thread( cyg_addrword_t data ) { cyg_handle_t self = cyg_thread_self(); #ifdef VERBOSE #define xXINFO( z ) \ do { z[13] = '0' + data; CYG_TEST_INFO( z ); } while ( 0 ) static char running[] = "Extra thread Xa running"; static char exiting[] = "Extra thread Xa exiting"; static char resumed[] = "Extra thread Xa resumed"; static char locked[] = "Extra thread Xa locked"; static char unlocked[] = "Extra thread Xa unlocked"; #else #define XINFO( z ) /* nothing */ #endif XINFO( running ); cyg_thread_suspend( self ); XINFO( resumed ); cyg_mutex_lock( mutex ); XINFO( locked ); cyg_mutex_unlock( mutex ); XINFO( unlocked ); extras[ data ] ++; XINFO( exiting ); } // ------------------------------------------------------------------------ static void t1( cyg_addrword_t data ) { cyg_handle_t self = cyg_thread_self(); #ifdef VERBOSE CYG_TEST_INFO( "Thread 1 running" ); #endif cyg_thread_suspend( self ); cyg_mutex_lock( mutex ); got_it++; CYG_TEST_CHECK( 0 == t3ended, "T3 ended prematurely [T1,1]" ); cyg_mutex_unlock( mutex ); CYG_TEST_CHECK( 0 == t3ended, "T3 ended prematurely [T1,2]" ); // That's all. #ifdef VERBOSE CYG_TEST_INFO( "Thread 1 exit" ); #endif } // ------------------------------------------------------------------------ static void t2( cyg_addrword_t data ) { cyg_handle_t self = cyg_thread_self(); int i; cyg_tick_count_t then, now; #ifdef VERBOSE CYG_TEST_INFO( "Thread 2 running" ); #endif CYG_TEST_CHECK( 0 == (data & ~0x77), "Bad T2 arg: extra bits" ); CYG_TEST_CHECK( 0 == (data & (data >> 4)), "Bad T2 arg: overlap" ); cyg_thread_suspend( self ); // depending on our config argument, optionally restart some of the // extra threads to throw noise into the scheduler: for ( i = 0; i < 3; i++ ) if ( (1 << i) & data ) // bits 0-2 control cyg_thread_resume( thread[i+4] ); // extras are thread[4-6] cyg_thread_delay( DELAYFACTOR * 10 ); // let those threads run cyg_scheduler_lock(); // do this next lot atomically go_flag = 1; // unleash thread 3 cyg_thread_resume( thread[1] ); // resume thread 1 // depending on our config argument, optionally restart some of the // extra threads to throw noise into the scheduler at this later point: for ( i = 4; i < 7; i++ ) if ( (1 << i) & data ) // bits 4-6 control cyg_thread_resume( thread[i] ); // extras are thread[4-6] cyg_scheduler_unlock(); // let scheduling proceed // Need a delay (but not a CPU yield) to allow t3 to awaken and act on // the go_flag, otherwise we check these details below too soon. // Actually, waiting for the clock to tick a couple of times would be // better, so that is what we will do. Must be a busy-wait. then = cyg_current_time(); do { now = cyg_current_time(); // Wait longer than the delay in t3 waiting on go_flag } while ( now < (then + 3) ); // Check for whatever result we expect from the protocol selected: // This mirrors what is done in configury in kmutex3.c and mutex3.cxx if ( PROTO_CEILING_MID == proto ) { CYG_TEST_INFO( "Not checking: ceiling mid value" ); } else if ( PROTO_INHERIT == proto || PROTO_CEILING_HIGH == proto ) { CYG_TEST_INFO( "Checking priority scheme operating" ); CYG_TEST_CHECK( 1 == t3ran, "Thread 3 did not run" ); CYG_TEST_CHECK( 1 == got_it, "Thread 1 did not get the mutex" ); } else { CYG_TEST_INFO( "Checking NO priority scheme operating" ); CYG_TEST_CHECK( 0 == t3ran, "Thread 3 DID run" ); CYG_TEST_CHECK( 0 == got_it, "Thread 1 DID get the mutex" ); } CYG_TEST_CHECK( 0 == t3ended, "Thread 3 ended prematurely [T2,1]" ); cyg_thread_delay( DELAYFACTOR * 20 ); // let those threads run CYG_TEST_CHECK( 1 == t3ran, "Thread 3 did not run" ); CYG_TEST_CHECK( 1 == got_it, "Thread 1 did not get the mutex" ); CYG_TEST_CHECK( 1 == t3ended, "Thread 3 has not ended" ); for ( i = 0; i < 3; i++ ) if ( (1 << i) & (data | data >> 4) ) // bits 0-2 and 4-6 control CYG_TEST_CHECK( 1 == extras[i+1], "Extra thread did not run" ); else CYG_TEST_CHECK( 0 == extras[i+1], "Extra thread ran" ); CYG_TEST_PASS( "Thread 2 exiting, AOK" ); // That's all: restart the control thread. cyg_thread_resume( thread[0] ); } // ------------------------------------------------------------------------ static void t3( cyg_addrword_t data ) { #ifdef VERBOSE CYG_TEST_INFO( "Thread 3 running" ); #endif cyg_mutex_lock( mutex ); cyg_thread_delay( DELAYFACTOR * 5 ); // let thread 3a run cyg_thread_resume( thread[2] ); // resume thread 2 while ( 0 == go_flag ) cyg_thread_delay(1); // wait until we are told to go t3ran ++; // record the fact CYG_TEST_CHECK( 0 == got_it, "Thread 1 claims to have got my mutex" ); cyg_mutex_unlock( mutex ); t3ended ++; // record that we came back CYG_TEST_CHECK( 1 == got_it, "Thread 1 did not get the mutex" ); #ifdef VERBOSE CYG_TEST_INFO( "Thread 3 exit" ); #endif } // ------------------------------------------------------------------------ static void control_thread( cyg_addrword_t data ) { cyg_handle_t self = cyg_thread_self(); int i, z; CYG_TEST_INIT(); CYG_TEST_INFO( "Control Thread running" ); // Go through the 27 possibilities of resuming the extra threads // 0: not at all // 1: early in the process // 2: later on // which are represented by bits 0-3 and 4-6 resp in the argument to // thread 2 (none set means no resume at all). for ( i = 0; i < 27; i++ ) { static int xx[] = { 0, 1, 16 }; int j = i % 3; int k = (i / 3) % 3; int l = (i / 9) % 3; int d = xx[j] | (xx[k]<<1) | (xx[l]<<2) ; if ( cyg_test_is_simulator && (0 != i && 13 != i && 26 != i) ) continue; // 13 is 111 base 3, 26 is 222 base 3 // Go through all these priority inversion prevention protocols: // (if supported in this configuration) // PROTO_NONE (0) // PROTO_INHERIT (1) // PROTO_CEILING_HIGH (2) // PROTO_CEILING_MID (3) // PROTO_CEILING_LOW (4) for ( proto = PROTO_NONE; proto <= PROTO_CEILING_LOW; proto++ ) { // If no priority inheritance at all, running threads 1a and 2a is // OK, but not thread 3a; it blocks the world. if ( PROTO_NONE == proto || PROTO_CEILING_MID == proto || PROTO_CEILING_LOW == proto ) if ( l ) // Cannot run thread 3a if no continue; // priority inheritance at all. mutex = &mutex_obj; switch ( proto ) { #ifdef CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_NONE case PROTO_NONE: cyg_mutex_init( mutex ); cyg_mutex_set_protocol( mutex, CYG_MUTEX_NONE ); break; #endif #ifdef CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_INHERIT case PROTO_INHERIT: cyg_mutex_init( mutex ); cyg_mutex_set_protocol( mutex, CYG_MUTEX_INHERIT ); break; #endif #ifdef CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_CEILING case PROTO_CEILING_HIGH: cyg_mutex_init( mutex ); cyg_mutex_set_protocol( mutex, CYG_MUTEX_CEILING ); cyg_mutex_set_ceiling( mutex, (cyg_priority_t) 4 ); break; case PROTO_CEILING_MID: cyg_mutex_init( mutex ); cyg_mutex_set_protocol( mutex, CYG_MUTEX_CEILING ); cyg_mutex_set_ceiling( mutex, (cyg_priority_t) 11 ); break; case PROTO_CEILING_LOW: cyg_mutex_init( mutex ); cyg_mutex_set_protocol( mutex, CYG_MUTEX_CEILING ); cyg_mutex_set_ceiling( mutex, (cyg_priority_t) 17 ); break; #endif default: continue; // Break out of the prio for loop - do nothing } got_it = 0; t3ran = 0; t3ended = 0; for ( z = 0; z < 4; z++ ) extras[z] = 0; go_flag = 0; new_thread( t1, 0, 5, 1, "test 1" ); // Slot 1 new_thread( t2, d, 10, 1, "test 2" ); // Slot 2 new_thread( t3, 0, 15, 1, "test 3" ); // Slot 3 new_thread( extra_thread, 1, 8, j, "extra 1" ); // Slot 4 new_thread( extra_thread, 2, 12, k, "extra 2" ); // Slot 5 new_thread( extra_thread, 3, 17, l, "extra 3" ); // Slot 6 { static char *a[] = { "inactive", "run early", "run late" }; diag_printf( "\n----- %s [%2d] New Cycle: 0x%02x, Threads 1a %s, 2a %s, 3a %s -----\n", protnames[proto], i, d, a[j], a[k], a[l] ); } cyg_thread_suspend( self ); kill_threads(); cyg_mutex_destroy( mutex ); } } CYG_TEST_EXIT( "Control Thread exit" ); } // ------------------------------------------------------------------------ externC void cyg_user_start( void ) { #ifdef CYGSEM_HAL_STOP_CONSTRUCTORS_ON_FLAG cyg_hal_invoke_constructors(); #endif new_thread( control_thread, 0, 2, 1, "control thread" ); } #else // CYGVAR_KERNEL_COUNTERS_CLOCK &c externC void cyg_start( void ) { CYG_TEST_INIT(); CYG_TEST_PASS_FINISH("KMutex4 test requires:\n" "CYGFUN_KERNEL_API_C &&\n" "CYGVAR_KERNEL_COUNTERS_CLOCK &&\n" "(CYGNUM_KERNEL_SCHED_PRIORITIES > 20) &&\n" "!defined(CYGPKG_KERNEL_SMP_SUPPORT) &&\n" "defined(CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_DYNAMIC)\n" ); } #endif // CYGVAR_KERNEL_COUNTERS_CLOCK &c // ------------------------------------------------------------------------ // Documentation: enclosed is the design of this test. // // See mutex3.cxx or kmutex3.c // ------------------------------------------------------------------------ // EOF mutex4.c
Go to most recent revision | Compare with Previous | Blame | View Log