sched.c

fsmlabs的real time linux的内核

/*
 * POSIX.1 Signals test program
 *
 * Written by J. Vidal
 * Copyright (C) Dec, 2002 OCERA Consortium.
 *
 * This program 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.
 *
 * Test program implementing a trivial Round Robin scheduler with 
 * user signals.
 *
 */

#include <rtl.h>
#include <rtl_sched.h>

#define MAX_TASKS 7
#define NTASKS 4
#define SCHED_SIGNAL RTL_SIGUSR1
#define WAKEUP_SIGNAL RTL_SIGUSR2
#define SUSPEND_SIGNAL (WAKEUP_SIGNAL+MAX_TASKS)
#define DELETE_SIGNAL (SUSPEND_SIGNAL+MAX_TASKS)


pthread_t thread[MAX_TASKS];
#define kill(th,sig) pthread_kill(thread[th],sig+th)

static void sched_hdl(int sig){
  static int rr_current=0;
  
  rtl_printf("\n\n\nSignal handler called for signal :%d, ROUND ROBING SCHEDULING.\n",sig);
  rtl_printf("Current :%d\n\n\n",rr_current % NTASKS); 
  if (++rr_current % NTASKS)   kill(rr_current % NTASKS,WAKEUP_SIGNAL);
  if (rr_current % NTASKS)   kill(rr_current % NTASKS,SUSPEND_SIGNAL);
}

static void wakeup_hdl(int sig){
  rtl_printf("Signal handler called for signal :%d, waking up thread\n",sig);
  pthread_wakeup_np(pthread_self());
}

static void suspend_hdl(int sig){
  rtl_printf("Signal handler called for signal :%d, suspending thread\n",sig);
  pthread_suspend_np(pthread_self());
}

static void delete_hdl(int sig){
  rtl_printf("Signal handler called for signal :%d, removing thread\n",sig);
  pthread_exit(NULL);
}

static void do_work(int who){
  static int i=0;
  int j,k,m=0;

  rtl_printf("Hi, I am thread %d, just wasting time iter:%d\n",who,i++);
      for (j=0;j<10;j++)
	for (k=0;k<10;k++)
	  m+=i-j+k;

}

void * start_routine(void *arg)
{	int i=0,err=0,param;
	struct sched_param p;
	struct sigaction sa_wakeup,sa_suspend,sa_delete,sa_sched;
	rtl_sigset_t mask;
	
	param=(unsigned) arg;
	
	if (param)
	  p . sched_priority = param;
	else
	  p . sched_priority = MAX_TASKS;

	pthread_setschedparam (pthread_self(), SCHED_FIFO, &p);

	if (param) {
	  
	  sa_wakeup.sa_handler=wakeup_hdl;
	  sa_suspend.sa_handler=suspend_hdl;
	  sa_delete.sa_handler=delete_hdl;
	  
	  if ((err=sigaction(WAKEUP_SIGNAL+param,&sa_wakeup,NULL))<0 )
	  rtl_printf("sigaction(%d,&sa_wakeup,NULL) FAILING, errno:%d.\n",WAKEUP_SIGNAL,errno);
	  
	  if ((err=sigaction(SUSPEND_SIGNAL+param,&sa_suspend,NULL))<0 )
	    rtl_printf("sigaction(%d,&sa_suspend,NULL) FAILING, errno:%d.\n",SUSPEND_SIGNAL,errno);
	  
	  if ((err=sigaction(DELETE_SIGNAL+param,&sa_delete,NULL))<0 )
	  rtl_printf("sigaction(%d,&sa_delete,NULL) FAILING, errno:%d.\n",DELETE_SIGNAL,errno);

	  rtl_sigfillset(&mask);
	  pthread_sigmask(SIG_SETMASK,&mask,NULL);
	  rtl_sigemptyset(&mask);

	  rtl_sigaddset(&mask,WAKEUP_SIGNAL);
	  rtl_sigaddset(&mask,SUSPEND_SIGNAL);
	  rtl_sigaddset(&mask,DELETE_SIGNAL);
	  
	  while(1){
	    sigsuspend(&mask);
	    do_work(param);
	  }

	} else {
	  sa_sched.sa_handler=sched_hdl;
	  if ((err=sigaction(SCHED_SIGNAL,&sa_sched,NULL))<0 )
	    rtl_printf("sigaction(%d,&sa,NULL) FAILING, errno:%d.\n",SCHED_SIGNAL,errno);

	  pthread_make_periodic_np (pthread_self(), gethrtime(), (long long)500*1000*1000);
	}

	rtl_sigfillset(&mask);
	rtl_sigdelset(&mask,SCHED_SIGNAL);
	pthread_sigmask(SIG_SETMASK,&mask,NULL);

	while (i++<=100) {
	  pthread_wait_np ();
	  pthread_kill(pthread_self(),SCHED_SIGNAL);
	  i++;
	}
	
	//Remove all scheduled threads.
	for (i=0;i<NTASKS;i++)
	  kill(i,DELETE_SIGNAL);
	
	return 0;
}

int init_module(void) {
  int i,err=0;
  for (i=0;i<NTASKS;i++)
    err=pthread_create (&thread[i], NULL, start_routine,(void *) i);
  return err;
}

void cleanup_module(void) {
  int i;
  for (i=0;i<NTASKS;i++)
    pthread_delete_np (thread[i]);
}