Subversion Repositories shark

/*

 * Project: S.Ha.R.K.

 *

 * Coordinators:

 *   Giorgio Buttazzo    <giorgio@sssup.it>

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

 *

 * Authors     :

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

 *   (see the web pages for full authors list)

 *

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

 *

 * http://www.sssup.it

 * http://retis.sssup.it

 * http://shark.sssup.it

 */

/**

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

 CVS :        $Id: crunch.c,v 1.1 2004-07-05 14:17:12 pj Exp $

 File:        $File$

 Revision:    $Revision: 1.1 $

 Last update: $Date: 2004-07-05 14:17:12 $

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

**/

/*

 * Copyright (C) 2001 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

 *

 */

/*

 * Crunch.c

 */

//#define DEBUG_CONFFILE

//#define DEBUG_MASTER_HARDCREATE

//#define DEBUG_MASTER_VALUECREATE

#include "valmodel.h"

#include "crunch.h"

#include <kernel/kern.h>

/*

 *  This small application simply reads the tasks and executes them.

 *  When they are all finished, the system shuts down.

 */

/*

 * this table contains all the tasks information collected from the

 * configuration file

 */

#define MAX_PATTERN 100000

struct task_struct pattern[MAX_PATTERN];

int pattern_dim;

/* This is some data collected by the task destructors that

 * can be useful for understanding how the Module works     */

/* this int contains the value as seen by the application */

int current_value = 0;

int max_value = 0;

int min_value = 0;

int max_created_value = 0;

int min_created_value = 0;

/* the number of finished tasks */

int current_finished_tasks = 0;

/* this flag is triggered by the master task  when it finishes */

int finished = 0;

/* number of instances of an hard tasks

   NOTE that it is 79 and not 80 as in the generation algorithm!!! */

#define ASTER_LIM 79

// Master task stuffs

PID master_pid;    // the PID of the master task

int current_task;  // the current position in the pattern array

// number of periodic tasks currently running...

int current_periodic_tasks = 0;

PID info_pid;    // the PID of the master task

/*

 * This function prints all the data read from the configuration file

 */

void print_conffile(char *name)

{

  int i;

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

  cprintf("Configuration file name        : %s\n", name);

  cprintf("Number of tasks in the pattern : %d\n", pattern_dim);

  cprintf("      Time Hard/Value      Dline       WCET Iterations Value Penalty\n");

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

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

    cprintf("%10d %10d %10d %10d %10d %5d %7d\n",

            pattern[i].time,

            pattern[i].type,

            pattern[i].reldline,

            pattern[i].wcet,

            pattern[i].iterations,

            pattern[i].value,

            pattern[i].penalty);

  }

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

}

/*

 * main()

 */

void scenario(void);

void create_master_task(void);

void create_info_task(void);

void update_scenario(void);

void print_statistics(void);

int main(int argc, char **argv)

{

  srand(18);

  set_exchandler_grx();

  /*

   * Parse the configuration file

   */

  crunch_file(pattern, &pattern_dim, MAX_PATTERN);

  if (!pattern_dim) {

    cprintf("Nothing to do!\n");

    sys_end();

  }

  /*

   * Print configuration file

   */

  #ifdef DEBUG_CONFFILE

  print_conffile(argv[1]); return 0;

  #endif

  /*

   * Print the scenario

   */

  scenario();

  /*

   * Create the high priority task that will create all the periodic

   * and value tasks.

   */

  create_master_task();

  /*

   * Create a periodic task to display some statistical informations

   */

  create_info_task();

  /*

   * While in idle time, update the scenario

   */

  while (!finished || task_counter != 3) {

    update_scenario();

  }

  print_statistics();

  return 0;

}

/*

 *

 * MASTER TASK STUFFS

 *

 */

void activate_master_task(void *);

void *master_task(void *);

void *hard_task(void *);

void *value_task(void *);

void create_master_task()

{

  NRT_TASK_MODEL nrt;

  struct timespec t;

  nrt_task_default_model(nrt);

  nrt_task_def_usemath(nrt);

  nrt_task_def_ctrl_jet(nrt);

  nrt_task_def_save_arrivals(nrt);

  master_pid = task_create("master", master_task, &nrt, NULL);

  if(master_pid == -1) {

    cprintf("Cannot create the master task!!!\n");

    sys_end();

  }

  current_task = 0;

  NULL_TIMESPEC(&t);

  ADDUSEC2TIMESPEC(pattern[0].time, &t);

  kern_cli();

  kern_event_post(&t, activate_master_task, NULL);

  kern_sti();

}

void activate_master_task(void *arg)

{

  task_activate(master_pid);

}

void *master_task(void *arg)

{

  int current_time;

  HARD_TASK_MODEL hard;

  PID phard;

  VALUE_TASK_MODEL value;

  PID group_container_pid[100];

  int group_container_pattern[100];

  int group_container_index;

  // used to record the group_creation for value task

  int i;

  PID p;

  task_nopreempt();

  hard_task_default_model(hard);

  hard_task_def_usemath(hard);

  value_task_default_model(value);

  value_task_def_usemath(value);

  do {

    // current_task indexes the next task to be activated.

    current_time = pattern[current_task].time;

    // create and activate all the hard tasks with the same starting time

    if (!pattern[current_task].type) {

      do {

        #ifdef DEBUG_MASTER_HARDCREATE

          { int i=current_task; cprintf("%10d %10d %10d %10d %10d %5d %7d\n",

            pattern[i].time, pattern[i].type, pattern[i].reldline,

            pattern[i].wcet, pattern[i].iterations, pattern[i].value,

            pattern[i].penalty); }

        #endif

        hard_task_def_mit(hard, pattern[current_task].reldline);

        hard_task_def_wcet(hard, pattern[current_task].wcet);

        hard_task_def_arg(hard, (void *)current_task);

        phard = task_create("hard_task", hard_task, &hard, NULL);

        if (phard == NIL) {

          clear();

          cprintf("Cannot create hard task! (errno=%d)\n", errno);

          sys_end();

        }

        else {

          task_activate(phard);

          current_periodic_tasks++;

        }

        current_task++;

      } while (current_task != pattern_dim &&

               pattern[current_task].time == current_time &&

               !pattern[current_task].type);

    }

    // create and activate all the soft tasks with the same starting time

    if (current_task != pattern_dim &&

        pattern[current_task].time == current_time &&

        pattern[current_task].type) {

      group_container_index = 0;

      kern_cli();

      while (current_task != pattern_dim &&

             pattern[current_task].time == current_time &&

             pattern[current_task].type) {

        #ifdef DEBUG_MASTER_VALUECREATE

          { int i=current_task; cprintf("V%10d %10d %10d %10d %10d %5d %7d\n",

            pattern[i].time, pattern[i].type, pattern[i].reldline,

            pattern[i].wcet, pattern[i].iterations, pattern[i].value,

            pattern[i].penalty); }

        #endif

//  kern_printf("master_task: current_value=%d\n",current_value);

        value_task_def_wcet(value,pattern[current_task].wcet);

        value_task_def_dline(value,pattern[current_task].reldline);

        value_task_def_value(value,pattern[current_task].value);

        value_task_def_penalty(value,pattern[current_task].penalty);

        value_task_def_arg(value, (void *)current_task);

        p = group_create("value_task", value_task, (TASK_MODEL *)&value, NULL);

//        kern_printf("\nCreating %d PID = %d\n",current_task, p);

        // we need to know which task we are inserting, so we insert it in

        // a list to check them later

        group_container_pid[group_container_index]=p;

        group_container_pattern[group_container_index]=current_task;

        group_container_index++;

        current_task++;

      }

/*      {kern_printf("group_container: index=%d, 0=%d, 1=%d, 2=%d, 3=%d\n",

       group_container_index, group_container_pid[0], group_container_pid[1],

       group_container_pid[2], group_container_pid[3]);}*/

      guarantee();

//      kern_printf("group_container_index=%d\n",group_container_index);

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

//      {kern_printf("i=%d, group_container: index=%d, 0=%d, 1=%d, 2=%d, 3=%d\n",i,

//       group_container_index, group_container_pid[0], group_container_pid[1],

//       group_container_pid[2], group_container_pid[3]);}

        p = group_container_pid[i];

//        kern_printf("+%d\n",p);

        max_created_value += pattern[group_container_pattern[i]].value;

        min_created_value -= pattern[group_container_pattern[i]].penalty;

        if (p == NIL) continue;

        if (crunch_taskaccepted(p)) {

          // we need to pass the original model for the task...

          // but just the common part is needed O:-)

          // account for the penalty before the task starts

          current_value -= pattern[group_container_pattern[i]].penalty;

          max_value += pattern[group_container_pattern[i]].value;

          min_value -= pattern[group_container_pattern[i]].penalty;

          value_task_def_arg(value, (void *)group_container_pattern[i]);

          group_create_accept(p,(TASK_MODEL *)&value);

//          kern_printf("Accetto task PID=%d\n",p);

        }

        else {

          group_container_pid[i] = NIL;

//          kern_printf("Rigetto task PID=%d\n",p);

          group_create_reject(p);

        }

      }

      kern_sti();

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

//        kern_printf("Attivo %d PID=%d\n",i,group_container_pid[i]);

        if (group_container_pid[i] != NIL)

          task_activate(group_container_pid[i]);

      }

    }

    if (current_task != pattern_dim) {

      struct timespec t;

      NULL_TIMESPEC(&t);

      ADDUSEC2TIMESPEC(pattern[current_task].time, &t);

      kern_cli();

      kern_event_post(&t, activate_master_task, NULL);

      task_endcycle();

    }

  } while(current_task != pattern_dim);

  /* since all the tasks has been activated, the master_task will stop

     forever.

     In that way we can look at the elapsed time consumed by the master task.

  */

//  task_nopreempt();

  finished = 1;

  task_endcycle();

  return (void *)0;

}

#define DEFAULT_SHIFT 1000000

void *hard_task(void *arg)

{

  struct timespec dl, curr;  // for deadline checking

  int index, j, x, y, temp;

  char s[2];

  struct timespec t;

  int b;

  task_setcanceltype(TASK_CANCEL_ASYNCHRONOUS,&temp);

  index = (int)arg;

  NULL_TIMESPEC(&t);

  ADDUSEC2TIMESPEC((DEFAULT_SHIFT*2)/3,&t);

  b = TIMESPEC_A_LT_B(&proc_table[exec_shadow].request_time,&t);

  do {

    x = 0;

    y = rand() % 6 + 3;

    s[0] = '*'; s[1] = 0;

    while (x < ASTER_LIM) {

      for (j=0; j<pattern[index].iterations; j++) {

        s[0] = '*' + rand() % 100;

        puts_xy(x,y,rand()%15+1,s);

      }

      // Dline check :-) it is not perfect, but it works :-)

      kern_cli();

      ll_gettime(TIME_EXACT,&curr);

      dl = proc_table[exec_shadow].request_time;

      ADDUSEC2TIMESPEC(pattern[index].reldline, &dl);

      if (TIMESPEC_A_LT_B(&dl,&curr)) {

        cprintf("\n\nPERIODIC TASK %d: Deadline miss!!!\n", index);

        cprintf("current time= %10ld sec, %10ld ns\n", curr.tv_sec, curr.tv_nsec);

        cprintf("deadline    = %10ld sec, %10ld ns\n", dl.tv_sec, dl.tv_nsec);

        sys_end();

      }

      task_endcycle();

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

      x++;

    }

  } while (b && !finished);

  kern_cli();

  // account for a finished task

  current_finished_tasks++;

  current_periodic_tasks--;

  // Dline check :-) it is not perfect, but it works :-)

  ll_gettime(TIME_EXACT,&curr);

  dl=proc_table[exec_shadow].request_time;

  ADDUSEC2TIMESPEC(pattern[index].reldline, &dl);

  if (TIMESPEC_A_LT_B(&dl,&curr)) {

    cprintf("\n\nPERIODIC TASK %d: Deadline miss!!!\n", index);

    cprintf("current time= %10ld sec, %10ld ns\n", curr.tv_sec, curr.tv_nsec);

    cprintf("deadline    = %10ld sec, %10ld ns\n", dl.tv_sec, dl.tv_nsec);

    sys_end();

  }

  return (void *)0;

}

void *value_task(void *arg)

{

  struct timespec dl, curr;  // for deadline checking

  int index, j, x, y, temp;

  char s[2];

  task_setcanceltype(TASK_CANCEL_ASYNCHRONOUS,&temp);

  index = (int)arg;

  //  kern_printf("Ú%dÙ",index);

  x = rand() % 26 + 1;

  y = rand() % 3  + 10;

  s[0] = '*'; s[1] = 0;

  for (j=0; j<pattern[index].iterations; j++) {

    s[0] = '*' + rand() % 100;

    puts_xy(x,y,rand()%15+1,s);

  }

//  kern_printf("*%d*\n",exec_shadow);

  kern_cli();

  // account for a finished task

  current_finished_tasks++;

  // Dline check :-) it is not perfect, but it works :-)

  ll_gettime(TIME_EXACT,&curr);

  TIMESPEC_ASSIGN(&dl, &proc_table[exec_shadow].request_time);

  ADDUSEC2TIMESPEC(pattern[index].reldline, &dl);

  if (TIMESPEC_A_GT_B(&dl,&curr)) {

    // The task finishes in time. account for the value

    current_value += pattern[index].penalty + pattern[index].value;

  }

  //  kern_printf("value: arg=%d current_value=%d pen=%d val=%d\n",arg,current_value,

  //  ((struct task_struct *)arg)->penalty,

  //      ((struct task_struct *)arg)->value);

  return (void *)0;

}

void *info_task(void *);

void create_info_task(void)

{

  HARD_TASK_MODEL hard;

  hard_task_default_model(hard);

  hard_task_def_usemath(hard);

  hard_task_def_mit(hard, 2000000);

  hard_task_def_wcet(hard, 2000);

  info_pid = task_create("info_task", info_task, &hard, NULL);

  task_activate(info_pid);

}

void *info_task(void *arg)

{

  int x;

  task_setcanceltype(TASK_CANCEL_ASYNCHRONOUS,&x);

  for (;;) {

    update_scenario();

    task_endcycle();

  }

}

void print_statistics(void)

{

  TIME sum;

  clear();

  jet_getstat(master_pid, &sum, 0, 0, 0);

  task_activate(master_pid);         // let the master task die...

  task_kill(info_pid);

  clear();

  cprintf("CRUNCH 1.12 - by Paolo Gai 2001\n\n");

  cprintf("ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ\n\n");

  cprintf("Final Results:\n\n");

  cprintf("The Master task elapsed time   : %d microseconds.\n\n",(int)sum);

  cprintf("Total number of tasks          : %9d\n", pattern_dim);

  cprintf("Total number of scheduled tasks: %9d\n\n",current_task);

  cprintf("Per.tasks created but not ended: %9d\n\n",current_periodic_tasks);

  cprintf("Maximum created value          : %9d\n",max_created_value);

  cprintf("Minimum created value          : %9d\n\n",min_created_value);

  cprintf("Maximum value                  : %9d\n",max_value);

  cprintf("Minimum value                  : %9d\n\n",min_value);

  cprintf("Total Value (from Module)      : %9d\n",crunch_getvalue());

  cprintf("Total Value (from CRUNCH)      : %9d\n",current_value);

  cprintf("ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ\n\n");

}

/*

 * Scenario

 */

void scenario(void)

{

  char buf[100];

  clear();

  puts_xy(0, 0,BLUE , "CRUNCH 1.12");

  puts_xy(15,0,GREEN, "by Paolo Gai 2001");

  puts_xy(0, 2,WHITE, "ÄÄÄ Hard Periodic Tasks ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ");

  puts_xy(0, 9,WHITE, "ÂÄÄ Soft Aperiodic Tasks ÄÄÂÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ");

  puts_xy(0,10,WHITE, "³                          ³");

  puts_xy(0,11,WHITE, "³                          ³");

  puts_xy(0,12,WHITE, "³                          ³");

  puts_xy(0,13,WHITE, "ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ");

  puts_xy(29,10,YELLOW, "Statistics:");

  sprintf(buf,"Total: %5d Already created:        Periodic:",pattern_dim);

  puts_xy(29,11,CYAN,   buf);

  puts_xy(29,12,BLUE,   "Value reported (by Modules):");

  puts_xy(29,13,RED,    "               (by CRUNCH ):");

  puts_xy(69,12,7,   "Min:");

  puts_xy(69,13,7,   "Max:");

  puts_xy(0,14,WHITE, "ÄÄÄ Debug space for Logging Module functions... ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ");

  place(0,15);

}

void update_scenario(void)

{

  char buf[100];

  sprintf(buf,"%5d",current_task);

  puts_xy(58,11,WHITE,buf);

  sprintf(buf,"%5d",current_periodic_tasks);

  puts_xy(75,11,WHITE,buf);

  sprintf(buf,"%5d",crunch_getvalue());

  puts_xy(58,12,WHITE,buf);

  sprintf(buf,"%5d",current_value);

  puts_xy(58,13,WHITE,buf);

  sprintf(buf,"%6d",min_value);

  puts_xy(74,12,WHITE,buf);

  sprintf(buf,"%6d",max_value);

  puts_xy(74,13,WHITE,buf);

}