Subversion Repositories shark

/*

 * Project: HARTIK (HA-rd R-eal TI-me K-ernel)

 *

 * Coordinators: Giorgio Buttazzo <giorgio@sssup.it>

 *               Gerardo Lamastra <gerardo@sssup.it>

 *

 * Authors     : Paolo Gai <pj@hartik.sssup.it>

 * (see authors.txt for full list of hartik's authors)

 *

 * ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy)

 *

 * http://www.sssup.it

 * http://retis.sssup.it

 * http://hartik.sssup.it

 */

/**

 ------------

 CVS :        $Id: testg.c,v 1.1.1.1 2002-09-02 09:37:48 pj Exp $

 File:        $File$

 Revision:    $Revision: 1.1.1.1 $

 Last update: $Date: 2002-09-02 09:37:48 $

 ------------

 Test 16 (G):

 This is a part of the cbsmouse.c Hartik's example.

 It only prints the task scheduling in graphic mode...

 There is a parameter to choose the type of scheduling module

 to initialize.

 to init correctly the module and task bandwidth parameters, set the defines

 NUM and DEN in initg.c and testg.c and remember the "s" (soft) parameter!!!

 to plot the deadlines assigned by CBS or TBS, compile cbs.c or tbs.c with

 the TESTG define

 (gray dots over the mouse line are the deadlines, green dots are CBS

  shifts)

**/

/*

 * Copyright (C) 2000 Paolo Gai

 *

 * 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 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 */

#include "kernel/kern.h"

#include "drivers/glib.h"

#include "drivers/keyb.h"

#include "drivers/mouse.h"

/*--------------------------------------------------------------*/

/*                    TEST ON EDF SCHEDULING                    */

/*--------------------------------------------------------------*/

#define LMOUSE          20

#define LM              40              /* line of main         */

#define OFFSET          20              /* initial phase        */

#define CHAR_DIM        8               /* Height of chars in pixels */

int     col[3] = {2, 4, 14};            /* colors of timelines  */

int     lev[3] = {80, 120, 160};        /* level of timelines   */

int     ptime[3] = {10, 20, 25};        /* number of cycles     */

int     period[3] = {40, 50,100};       /* tasks' periods       */

int     tick = 1;                       /* system tick          */

int     tscale = 1;                     /* time scale           */

TIME    starttime = 0;                  /* Simulation start time (scaled) */

char *title;  /* used in initg.c */

/* period[] is scaled with a factor of PERIODSCALE usec */

#define PERIODSCALE 5000

// update also initg.c!!!

#define NUM 200

#define DEN 64000

//SEM     mutex;                                /* Semaphore for graphix*/

//#define IY(y) (480 - y)

#define IY(y)    y

/*

 * mouse cursor

 *

 */

#define W WHITE

#define R RED

#define G GREEN

#define M MAGENTA

/* shape */

BYTE mycursor[16*16]= {

   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

   0,W,W,W,W,0,0,0,0,0,0,W,W,W,W,0,

   0,W,M,0,0,0,0,0,0,0,0,0,0,M,W,0,

   0,W,0,M,0,0,0,0,0,0,0,0,M,0,W,0,

   0,W,0,0,M,0,0,0,0,0,0,M,0,0,W,0,

   0,0,0,0,0,M,0,0,0,0,M,0,0,0,0,0,

   0,0,0,0,0,0,G,G,G,G,0,0,0,0,0,0,

   0,0,0,0,0,0,G,0,0,G,0,0,0,0,0,0,

   0,0,0,0,0,0,G,0,0,G,0,0,0,0,0,0,

   0,0,0,0,0,0,G,0,0,G,0,0,0,0,0,0,

   0,0,0,0,0,0,G,G,G,G,0,0,0,0,0,0,

   0,0,0,0,0,0,M,M,M,M,0,0,0,0,0,0,

   0,0,0,0,0,0,M,M,M,M,0,0,0,0,0,0,

   0,0,0,0,0,M,M,M,M,M,M,0,0,0,0,0,

   0,0,0,0,M,M,M,M,M,M,M,M,0,0,0,0,

   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

};

#define F 0xff

#define B 0x00

/* mask */

BYTE mybkg[16*16]= {

   B,B,B,B,B,B,F,F,F,F,B,B,B,B,B,B,

   B,0,0,0,0,B,F,F,F,F,B,0,0,0,0,B,

   B,0,0,B,B,F,F,F,F,F,B,B,B,0,0,B,

   B,0,B,0,B,F,F,F,F,F,F,B,0,B,0,B,

   B,0,B,B,0,B,F,F,F,F,B,0,B,B,0,B,

   B,B,B,F,B,0,B,B,B,B,0,B,F,B,B,B,

   F,F,F,F,F,B,0,0,0,0,B,F,F,F,F,F,

   F,F,F,F,F,B,0,B,B,0,B,F,F,F,F,F,

   F,F,F,F,F,B,0,B,B,0,B,F,F,F,F,F,

   F,F,F,F,F,B,0,B,B,0,B,F,F,F,F,F,

   F,F,F,F,F,B,0,0,0,0,B,F,F,F,F,F,

   F,F,F,F,F,B,0,0,0,0,B,F,F,F,F,F,

   F,F,F,F,F,B,0,0,0,0,B,F,F,F,F,F,

   F,F,F,F,B,0,0,0,0,0,0,B,F,F,F,F,

   F,F,F,B,0,0,0,0,0,0,0,0,B,F,F,F,

   F,F,F,B,B,B,B,B,B,B,B,B,B,F,F,F,

};

#undef B

#define B 0xff

/* bad mask */

BYTE mybadbkg[16*16]= {

   B,B,B,B,B,B,F,F,F,F,B,B,B,B,B,B,

   B,0,0,0,0,B,F,F,F,F,B,0,0,0,0,B,

   B,0,0,B,B,F,F,F,F,F,B,B,B,0,0,B,

   B,0,B,0,B,F,F,F,F,F,F,B,0,B,0,B,

   B,0,B,B,0,B,F,F,F,F,B,0,B,B,0,B,

   B,B,B,F,B,0,B,B,B,B,0,B,F,B,B,B,

   F,F,F,F,F,B,0,0,0,0,B,F,F,F,F,F,

   F,F,F,F,F,B,0,B,B,0,B,F,F,F,F,F,

   F,F,F,F,F,B,0,B,B,0,B,F,F,F,F,F,

   F,F,F,F,F,B,0,B,B,0,B,F,F,F,F,F,

   F,F,F,F,F,B,0,0,0,0,B,F,F,F,F,F,

   F,F,F,F,F,B,0,0,0,0,B,F,F,F,F,F,

   F,F,F,F,F,B,0,0,0,0,B,F,F,F,F,F,

   F,F,F,F,B,0,0,0,0,0,0,B,F,F,F,F,

   F,F,F,B,0,0,0,0,0,0,0,0,B,F,F,F,

   F,F,F,B,B,B,B,B,B,B,B,B,B,F,F,F,

};

/* very bad mask */

BYTE myverybadbkg[16*16]= {

   F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,

   F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,

   F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,

   F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,

   F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,

   F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,

   F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,

   F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,

   F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,

   F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,

   F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,

   F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,

   F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,

   F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,

   F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,

   F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,

};

/*--------------------------------------------------------------*/

/*      Prints a grid to show task periods during execution     */

/*--------------------------------------------------------------*/

void    print_grid()

{

  int     i;

  int     a1, a2, a3;

  int     temp;

//  char    str[50];

  a1 = 0;

  a2 = 0;

  a3 = 0;

  temp = 0;

  grx_text(title, 0, 240-10 ,10, 0);

  grx_line(OFFSET, lev[0], 639, lev[0], 5);

  grx_line(OFFSET, lev[1], 639, lev[1], 5);

  grx_line(OFFSET, lev[2], 639, lev[2], 5);

  grx_text("T1", 0, lev[0]-8, 9, 0);

  grx_text("T2", 0, lev[1]-8, 9, 0);

  grx_text("T3", 0, lev[2]-8, 9, 0);

  grx_text("MA", 0,     LM, 8, 0);

  grx_text("MO", 0,     LMOUSE, 8, 0);

  for (i = OFFSET; i < 640; i++) {

    if (temp >= a1) {

      grx_line(i, lev[0] - 1, i, lev[0] - 20, 3);

      a1 += period[0];

    }

    if (temp >= a2) {

      grx_line(i, lev[1] - 1, i, lev[1] - 20, 3);

      a2 += period[1];

    }

    if (temp >= a3) {

      grx_line(i, lev[2] - 1, i, lev[2] - 20, 3);

      a3 += period[2];

    }

    temp += tick/tscale;

  }

}

/*--------------------------------------------------------------*/

/*      This function is called at system termination           */

/*--------------------------------------------------------------*/

void    my_end()

{

  grx_close();

//  sys_status(0xFFFF);

//  sys_end();

}

/*--------------------------------------------------------------*/

/*      GENERIC PERIODIC PROCESS                                */

/*--------------------------------------------------------------*/

TASK    color(int k)

{

  int     i;

  DWORD   x = OFFSET;

  TIME  t;

  while ( x < 640L) {

    for (i = 0; i < ptime[k]; i++) {

      t = sys_gettime(NULL) / PERIODSCALE;

      x = (t - starttime) + OFFSET;

      if (x>=640) break;

      //sem_wait(mutex, BLOCK);

      kern_cli();

      grx_plot(x, lev[k] - 4, col[k]);

      grx_plot(x, lev[k] - 5, col[k]);

      grx_plot(x, lev[k] - 6, col[k]);

      grx_plot(x, lev[k] - 7, col[k]);

      //sem_signal(mutex);

      kern_sti();

      while (sys_gettime(NULL)/PERIODSCALE == t);

    }

    task_endcycle();

  }

  return 0;

}

void my_mouse_handler(MOUSE_EVT *ev)

{

  int x;

  x = (sys_gettime(NULL)/PERIODSCALE - starttime) + OFFSET;

  if (x>=640) return;

  //sem_wait(mutex, BLOCK);

  grx_plot(x, LMOUSE, 8);

  //while (sys_ticks()==s);

  //sem_signal(mutex);  

}

/*--------------------------------------------------------------*/

/*      MAIN PROCESS                                            */

/*--------------------------------------------------------------*/

int  main(int argc, char *argv[])

{

  int     i;

  int     x = OFFSET;

  MOUSE_PARMS mouse = BASE_MOUSE;

  HARD_TASK_MODEL mouse_hard;

  SOFT_TASK_MODEL mouse_soft;

  NRT_TASK_MODEL  mouse_nrt;

  char  c;

  KEY_EVT emerg;

  HARD_TASK_MODEL m_per;

  int modenum;

  //sys_def_nocheck(si);

  //sys_def_tick(si, tick, mSec);

  //sys_init(&si);

  //cprintf("Sys GetTick... %lu 100000 / sys_tick: %lu \n", sys_gettick(), 100000 / sys_gettick());

  if (argc>=3)

    switch(*argv[2]) {

      case 'h':

        /* this is not correct, because it don't remember activations */

        hard_task_default_model(mouse_hard);

        hard_task_def_mit(mouse_hard,DEN);

        hard_task_def_wcet(mouse_hard,NUM);

        hard_task_def_system(mouse_hard);

        hard_task_def_aperiodic(mouse_hard);

        mouse_def_task(mouse,(TASK_MODEL *)&mouse_hard);

        break;

      case 's':

        soft_task_default_model(mouse_soft);

        soft_task_def_wcet(mouse_soft,NUM);

        soft_task_def_met(mouse_soft,NUM);

        soft_task_def_period(mouse_soft,DEN);

        soft_task_def_system(mouse_soft);

        soft_task_def_aperiodic(mouse_soft);

        mouse_def_task(mouse,(TASK_MODEL *)&mouse_soft);

        break;

      case 'n':

        /* this is not correct, because it don't remember activations */

        nrt_task_default_model(mouse_nrt);

        nrt_task_def_system(mouse_nrt);

        mouse_def_task(mouse,(TASK_MODEL *)&mouse_nrt);

        break;

      default:

        argc=0;

        break;

    }

  mouse_def_ms(mouse,0);

  if (argc>=4) {

    period[0]=atoi(argv[3]);

    if (period[0]<ptime[0]) period[0]=ptime[0]+5;

  }

  if (argc>=5) {

    period[1]=atoi(argv[4]);

    if (period[1]<ptime[1]) period[1]=ptime[1]+5;

  }

  if (argc>=6) {

    period[2]=atoi(argv[5]);

    if (period[2]<ptime[2]) period[2]=ptime[2]+5;

  }

  if (argc<2) {

    cprintf("syntax: x testg <config> <mouse-task> [t1] [t2] [t3]\n");

    cprintf("where <config> can be:\n");

    cprintf("\t0 - EDF + CBS                + RR\n");

    cprintf("\t1 - RM  + PS (  bkg, U=1/16) + RR, no check Ulub < 0.69\n");

    cprintf("\t2 - RM  + PS (nobkg, U=1/16) + RR, no check Ulub < 0.69\n");

    cprintf("\t3 - EDF + PS (  bkg, U=1/16) + RR\n");

    cprintf("\t4 - EDF + PS (nobkg, U=1/16) + RR\n");

    cprintf("\t5 - EDF + TBS(       U=1/16) + RR\n");

    cprintf("\t6 - RM  + DS (  bkg, U=1/16) + RR, no check Ulub < 0.69\n");

    cprintf("\t7 - RM  + DS (nobkg, U=1/16) + RR, no check Ulub < 0.69\n");

    cprintf("\nwhere <mouse-task> can be:\n");

    cprintf("\th - Hard\n");

    cprintf("\ts - Soft (understimated wcet)\n");

    cprintf("\tn - NRT\n");

    sys_end();

    return -1;

  }

  if (grx_init() == -1) {

    cprintf("Error initing GraphLib!!!\n");

    sys_end();

  }

  modenum = grx_getmode(640, 480, 8);

  cprintf("Modenum :%d\n", modenum);

  if (grx_setmode(modenum) == -1) {

    cprintf("No SetMode!!!\n");

    sys_end();

  }

  /* */

//  grx_close();

  print_grid();

  #define DX (640/5-1)

  grx_box(DX*0,240,DX*1-1,479,GREEN);

  grx_box(DX*1,240,DX*2-1,479,WHITE);

  grx_box(DX*2,240,DX*3-1,479,RED);

  grx_box(DX*3,240,DX*4-1,479,MAGENTA);

  grx_box(DX*4,240,DX*5-1,479,BLACK);

  for (i=0;i<3;i++)  {    

     period[i]=period[i]*PERIODSCALE;

     //ptime[i]=ptime[i]  *PERIODSCALE; ptime is not scaled

  }

  sys_atrunlevel(my_end, NULL, RUNLEVEL_BEFORE_EXIT);

  /* mutex */

//  mutex = sem_create(1);

  /* keyboard */

  emerg.ascii = 'x';

  emerg.scan = KEY_X;

  emerg.flag = ALTL_BIT;

  keyb_hook(emerg,(void (*)(KEY_EVT *))sys_end);

  keyb_getchar();

  /* mouse */

  mouse_init(&mouse);

  mouse_limit(XMINLIMIT(640,480),

              240,

              XMAXLIMIT(640,480),

              YMAXLIMIT(640,480));

  mouse_position(320,280);

  mouse_threshold(2);

  //grx_setcolor(255,255,255,255);

  mouse_grxshape(mycursor,mybkg);

  mouse_grxcursor(ENABLE);

  mouse_on();

  mouse_hook(my_mouse_handler);

  /* hard task creation */

  hard_task_default_model(m_per);

  hard_task_def_mit(m_per,period[0]);

  hard_task_def_wcet(m_per,ptime[0]*PERIODSCALE);

  hard_task_def_group(m_per, 1);

  //task_def_wcet(m, ptime[0] * sys_tick);

  if (task_create("verde", color, &m_per, NULL) == -1) {

    grx_close();

    perror("Edf.C(main) Could not create <green>:");

    sys_end();

    l1_exit(-1);

  }

  hard_task_def_arg(m_per, (void *)1);

  hard_task_def_wcet(m_per, ptime[1]*PERIODSCALE);

  hard_task_def_mit(m_per,period[1]);

  if (task_create("red", color, &m_per, NULL) == -1) {

    grx_close();

    perror("Edf.C(main) Could not create <red>:");

    sys_end();

    l1_exit(-1);

  }

  hard_task_def_arg(m_per, (void *)2);

  hard_task_def_wcet(m_per, ptime[2]*PERIODSCALE);

  hard_task_def_mit(m_per,period[2]);

  if (task_create("yellow", color, &m_per, NULL) == -1) {

    grx_close();

    perror("Edf.C(main) Could not create <yellow>:");

    sys_end();

    l1_exit(-1);

  }

  starttime = sys_gettime(NULL) / PERIODSCALE;

  group_activate(1);

  /* main loop */

  while (x < 640L) {

    x = (sys_gettime(NULL)/PERIODSCALE - starttime) + OFFSET;

    if (x>=640) break;

    //sem_wait(mutex, BLOCK);

    kern_cli();

    grx_plot(x, LM, 7);

    kern_sti(); // sem_signal(mutex);

  }

  c = keyb_getchar();

  return 0;

}

/*--------------------------------------------------------------*/