rr_sched.c

最新rtlinux内核源码

/*
 * 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]);
}