Subversion Repositories shark

/*

 * Project: S.Ha.R.K.

 *

 * Coordinators:

 *   Giorgio Buttazzo    <giorgio@sssup.it>

 *   Paolo Gai           <pj@gandalf.sssup.it>

 *

 * Authors     :

 *   Giacomo Guidi       <giacomo@gandalf.sssup.it>

 *   Anton Cervin

 *

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

 *

 * http://www.sssup.it

 * http://retis.sssup.it

 * http://shark.sssup.it

 */

/*

 * 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 "time.h"

#include "elastic/elastic/elastic.h"

#include <drivers/shark_keyb26.h>

#define MAX_TASKS 7

/* A task that scrolls a number (the task number) across the screen */

TASK elastic_test(void *arg) {

  int y = (int)arg;

  int x = 0;  

  char str[2];

  str[0] = '0' + y + 1;

  str[1] = '\0';

  while(1) {

    puts_xy(x,y,LIGHTGRAY," ");

    x = (x + 1) % 80;

    puts_xy(x,y,LIGHTGRAY,str);

    task_testcancel();

    task_endcycle();

  }

}

/* A simple keyboard string input routine */

void myinput(char *query, char *buf, int len) {

  BYTE c;

  int n = 0;

  cprintf(query);

  do {

    c = keyb_getch(NON_BLOCK);

    if (c == '\r') break;

    if (c == '\b') {

      if (n > 0) {

        cprintf("%c", '\b');

        n--;

      }

    } else if ((c >= '0' && c <= '9') || (c >= 'a' && c <= 'z')) {

      cprintf("%c", c);

      buf[n++] = c;

    }

  } while (n < len);

  buf[n] = '\0';

  cprintf("\n");

}

/* The main program */

int main(int argc, char **argv)

{

  ELASTIC_TASK_MODEL e;

  PID el_pid;

  PID pidvec[MAX_TASKS];

  int quit = 0;

  char buf[80];

  int y;

  int Tmin, Tmax, C, E, T, nbr, i;

  double U, Umax;

  for (i=0; i<MAX_TASKS; i++) pidvec[i] = NIL;

  clear();

  /* Create predefined task 1 */

  elastic_task_default_model(e);

  elastic_task_def_period(e, 50000, 200000);

  elastic_task_def_wcet(e, 25000);

  elastic_task_def_param(e, 5, PERIOD_SCALING);

  elastic_task_def_arg(e, (void *)0);

  el_pid = task_create("Elastic",elastic_test,&e,NULL);

  if (el_pid == NIL) {

    cprintf("ELASTIC_public_create failed!\n");

  } else {

    pidvec[0] = el_pid;

    task_activate(el_pid);

  }

  /* Create predefined task 2 */

  elastic_task_default_model(e);

  elastic_task_def_period(e, 100000, 150000);

  elastic_task_def_wcet(e, 40000);

  elastic_task_def_param(e, 10, PERIOD_SCALING);

  elastic_task_def_arg(e, (void *)1);

  el_pid = task_create("Elastic",elastic_test,&e,NULL);

  if (el_pid == NIL) {

    cprintf("ELASTIC_public_create failed!\n");

  } else {

    pidvec[1] = el_pid;

    task_activate(el_pid);

  }

  do {

    /* Print task table */

    for (y = 7; y <=15; y++) {

      puts_xy(0,y,LIGHTGRAY,"                                                                                ");

    }

    place(0,7);

    U = 0.0;

    Umax = 0.0;

    cprintf("Nbr  Tmin  Tmax    C     E     T  \n");

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

      if (pidvec[i] != NIL) {

        Tmin = ELASTIC_get_Tmin(pidvec[i]);

        Tmax = ELASTIC_get_Tmax(pidvec[i]);

        C = ELASTIC_get_C(pidvec[i]);

        E = ELASTIC_get_E(pidvec[i]);

        T = ELASTIC_get_period(pidvec[i]);

        U += (double)C/(double)T;

        Umax += (double)C/(double)Tmin;

        cprintf(" %1d   %4d  %4d  %4d  %4d  %4d\n", i+1, Tmin/1000, Tmax/1000, C/1000, E, T/1000);

      }

    }

    cprintf("Maximum utilization: %5.3f   Actual utilization: %5.3f\n", Umax, U);

    puts_xy(0,16,LIGHTGRAY,"                                                                                ");

    place(0,16);

    myinput("(q)uit, (c)reate, (k)ill, force (p)eriod, change (e)lasticity? ", buf, 10);

    for (y = 17; y <=24; y++) {

      puts_xy(0,y,LIGHTGRAY,"                                                                                ");

    }

    switch (buf[0]) {

      /* Quit */

    case 'q':

      quit = 1;

      break;

      /* Create task */

    case 'c':

      cprintf("Create task");

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

        if (pidvec[i] == NIL) break;

      }

      if (i == MAX_TASKS) {

        cprintf("\nNo more task slots available!\n");

        break;

      } else {

        cprintf(" %d\n", i+1);

      }

      myinput("Tmin (ms): ", buf, 10);

      Tmin = 1000*atoi(buf);

      myinput("Tmax (ms): ", buf, 10);

      Tmax = 1000*atoi(buf);

      myinput("C (ms): ", buf, 10);

      C = 1000*atoi(buf);

      myinput("E: ", buf, 10);

      E = atoi(buf);

      elastic_task_default_model(e);

      elastic_task_def_period(e, Tmin, Tmax);

      elastic_task_def_wcet(e, C);

      elastic_task_def_param(e, E, PERIOD_SCALING);

      elastic_task_def_arg(e, (void *)i);

      el_pid = task_create("Elastic",elastic_test,&e,NULL);

      if (el_pid == NIL) {

        cprintf("ELASTIC_public_create failed!\n");

      } else {

        pidvec[i] = el_pid;

        task_activate(el_pid);

      }

      break;

      /* Force period */

    case 'p':

      myinput("Force period\nTask nbr: ", buf, 10);

      nbr = atoi(buf);

      if (nbr < 1 || nbr > MAX_TASKS) {

        cprintf("Invalid task number!\n");

        break;

      }

      el_pid = pidvec[nbr-1];

      if (el_pid == NIL) {

        cprintf("Task does not exist!\n");

        break;

      }

      myinput("T (ms): ", buf, 10);

      T = 1000*atoi(buf);

      if (ELASTIC_set_period(el_pid, T) == -1) {

        cprintf("ELASTIC_set_period failed!\n");

      }

      break;

      /* Kill task */

    case 'k':

      myinput("Kill task\nTask nbr: ", buf, 10);

      nbr = atoi(buf);

      if (nbr < 1 || nbr > MAX_TASKS) {

        cprintf("Invalid task number!\n");

        break;

      }

      el_pid = pidvec[nbr-1];

      if (el_pid == NIL) {

        cprintf("Task does not exist!\n");

        break;

      }

      task_kill(el_pid);

      pidvec[nbr-1] = NIL;

      usleep(500000);  // wait half a second before redrawing the task table!!!

      /* also erase task number */

      puts_xy(0,nbr-1,LIGHTGRAY,"                                                                                ");

      break;

      /* Set elasticity */

    case 'e':

      myinput("Set elasticity\nTask nbr: ", buf, 10);

      nbr = atoi(buf);

      if (nbr < 1 || nbr > MAX_TASKS) {

        cprintf("Invalid task number!\n");

        break;

      }

      el_pid = pidvec[nbr-1];

      if (el_pid == NIL) {

        cprintf("Task does not exist!\n");

        break;

      }

      myinput("E: ", buf, 10);

      E = atoi(buf);

      if (ELASTIC_set_E(el_pid, E) == -1) {

        cprintf("ELASTIC_set_E failed!\n");

      }

      break;

    default:

      cprintf("Unknown command\n");

      break;

    }

  } while (!quit);

  exit(1);

  return 0;

}