Subversion Repositories openrisc_2011-10-31

/*
 *
 *  This is a simple real-time applications which contains 3 periodic tasks.
 *
 *  Task A is an independent task.
 *
 *  Task B and C share a data.
 *
 *  Tasks are implemented as POSIX threads.
 *
 *  The share data is protected with a POSIX mutex.
 *
 *  Other POSIX facilities such as timers, condition, .. is also used
 *
 *  The license and distribution terms for this file may be
 *  found in the file LICENSE in this distribution or at
 *  http://www.OARcorp.com/rtems/license.html.
 *
 *  $Id: psxtimer.c,v 1.2 2001-09-27 12:02:26 chris Exp $
 */
 
#define CONFIGURE_INIT
#include "system.h"
#include <pthread.h>  /* thread facilities */
#include <signal.h>   /* signal facilities */
#include <unistd.h>   /* sleep facilities */
#include <sched.h>    /* schedule facilities */
#include <time.h>     /* time facilities */
#include <stdio.h>    /* console facilities */
 
 
 
/* temporal parameters of a task */
 
struct periodic_params {
   struct timespec period;
   int signo;       /* signal number */
   int id;          /* task identification */
 };   
 
pthread_attr_t attr;
 
/* shared datum */
 
struct shared_data {
   pthread_mutex_t mutex;
   pthread_cond_t  sync;
   int updated;
   int x;
 };
 
struct shared_data data;
 
/* task A  */
 
void * task_a (void *arg)
{
   struct   timespec my_period;
   int      my_sig, received_sig;
   struct   itimerspec timerdata;
   timer_t  timer_id;
   time_t   clock;
   struct   sigevent event;
   sigset_t set;
 
   my_period = ((struct periodic_params*) arg)->period;
   my_sig    = ((struct periodic_params*) arg)->signo;
 
   /* timer create */
   event.sigev_notify = SIGEV_SIGNAL;
   event.sigev_signo = my_sig;
   if (timer_create (CLOCK_REALTIME, &event, &timer_id) == -1) {
      perror ("Error in timer creation\n");
      pthread_exit ((void *) -1);
    }
 
   /* block the timer signal */
   sigemptyset (&set);
   sigaddset (&set,my_sig);
   pthread_sigmask(SIG_BLOCK,&set,NULL);
 
   /* set the timer in periodic mode */
   timerdata.it_interval = my_period;
   timerdata.it_value    = my_period;
   if (timer_settime(timer_id, 0, &timerdata, NULL) == -1) {
     perror ("Error in timer setting\n");
     pthread_exit ((void *) -1);
   }
 
   /* periodic activity */
   while(1) {
     if (sigwait(&set,&received_sig) == -1) {
       perror ("Error in sigwait\n");
     }
     clock = time(NULL);
     printf("Executing task A %s", ctime(&clock));
   }
 }
 
/* task B  */
 
void * task_b (void *arg)
{
   struct   timespec my_period;
   int      my_sig, received_sig;
   struct   itimerspec timerdata;
   timer_t  timer_id;
   time_t   clock;
   struct   sigevent event;
   sigset_t set;
 
   int x;   /* value to be copied to the shared datum */
 
   my_period = ((struct periodic_params*) arg)->period;
   my_sig    = ((struct periodic_params*) arg)->signo;
 
   x = 1;
 
   /* timer create */
   event.sigev_notify = SIGEV_SIGNAL;
   event.sigev_signo = my_sig;
   if (timer_create (CLOCK_REALTIME, &event, &timer_id) == -1) {
      perror ("Error in timer creation\n");
      pthread_exit ((void *) -1);
    }
 
   /* block the timer signal */
   sigemptyset (&set);
   sigaddset (&set,my_sig);
   pthread_sigmask(SIG_BLOCK,&set,NULL);
 
   /* set the timer in periodic mode */
   timerdata.it_interval = my_period;
   timerdata.it_value    = my_period;
   if (timer_settime(timer_id, 0, &timerdata, NULL) == -1) {
     perror ("Error in timer setting\n");
     pthread_exit ((void *) -1);
   }
 
   /* periodic activity */
   while(1) {
     if (sigwait(&set,&received_sig) == -1) {
       perror ("Error in sigwait\n");
       pthread_exit ((void *) -1);
     }
     pthread_mutex_lock (&data.mutex);
     clock = time(NULL);
     printf("Executing task B with x = %i %s", x, ctime(&clock));
     data.x = x;
     data.updated = TRUE;
     pthread_cond_signal  (&data.sync);
     pthread_mutex_unlock (&data.mutex);
     x++;
   }
}
 
/* task C */
 
void * task_c (void *arg)
{
   struct   timespec my_period;
   int      my_sig, received_sig;
   struct   itimerspec timerdata;
   timer_t  timer_id;
   time_t   clock;
   struct   sigevent event;
   sigset_t set;
 
   int x;   /* value to be copied to the shared datum */
 
   my_period = ((struct periodic_params*) arg)->period;
   my_sig    = ((struct periodic_params*) arg)->signo;
 
   x = 0;
 
   /* timer create */
   event.sigev_notify = SIGEV_SIGNAL;
   event.sigev_signo = my_sig;
   if (timer_create (CLOCK_REALTIME, &event, &timer_id) == -1) {
      perror ("Error in timer creation\n");
      pthread_exit ((void *) -1);
    }
 
   /* block the timer signal */
   sigemptyset (&set);
   sigaddset (&set,my_sig);
   pthread_sigmask(SIG_BLOCK,&set,NULL);
 
   /* set the timer in periodic mode */
   timerdata.it_interval = my_period;
   timerdata.it_value    = my_period;
   if (timer_settime(timer_id, 0, &timerdata, NULL) == -1) {
     perror ("Error in timer setting\n");
     pthread_exit ((void *) -1);
   }
 
   /* periodic activity */
   while(1) {
      if (sigwait(&set,&received_sig) == -1) {
       perror ("Error in sigwait\n");
       pthread_exit ((void *) -1);
     } 
     pthread_mutex_lock (&data.mutex);
     while (data.updated == FALSE) {
       pthread_cond_wait (&data.sync,&data.mutex);
     }
     x = data.x;
     clock = time(NULL);
     printf("Executing task C with x = %i %s", x, ctime(&clock));
     pthread_mutex_unlock (&data.mutex);
   }
 }
 
 
/* main */
 
void *POSIX_Init (
  void *argument
)
 
{
   pthread_mutexattr_t mutexattr;    /* mutex attributes */
   pthread_condattr_t  condattr;     /* condition attributes */
   pthread_attr_t attr;              /* task attributes */
   pthread_t ta,tb,tc;               /* threads */
   sigset_t  set;                    /* signals */
 
   struct sched_param sch_param;     /* schedule parameters */
   struct periodic_params params_a, params_b, params_c;
 
   puts( "\n\n*** POSIX Timers Test ***" );
 
   data.updated = FALSE;
   data.x = 0;
 
   /* mask signal */
   sigemptyset (&set);
   sigaddset (&set,SIGALRM);
   pthread_sigmask (SIG_BLOCK,&set,NULL);
 
   /* set mutex attributes */
   if (pthread_mutexattr_init (&mutexattr) != 0) {
     perror ("Error in mutex attribute init\n");
   }
 
   /* init mutex */
   if (pthread_mutex_init (&data.mutex,&mutexattr) != 0) {
     perror ("Error in mutex init");
   }
 
    /* init condition attributes */
   if (pthread_condattr_init (&condattr) != 0) {
     perror ("Error in condition attribute init\n");
   }
 
   /* init condition */
   if (pthread_cond_init (&data.sync,&condattr) != 0) {
     perror ("Error in condition init");
   }
 
   /* init task attributes */
   if (pthread_attr_init(&attr) != 0) {
     perror ("Error in attribute init\n");
   }
 
   /* set explicit schedule for every task */
   if (pthread_attr_setinheritsched (&attr,
     PTHREAD_EXPLICIT_SCHED) != 0) {
      perror("Error in attribute inheritsched\n");
   }
 
   /* set task independent (join will not use) */
   if (pthread_attr_setdetachstate (&attr,
     PTHREAD_CREATE_DETACHED) != 0) {
      perror ("Error in attribute detachstate\n");
   }
 
   /* schedule policy POSIX_FIFO (priority preemtive and FIFO within the same
      priority) */
   if (pthread_attr_setschedpolicy (&attr,
     SCHED_FIFO) != 0) {
      perror ("Error in attribute setschedpolicy\n"); 
    }
 
   /* set and create thread A with priority 1 */
 
   sch_param.sched_priority = 1;
   if (pthread_attr_setschedparam(&attr, &sch_param) != 0) {
      perror ("Error in attribute schedparam\n");
    }
 
   /* Temporal parameters (1 sec. periodicity) */
 
   params_a.period.tv_sec  = 1;         /* seconds */
   params_a.period.tv_nsec = 000000000; /* nanoseconds */
   params_a.signo = SIGALRM;
   if (pthread_create (&ta, &attr, task_a, &params_a) != 0 ) {
     perror ("Error in thread create for task a\n");
   }
 
   /* set and create thread B with priority 15 */
 
   sch_param.sched_priority = 15;
   if (pthread_attr_setschedparam(&attr, &sch_param) != 0) {
      perror ("Error in attribute schedparam");
    }
 
   /* Temporal parameters (2 sec. periodicity) */
   params_b.period.tv_sec  = 2;         /* seconds */
   params_b.period.tv_nsec = 000000000; /* nanoseconds */
   params_b.signo = SIGALRM;
   if (pthread_create (&tb, &attr, task_b, &params_b) != 0) {
     perror ("Error in thread create for task b\n");
   }
 
   /* set and create thread B with priority 14 */
 
   sch_param.sched_priority = 14;
   if (pthread_attr_setschedparam(&attr, &sch_param) != 0 ) {
      perror ("Error in attribute schedparam\n");
    }
 
   /* Temporal parameters (3 sec. periodicity) */
   params_c.period.tv_sec  = 3;         /* seconds */
   params_c.period.tv_nsec = 000000000; /* nanoseconds */
   params_c.signo = SIGALRM;
   if (pthread_create (&tc, &attr, task_c, &params_c) != 0) {
     perror ("Error in trhead create for task c\n");
   }
 
 
   /* execute 20 seconds and finish */
   sleep (20);
   puts( "\n\n*** End of POSIX Timers Test ***" );
   exit (0);
 }