src_rtlinux/test_fosa.c

   1 #include "fosa_threads_and_signals.h"
   2 #include "fosa_clocks_and_timers.h"
   3 #include "fosa_mutexes_and_condvars.h"
   4 #include "fosa_app_def_sched.h"
   5 #include <rtl.h>
   6 //#include <unistd.h>
   7 //#include <stdio.h>
   8 //#include <time.h> // for nanosleep
   9
  10
  11 #define printf rtl_printf
  12 void * thread_code(void *arg) {
  13     struct timespec req={.tv_sec=1, .tv_nsec=0};
  14     printf("Thread executing\n");
  15     nanosleep(&req, 0);
  16     printf("Thread terminating\n");
  17     return NULL;
  18 }
  19
  20 /////////////////////////////////////////////////////////////
  21 // Simple test program for FOSA
  22 //
  23 // It just checks that the different functions can be called
  24 // and that they return appropriate values
  25 /////////////////////////////////////////////////////////////
  26
  27 void *main_app(void *args) {
  28   //////////////////////////////////
  29   //  Test clock functions
  30   //////////////////////////////////
  31
  32   printf("--------------------------------------------------\n");
  33   printf("test get_time\n");
  34
  35   struct timespec current_time;
  36   int err;
  37   void * obtained;
  38   fosa_clock_id_t cpu_clock;
  39
  40   err=fosa_clock_get_time(FOSA_CLOCK_REALTIME, &current_time);
  41   printf("fosa_clock_get_time for CLOCK_REALTIME sec=%d nsec=%d err=%d\n",
  42          current_time.tv_sec, current_time.tv_nsec,err);
  43
  44   fosa_thread_get_cputime_clock(fosa_thread_self(), &cpu_clock);
  45   err=fosa_clock_get_time(cpu_clock, &current_time);
  46   printf("fosa_clock_get_time for CPU-time clock sec=%d nsec=%d err=%d\n",
  47          current_time.tv_sec, current_time.tv_nsec,err);
  48
  49
  50   /////////////////////////////////////////////
  51   //  Test thread ids, attributes and creation
  52   ////////////////////////////////////////////
  53
  54
  55   printf("--------------------------------------------------\n");
  56   printf("test thread ids and thread creation\n");
  57
  58   int stsize, prio;
  59   struct timespec req={.tv_sec=2, .tv_nsec=0};
  60   frsh_thread_id_t tid1=fosa_thread_self();
  61   frsh_thread_id_t tid2=fosa_thread_self();
  62   printf("equal thread comparison=%d\n",fosa_thread_equal(tid1,tid2));
  63
  64   frsh_thread_attr_t th_attr;
  65
  66   err=frsh_thread_attr_init(&th_attr);
  67   printf("thread attributes object initialized, err=%d\n",err);
  68
  69   err=frsh_thread_attr_set_stacksize(&th_attr,40000);
  70   printf("thread attr set stack size to 40000, err=%d\n",err);
  71
  72   err=frsh_thread_attr_get_stacksize(&th_attr,&stsize);
  73   printf("thread attr get stack size=%d, err=%d\n",stsize,err);
  74
  75   err=fosa_thread_attr_set_prio(&th_attr,27);
  76   printf("thread attr set prio to 27, err=%d\n",err);
  77
  78   err=fosa_thread_attr_get_prio(&th_attr,&prio);
  79   printf("thread attr get prio=%d, err=%d\n",prio,err);
  80
  81   err=fosa_thread_create (&tid2, &th_attr, thread_code, NULL);
  82   printf("creating thread with default attributes err=%d\n",err);
  83
  84   nanosleep(&req,0);
  85
  86   err=frsh_thread_attr_destroy(&th_attr);
  87   printf("thread attributes object destroyed, err=%d\n",err);
  88
  89   //////////////////////////////////
  90   //  Test signals
  91   //////////////////////////////////
  92
  93   printf("--------------------------------------------------\n");
  94   printf("test signals\n");
  95
  96   frsh_signal_t received;
  97   frsh_signal_info_t sigvalue,  value_received;
  98   struct timespec timeout;
  99   frsh_signal_t sig=FOSA_SIGNAL_MIN+1;
 100   frsh_signal_t timer_sig=FOSA_SIGNAL_MIN+3;
 101   frsh_signal_t siglist[2];
 102
 103   siglist[0]=sig;
 104   siglist[1]=timer_sig;
 105
 106   timeout.tv_sec=1;
 107   timeout.tv_nsec=0;
 108
 109   sigvalue.sival_int=55;
 110
 111   err=fosa_set_accepted_signals(siglist,2);
 112   printf("two signals in set of accepted signals, err=%d\n",err);
 113
 114   err=fosa_signal_timedwait(siglist,1,&received,&value_received,&timeout);
 115   printf("timed wait not implemented; timeoutcode=%d\n",err);
 116
 117   err=fosa_signal_queue(sig, sigvalue,fosa_thread_self());
 118   printf("signal queued with value 55, err=%d\n",err);
 119
 120   err=fosa_signal_wait(siglist,1,&received, &value_received);
 121   printf("timeoutcode=%d signal received=%d value=%d\n",
 122          err,received,value_received.sival_int);
 123
 124
 125   //////////////////////////////////
 126   //  Test timers and signals
 127   //////////////////////////////////
 128
 129   printf("--------------------------------------------------\n");
 130   printf("test timers and signals\n");
 131
 132   frsh_signal_info_t timer_info;
 133   fosa_timer_id_t timerid;
 134   struct timespec timerval, remaining_time;
 135
 136   timer_info.sival_int=88;
 137   timerval.tv_sec=1;
 138   timerval.tv_nsec=300000000;
 139
 140
 141   err=fosa_timer_create
 142     (FOSA_CLOCK_REALTIME, timer_sig, timer_info,&timerid);
 143   printf("timer created, err=%d\n",err);
 144
 145   err=fosa_timer_arm(timerid,false,&timerval);
 146   printf("timer armed for 1.3 secs, err=%d\n",err);
 147
 148   fosa_clock_get_time(FOSA_CLOCK_REALTIME, &current_time);
 149   printf("current time sec=%d nsec=%d\n",
 150          current_time.tv_sec, current_time.tv_nsec);
 151   printf("wait for timer to expire...\n");
 152
 153   siglist[0]=timer_sig;
 154   err=fosa_signal_wait(siglist,1,&received, &value_received);
 155   printf("timeoutcode=%d signal received=%d value=%d\n",
 156          err,received,value_received.sival_int);
 157
 158   fosa_clock_get_time(FOSA_CLOCK_REALTIME, &current_time);
 159   printf("current time sec=%d nsec=%d\n",
 160          current_time.tv_sec, current_time.tv_nsec);
 161
 162   timerval.tv_sec=6;
 163   timerval.tv_nsec=0;
 164   err=fosa_timer_arm(timerid,false,&timerval);
 165   printf("timer armed for 6 secs, err=%d\n",err);
 166
 167   timerval.tv_sec=1;
 168   printf("sleeping 1 second\n");
 169   nanosleep(&timerval, NULL);
 170
 171   err=fosa_timer_get_remaining_time(timerid, &remaining_time);
 172   printf("timer remaining time sec=%d nsec=%d, err=%d\n",
 173          remaining_time.tv_sec, remaining_time.tv_nsec, err);
 174
 175   printf("sleeping 1 second\n");
 176   nanosleep(&timerval, NULL);
 177
 178   err=fosa_timer_disarm(timerid,&remaining_time);
 179   printf("timer disarmed, remaining time sec=%d nsec=%d, err=%d\n",
 180          remaining_time.tv_sec, remaining_time.tv_nsec, err);
 181
 182   err=fosa_timer_get_remaining_time(timerid, &remaining_time);
 183   printf("timer remaining time after disarm (0?) sec=%d nsec=%d, err=%d\n",
 184          remaining_time.tv_sec, remaining_time.tv_nsec, err);
 185
 186   fosa_timer_delete(timerid);
 187
 188
 189   //////////////////////////////////
 190   //  Test thread-specific data
 191   //////////////////////////////////
 192
 193   printf("--------------------------------------------------\n");
 194   printf("test thread-specific data\n");
 195
 196   int value=333;
 197   int key;
 198   frsh_thread_id_t tid=fosa_thread_self();
 199
 200   err=fosa_key_create(&key);
 201   printf("key created=%d. err=%d\n",key,err);
 202
 203   fosa_thread_set_specific_data (key, tid, (void *) (&value));
 204   printf("specific data set to 333. err=%d\n",err);
 205
 206   fosa_thread_get_specific_data (key, tid, &obtained);
 207   printf("obtained thread specific data=%d\n",*((int *)obtained));
 208
 209
 210   //////////////////////////////////
 211   //  Test Priorities
 212   //////////////////////////////////
 213
 214   printf("--------------------------------------------------\n");
 215   printf("test priorities\n");
 216
 217
 218   err=fosa_thread_set_prio(fosa_thread_self(),14);
 219   printf("priority set to 14. err=%d\n",err);
 220
 221   err=fosa_thread_get_prio(fosa_thread_self(),&prio);
 222   printf("prio=%d. err=%d\n",prio,err);
 223
 224
 225   //////////////////////////////////
 226   //  Test Mutexes
 227   //////////////////////////////////
 228
 229   printf("--------------------------------------------------\n");
 230   printf("test mutexes\n");
 231
 232   frsh_mutex_t lock;
 233   int old;
 234
 235   err=fosa_mutex_init(&lock,24);
 236   printf("mutex initialized with ceiling 24. err=%d\n",err);
 237
 238   err=fosa_mutex_set_prioceiling(&lock,24,&old);
 239   printf("mutex priority ceiling changed to 24. old=%d. err=%d\n",old,err);
 240
 241   err=fosa_mutex_get_prioceiling(&lock,&old);
 242   printf("mutex priority ceiling is=%d. err=%d\n",old,err);
 243
 244   err=fosa_mutex_lock(&lock);
 245   printf("mutex locked. err=%d\n",err);
 246
 247   err=fosa_mutex_unlock(&lock);
 248   printf("mutex unlocked. err=%d\n",err);
 249
 250   err=fosa_mutex_trylock(&lock);
 251   printf("mutex try locked. err=%d\n",err);
 252
 253   err=fosa_mutex_unlock(&lock);
 254   printf("mutex unlocked. err=%d\n",err);
 255
 256   //////////////////////////////////
 257   //  Test Condition variables
 258   //////////////////////////////////
 259
 260   printf("--------------------------------------------------\n");
 261   printf("test condition variables\n");
 262
 263   fosa_cond_t cond;
 264
 265   err=fosa_cond_init(&cond);
 266   printf("condvar initialized. err=%d\n",err);
 267
 268   err=fosa_cond_signal(&cond);
 269   printf("cond signalled. err=%d\n",err);
 270
 271   err=fosa_cond_broadcast(&cond);
 272   printf("cond broadcast. err=%d\n",err);
 273
 274   fosa_clock_get_time(FOSA_CLOCK_REALTIME, &current_time);
 275   printf("current time sec=%d nsec=%d\n",
 276          current_time.tv_sec, current_time.tv_nsec);
 277
 278   current_time.tv_sec=current_time.tv_sec+2;
 279
 280   fosa_mutex_lock(&lock);
 281   err=fosa_cond_timedwait(&cond,&lock,&current_time);
 282   fosa_mutex_unlock(&lock);
 283   printf("cond timedwait with timeout=2 sec. err=%d\n",err);
 284
 285   fosa_clock_get_time(FOSA_CLOCK_REALTIME, &current_time);
 286   printf("current time sec=%d nsec=%d\n",
 287          current_time.tv_sec, current_time.tv_nsec);
 288
 289   err=fosa_mutex_destroy(&lock);
 290   printf("mutex destroyed. err=%d\n",err);
 291
 292   err=fosa_cond_destroy(&cond);
 293   printf("cond destroyed. err=%d\n",err);
 294
 295   ////////////////////////////////////////
 296   //  Test Application-defined scheduling
 297   ///////////////////////////////////////
 298   /*
 299   printf("--------------------------------------------------\n");
 300   printf("test application-defined scheduling\n");
 301
 302   frsh_thread_attr_t th1_attr;
 303   bool is_appsched;
 304
 305   err=frsh_thread_attr_init(&th1_attr);
 306   printf("thread attributes object initialized, err=%d\n",err);
 307
 308   err=fosa_thread_attr_set_appscheduled(&th1_attr,true);
 309   printf("thread attr set appsched, err=%d\n",err);
 310
 311   err=fosa_thread_attr_get_appscheduled(&th1_attr,&is_appsched);
 312   printf("thread attr get appsched=%d, err=%d\n",is_appsched,err);
 313   */
 314   return 0;
 315
 316 }
 317
 318 static pthread_t main_thread;
 319
 320 int init_module (void) {
 321     return pthread_create(&main_thread, 0, main_app, 0);
 322 }
 323
 324 void cleanup_module(void) {
 325   pthread_delete_np(main_thread);
 326 }