ecos-v2_0-branch: packages/kernel/current/tests/stress

comparison packages/kernel/current/tests/stress_threads.c @ 24:306eee292492 ecos-sw-1999-07-16

Merge from eCos master repository on 1999-07-16-05:47:06-BST

author	jlarmour
date	Fri, 16 Jul 1999 21:54:32 +0000
parents	53104bbd5f99
children	18ee5a9c102e

comparison

equal deleted inserted replaced

-:8883a9947b66
+:306eee292492
 // STACK_SIZE is typical +2kB for printf family calls which use big
 // auto variables.
 #define STACK_SIZE (2*1024 + CYGNUM_HAL_STACK_SIZE_TYPICAL)
 #define STACK_SIZE2 (8*1024 + CYGNUM_HAL_STACK_SIZE_TYPICAL)
-/* Allocate priorities in this order. This ensures that handlers
+// The number of instances in each thread class
-(which are the ones using the CPU) get enough CPU time to actually
-complete their tasks. */
 #define N_MAIN 1
 #define MAX_HANDLERS 19
 #define N_LISTENERS 4
 #define N_CLIENTS 4
+#define N_THREADS (N_MAIN+MAX_HANDLERS+N_LISTENERS+N_CLIENTS)
-#if (CYGNUM_KERNEL_SCHED_PRIORITIES >= (N_MAIN+MAX_HANDLERS+N_LISTENERS+N_CLIENTS))
+/* Allocate priorities in this order. This ensures that handlers
+(which are the ones using the CPU) get enough CPU time to actually
+complete their tasks. */
+//#define P_MAIN        0                       // This is defined by libc
+#define P_MAIN_PROGRAM  1
+#define P_BASE_HANDLER  2
+#define P_BASE_LISTENER (P_BASE_HANDLER+MAX_HANDLERS)
+#define P_BASE_CLIENT   (P_BASE_LISTENER+N_LISTENERS)
+#define P_MAX           (P_BASE_CLIENT+N_CLIENTS)
+#if (CYGNUM_KERNEL_SCHED_PRIORITIES >= (P_MAX))
 /* if we use the bitmap scheduler we must make sure we don't use the
 same priority more than once, so we must store those already in use */
-static volatile char priority_in_use[N_MAIN+MAX_HANDLERS+N_LISTENERS+N_CLIENTS];
+static volatile char priority_in_use[P_MAX];
 /* now declare (and allocate space for) some kernel objects, like the
 threads we will use */
 cyg_thread main_thread_s;
 cyg_thread handler_thread_s[MAX_HANDLERS];
 cyg_handle_t mainH;
 cyg_handle_t handlerH[MAX_HANDLERS];
 cyg_handle_t listenerH[N_LISTENERS];
 cyg_handle_t clientH[N_CLIENTS];
+/* space for thread names */
+char thread_name[P_MAX][20];
 /* and now variables for the procedure which is the thread */
 cyg_thread_entry_t main_program, client_program, listener_program,
 handler_program;
 /* a few mutexes used in the code */
 /* a global variable with which the client and server coordinate */
 int client_makes_request = 0;
 /* indicates that it's time to print out a report */
 int time_to_report = 0;
 /* print status after a delay of this many secs. */
 int time_report_delay;
 /*** now application-specific variables ***/
 /* an array that stores whether the handler threads are in use */
 int handler_thread_in_use[MAX_HANDLERS];
 char                *name,                  /* optional thread name      */
 void                *stack_base,            /* stack base, NULL = alloc  */
 cyg_ucount32        stack_size,             /* stack size, 0 = default   */
 cyg_handle_t        *handle,                /* returned thread handle    */
 cyg_thread          *thread                 /* put thread here           */
 );
 int get_handler_slot(cyg_handle_t current_threadH);
 void perform_stressful_tasks(void);
 void permute_array(char a[], int size, int seed);
 void setup_death_alarm(cyg_addrword_t data, cyg_handle_t *deathHp,
 /* main launches all the threads of the test */
 int
 main(void)
 {
 int i;
 CYG_TEST_INIT();
 CYG_TEST_INFO("# Entering stress's cyg_user_start() function");
 cyg_mutex_init(&client_request_lock);
 cyg_mutex_init(&statistics_print_lock);
 cyg_mutex_init(&free_handler_lock);
 /* initialize statistics */
 memset(&statistics, 0, sizeof(statistics));
 /* clear priority table */
 for (i = 0; i < sizeof(priority_in_use); i++)
 priority_in_use[i] = 0;
 /* initialize main thread */
 {
-char thread_name[] = "main";
+sc_thread_create(P_MAIN_PROGRAM, main_program, (cyg_addrword_t) 0,
+"main_program", (void *) main_stack, STACK_SIZE,
-sc_thread_create(0, main_program, (cyg_addrword_t) 0,
+&mainH, &main_thread_s);
-thread_name, (void *) main_stack, STACK_SIZE,
+priority_in_use[P_MAIN_PROGRAM]++;
-&mainH, &main_thread_s);
+}
-priority_in_use[0]++;
-}
+/* initialize all handler threads to not be in use */
+for (i = 0; i < MAX_HANDLERS; ++i) {
-/* initialize all handler threads to not be in use */
+handler_thread_in_use[i] = 0;
-for (i = 0; i < MAX_HANDLERS; ++i) {
+}
-handler_thread_in_use[i] = 0;
+for (i = 0; i < N_LISTENERS; ++i) {
-}
+int prio = P_BASE_LISTENER + i;
-for (i = 0; i < N_LISTENERS; ++i) {
+char* name = &thread_name[prio][0];
-int prio;
+sprintf(name, "listener-%02d/%02d", i, prio);
-char thread_name[20];
+sc_thread_create(prio, listener_program, (cyg_addrword_t) i,
-sprintf(thread_name, "listener-%02d", i);
+name, (void *) listener_stack[i], STACK_SIZE,
-prio = N_MAIN + MAX_HANDLERS + i;
+&listenerH[i], &listener_thread_s[i]);
-sc_thread_create(prio, listener_program, (cyg_addrword_t) i,
+CYG_ASSERT(0 == priority_in_use[prio], "Priority already in use!");
-thread_name, (void *) listener_stack[i], STACK_SIZE,
+priority_in_use[prio]++;
-&listenerH[i], &listener_thread_s[i]);
+}
-CYG_ASSERT(0 == priority_in_use[prio], "Priority already in use!");
+for (i = 0; i < N_CLIENTS; ++i) {
-priority_in_use[prio]++;
+int prio = P_BASE_CLIENT + i;
-}
+char* name = &thread_name[prio][0];
-for (i = 0; i < N_CLIENTS; ++i) {
+sprintf(name, "client-%02d/%02d", i, prio);
-int prio;
+sc_thread_create(prio, client_program, (cyg_addrword_t) i,
-char thread_name[20];
+name, (void *) client_stack[i], STACK_SIZE,
-sprintf(thread_name, "client-%02d", i);
+&(clientH[i]), &client_thread_s[i]);
-prio = N_MAIN + MAX_HANDLERS + N_LISTENERS + i;
+CYG_ASSERT(0 == priority_in_use[prio], "Priority already in use!");
-sc_thread_create(prio, client_program, (cyg_addrword_t) i,
+priority_in_use[prio]++;
-thread_name, (void *) client_stack[i], STACK_SIZE,
+}
-&(clientH[i]), &client_thread_s[i]);
-CYG_ASSERT(0 == priority_in_use[prio], "Priority already in use!");
+cyg_thread_resume(mainH);
-priority_in_use[prio]++;
+for (i = 0; i < N_CLIENTS; ++i) {
-}
+cyg_thread_resume(clientH[i]);
+}
-cyg_thread_resume(mainH);
+for (i = 0; i < N_LISTENERS; ++i) {
-for (i = 0; i < N_CLIENTS; ++i) {
+cyg_thread_resume(listenerH[i]);
-cyg_thread_resume(clientH[i]);
+}
-}
-for (i = 0; i < N_LISTENERS; ++i) {
+/* set up the alarm which gives periodic wakeups to say "time to
-cyg_thread_resume(listenerH[i]);
+print a report */
-}
+system_clockH = cyg_real_time_clock();
+cyg_clock_to_counter(system_clockH, &counterH);
-/* set up the alarm which gives periodic wakeups to say "time to
-print a report */
+cyg_alarm_create(counterH, report_alarm_func,
-system_clockH = cyg_real_time_clock();
+(cyg_addrword_t) 4000,
-cyg_clock_to_counter(system_clockH, &counterH);
+&report_alarmH, &report_alarm);
+if (cyg_test_is_simulator) {
-cyg_alarm_create(counterH, report_alarm_func,
+time_report_delay = 2;
-(cyg_addrword_t) 4000,
+} else {
-&report_alarmH, &report_alarm);
+time_report_delay = 30;
-if (cyg_test_is_simulator) {
+}
-time_report_delay = 2;
-} else {
+cyg_alarm_initialize(report_alarmH, cyg_current_time()+200,
-time_report_delay = 30;
+time_report_delay*100);
-}
+return 0;
-cyg_alarm_initialize(report_alarmH, cyg_current_time()+200,
-time_report_delay*100);
 }
 /* main_program() -- frees resources and prints status. */
 void main_program(cyg_addrword_t data)
 {
 }
 /* client_program() -- an obnoxious client which makes a lot of requests */
 void client_program(cyg_addrword_t data)
 {
 int delay;
 printf("# Starting client-%d\n", (int) data);
 system_clockH = cyg_real_time_clock();
 cyg_clock_to_counter(system_clockH, &counterH);
 for (;;) {
 delay = (rand() % 20);
 /* now send a request to the server */
 cyg_mutex_lock(&client_request_lock); {
 ++client_makes_request;
 /*        printf("client_makes_request        %d\n", client_makes_request); */
 } cyg_mutex_unlock(&client_request_lock);
 cyg_thread_delay(10+delay);
 /*      cyg_thread_delay(0); */
 }
 }
 /* listener_program() -- listens for a request and spawns a handler to
 take care of the request */
 void listener_program(cyg_addrword_t data)
 }
 } cyg_mutex_unlock(&client_request_lock);
 if (make_request) {
 int prio;
+char* name;
 /* printf("just got a request from a client (count = %d)\n", */
 /*        client_makes_request); */
 handler_slot = get_handler_slot(listenerH[(int) data]);
-prio = N_MAIN+handler_slot;
+prio = P_BASE_HANDLER+handler_slot;
+name = &thread_name[prio][0];
+sprintf(name, "handler-%02d/%02d", handler_slot, prio);
 CYG_ASSERT(0 == priority_in_use[prio], "Priority already in use!");
 priority_in_use[prio]++;
 sc_thread_create(prio, handler_program,
 (cyg_addrword_t) handler_slot,
-"handler", (void *) handler_stack[handler_slot],
+name, (void *) handler_stack[handler_slot],
 STACK_SIZE2, &handlerH[handler_slot],
 &handler_thread_s[handler_slot]);
 cyg_thread_resume(handlerH[handler_slot]);
 ++statistics.handler_invocation_histogram[handler_slot];
 }
 }
 /* handler_program() -- is spawned to handle each incoming request */
 void handler_program(cyg_addrword_t data)
 {
 /* here is where we perform specific stressful tasks */
 perform_stressful_tasks();
 cyg_thread_delay(4 + (int) (0.5*log(1.0 + fabs((rand() % 1000000)))));
 /*    cyg_thread_delay(0); */
 ++statistics.thread_exits;
 {
 // Loop until the handler id and priority can be communicated to
 // the main_program.
 int freed = 0;
 do {
 cyg_mutex_lock(&free_handler_lock); {
 if (-1 == free_handler_id) {
 free_handler_id = data;
-free_handler_pri = N_MAIN+(int) data;
+free_handler_pri = P_BASE_HANDLER+(int) data;
 freed = 1;
 }
 } cyg_mutex_unlock(&free_handler_lock);
 if (!freed)
 cyg_thread_delay(2);
 } while (!freed);
 }
 // Then exit.
 cyg_thread_exit();
 }
 /* look for an available handler thread */
 int get_handler_slot(cyg_handle_t current_threadH)
 {
 /* do things which will stress the system */
 void perform_stressful_tasks()
 {
 #define MAX_MALLOCED_SPACES 100  /* do this many mallocs at most */
 #define MALLOCED_BASE_SIZE 1    /* basic size in bytes */
 char *spaces[MAX_MALLOCED_SPACES];
 unsigned int i;
 cyg_mutex_t tmp_lock;
 cyg_uint8 pool_space[10][100];
 cyg_handle_t mempool_handles[10];
 cyg_mempool_fix mempool_objects[10];
 cyg_mutex_init(&tmp_lock);
 /* here I use malloc, which uses the kernel's variable memory pools.
 note that malloc/free is a bit simple-minded here: it does not
 try to really fragment things, and it does not try to make the
 allocation/deallocation concurrent with other thread execution
 (although I'm about to throw in a yield()) */
 for (i = 0; i < MAX_MALLOCED_SPACES; ++i) {
 ++statistics.malloc_tries;
 /*      spaces[i] = (char *) malloc(((int)(sqrt(i*2.0))+1)*MALLOCED_BASE_SIZE); */
 spaces[i] = (char *) malloc(((int)i*2.0+1)*MALLOCED_BASE_SIZE);
 if (i % (MAX_MALLOCED_SPACES/10) == 0) {
 cyg_thread_yield();
 }
 if (i % (MAX_MALLOCED_SPACES/15) == 0) {
 cyg_thread_delay(i % 5);
 }
 }
 /* now free it all up */
 for (i = 0; i < MAX_MALLOCED_SPACES; ++i) {
 if (spaces[i] != NULL) {
 unsigned int j;
 for (j = 0; j < (i*2+1)*MALLOCED_BASE_SIZE; ++j) {
-	spaces[i][j] = 0xAA;	/* write a bit pattern */
+spaces[i][j] = 0xAA;    /* write a bit pattern */
 }
 free(spaces[i]);
 } else {
 ++statistics.malloc_failures;
 }
 }
 /* now allocate and then free some fixed-size memory pools; for
 now this is simple-minded because it does not have many threads
 sharing the memory pools and racing for memory. */
 for (i = 0; i < 10; ++i) {
 cyg_mempool_fix_create(pool_space[i], 100, (i+1)*3,
 &mempool_handles[i], &mempool_objects[i]);
 }
 for (i = 0; i < 10; ++i) {
 spaces[i] = cyg_mempool_fix_try_alloc(mempool_handles[i]);
 }
 for (i = 0; i < 10; ++i) {
 if (spaces[i]) {
 cyg_mempool_fix_delete(mempool_handles[i]);
 }
 }
 cyg_mutex_destroy(&tmp_lock);
 }
 /* report_alarm_func() is invoked as an alarm handler, so it should be
 quick and simple.  in this case it sets a global flag which is
 checked by main_program. */
 /* this sets up death alarms. it gets the handle and alarm from the
 caller, since they must persist for the life of the alarm */
 void setup_death_alarm(cyg_addrword_t data, cyg_handle_t *deathHp,
 cyg_alarm *death_alarm_p, int *killed_p)
 {
 cyg_handle_t system_clockH, counterH;
 cyg_resolution_t rtc_res;
 system_clockH = cyg_real_time_clock();
 cyg_clock_to_counter(system_clockH, &counterH);
 cyg_alarm_create(counterH, death_alarm_func,
 (cyg_addrword_t) killed_p,
 deathHp, death_alarm_p);
 rtc_res = cyg_clock_get_resolution(system_clockH);
 {
 cyg_tick_count_t tick_delay;
 tick_delay = (long long)
 ((1000000000.0*rtc_res.divisor)
 *((double)DEATH_TIME_LIMIT)/((double)rtc_res.dividend));
 if ( cyg_test_is_simulator )
 tick_delay /= 10;
 #ifdef CYGPKG_HAL_I386_LINUX
 // 20 seconds is a long time compared to the run time of other tests.
 // Reduce to 10 seconds, allowing more tests to get run.
 tick_delay /= 2;
 #endif
 cyg_alarm_initialize(*deathHp, cyg_current_time() + tick_delay, 0);
 }
 }
 #endif
 /* death_alarm_func() is the alarm handler that kills the current
 thread after a specified timeout. It does so by setting a flag the
 thread is constantly checking. */
 void death_alarm_func(cyg_handle_t alarmH, cyg_addrword_t data)
 {
 int *killed_p;
 killed_p = (int *) data;
 *killed_p = 1;
 }
 /* now I write the sc_ versions of the cyg_functions */
 void sc_thread_create(
 cyg_addrword_t      sched_info,            /* scheduling info (eg pri)  */
 char                *name,                 /* optional thread name      */
 void                *stack_base,           /* stack base, NULL = alloc  */
 cyg_ucount32        stack_size,            /* stack size, 0 = default   */
 cyg_handle_t        *handle,               /* returned thread handle    */
 cyg_thread          *thread                /* put thread here           */
 )
 {
 /*printf("Creating a thread -- priority is %lu\n", (unsigned long) sched_info);*/
 /*    fflush(stdout); */
 ++statistics.thread_creations;
 cyg_thread_create(sched_info, entry, entry_data, name,
 stack_base, stack_size, handle, thread);
+CYG_ASSERT(cyg_thread_get_priority(*handle) == (cyg_priority_t) sched_info,
+"Didn't get requested priority!");
 }
 void print_statistics(int print_full)
 {
 int i;
 static int print_count = 0;
 printf("State dump %d (time %02d.%02d.%02d)\n",
 print_count,
 print_count*time_report_delay / (60*60),   // hours
 (print_count*time_report_delay / 60) % 60, // minutes
 (print_count*time_report_delay ) % 60); // seconds
 print_count++;
 cyg_mutex_lock(&statistics_print_lock); {
 printf(" Handler-invocations: ");
 for (i = 0; i < MAX_HANDLERS; ++i) {
 printf("%4lu ", statistics.handler_invocation_histogram[i]);
 }
 printf("\n");
 printf(" malloc()-tries/failures: -- %7lu %7lu\n",
 statistics.malloc_tries, statistics.malloc_failures);
 printf(" client_makes_request:       %d\n", client_makes_request);
 } cyg_mutex_unlock(&statistics_print_lock);
 // Add: Also occasionally dump individual threads' stack status.
 if (0 == print_count % 5 || print_full) {
 cyg_test_dump_interrupt_stack_stats( " Status" );
 cyg_test_dump_idlethread_stack_stats( " Status" );
 }
 }
 #else /* (CYGNUM_KERNEL_SCHED_PRIORITIES >=    */
 /* (N_MAIN+N_CLIENTS+N_LISTENERS+MAX_HANDLERS)) */
 #define N_A_MSG "not enough priorities available"
 #endif /* (CYGNUM_KERNEL_SCHED_PRIORITIES >=    */
 /* (N_MAIN+N_CLIENTS+N_LISTENERS+MAX_HANDLERS)) */
 #else /* CYGSEM_LIBC_MALLOC */
 # define N_A_MSG "this test needs malloc"
 #endif /* CYGSEM_LIBC_MALLOC */

Mercurial > ecos-v2_0-branch

comparison packages/kernel/current/tests/stress_threads.c @ 24:306eee292492 ecos-sw-1999-07-16