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: step3.c,v 1.1 2004-07-05 14:17:15 pj Exp $

 File:        $File$

 Revision:    $Revision: 1.1 $

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

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

**/

/*

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

#include "ll/i386/x-dos.h"

#include "modules/rr.h"

#include "modules/dummy.h"

#include "modules/edf.h"

#include "modules/sem.h"

#include "modules/hartport.h"

#include "drivers/keyb.h"

#include "ctype.h"

#include "tune.h"

int ending=0;

// Patterns

#define MAX_PATTERN 10000

int max_pattern = 0;

TIME pattern_t[MAX_PATTERN];

TIME pattern_period[MAX_PATTERN];

TIME pattern_wcet[MAX_PATTERN];

TIME pattern_iter[MAX_PATTERN];

TIME pattern_value[MAX_PATTERN];

TIME pattern_penalty[MAX_PATTERN];

// Random load

int max_random = 0;

TIME random_t[MAX_PATTERN];

TIME random_reldline[MAX_PATTERN];

TIME random_wcet[MAX_PATTERN];

int  random_value[MAX_PATTERN];

int  random_penalty[MAX_PATTERN];

// Bad load

int max_bad = 0;

TIME bad_t[MAX_PATTERN];

TIME bad_reldline[MAX_PATTERN];

TIME bad_wcet[MAX_PATTERN];

int  bad_value[MAX_PATTERN];

int  bad_penalty[MAX_PATTERN];

#define WCET_SLACK 500

void tune_pattern(void)

{

  int i,w;

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

    place(0,15);

    cprintf("Tuning index %d/%d.\n",i,max_pattern);

    if (i>0 && pattern_wcet[i]==pattern_wcet[i-1])

      pattern_iter[i] = pattern_iter[i-1];

    else {

      w = (pattern_wcet[i]*80)/100-WCET_SLACK;

      // if (w>pattern_wcet[i]-WCET_SLACK) w=pattern_wcet[i]-WCET_SLACK;

      pattern_iter[i] = tune_CPU_speed(w);

    }

  }

}

// Shape modification

#define DEFAULT_SHIFT 1000000

#define MAX_SHAPE 1000

bandwidth_t shape_B[MAX_SHAPE];

TIME shape_T[MAX_SHAPE];

int max_shape;

// this function creates a set if tasks (1 or 2) that comes at random

// time, with random values and random wcet.

#define MAX_PERIOD 2998

void generate_random_load(void)

{

  int current_time = DEFAULT_SHIFT;

  while (current_time<shape_T[max_shape-1]*1000000) {

    random_t[max_random] = current_time;

    random_reldline[max_random] = rand()%MAX_PERIOD*1000+2;

    random_wcet[max_random] = rand()%(random_reldline[max_random]-1000)+1000;

    random_value[max_random] = rand()%101;

    random_penalty[max_random] = rand()%101;

    if (rand()%2)

      current_time += random_reldline[max_random] + 100000;

    max_random++;

  }

}

#define MAX_VALUE_REL_DLINE 3000000

#define SUBTASKS    10

#define SUBSUBTASKS 30

void generate_bad_load(void)

{

  int i,j,k;

  bandwidth_t freeB;

  TIME t,l;

  int subtasks, rdline;

  for (i=1; i < max_shape; i++) {

    //length of the period with the same max bandwidth

    l = (shape_T[i]-shape_T[i-1])* 1000000;

    freeB = MAX_BANDWIDTH - shape_B[i-1];

    t = shape_T[i-1]*1000000 + DEFAULT_SHIFT;

    if (l/SUBTASKS > MAX_VALUE_REL_DLINE) {

      subtasks = l/MAX_VALUE_REL_DLINE;

      rdline = MAX_VALUE_REL_DLINE;

    }

    else {

      subtasks = SUBTASKS;

      rdline = l/SUBTASKS;

    }

    for (j=0; j<subtasks; j++) {

      // create the first "big" task

      bad_t[max_bad] = t;

      bad_reldline[max_bad] = rdline;

      bad_wcet[max_bad] = (int)(((double)freeB/(double)MAX_BANDWIDTH)*bad_reldline[max_bad]);

      bad_value[max_bad] = 80;

      bad_penalty[max_bad] = 90;

      max_bad++;

      // create the small subtasks!!

      for (k=0; k<SUBSUBTASKS; k++) {

        bad_t[max_bad] = t;

        bad_reldline[max_bad] = rdline/SUBSUBTASKS;

        bad_wcet[max_bad] = (int)(((double)freeB/(double)MAX_BANDWIDTH)*bad_reldline[max_bad]);

        bad_value[max_bad] = 100/SUBSUBTASKS;

        bad_penalty[max_bad] = 200/SUBSUBTASKS;

        max_bad++;

        t += rdline/SUBSUBTASKS;

      }

    }

  }

}

#define INSERT_RANDOM 1

#define INSERT_BAD 2

// This function merges the random load and the bad_load into the pattern!

// This function subsumes that the two arrays are ordered by time.

void generate_pattern(void)

{

  int random_i, bad_i;

  int todo = 0;

  random_i = 0;

  bad_i = 0;

  while (!(random_i == max_random && bad_i == max_bad)) {

    if (random_i < max_random) {

      // there are random available

      if (bad_i < max_bad)

        // random and bad available

        if (random_t[random_i] < bad_t[bad_i])

          todo = INSERT_RANDOM;

        else

          todo = INSERT_BAD;

      else

        // only random

        todo = INSERT_RANDOM;

    }

    else

      // only bad available

      todo = INSERT_BAD;

    if (todo == INSERT_RANDOM) {

      pattern_t[max_pattern] = random_t[random_i];

      pattern_period[max_pattern] = random_reldline[random_i];

      pattern_wcet[max_pattern] = random_wcet[random_i];

      pattern_value[max_pattern] = random_value[random_i];

      pattern_penalty[max_pattern] = random_penalty[random_i];

      max_pattern++;

      random_i++;

    }

    else {

      pattern_t[max_pattern] = bad_t[bad_i];

      pattern_period[max_pattern] = bad_reldline[bad_i];

      pattern_wcet[max_pattern] = bad_wcet[bad_i];

      pattern_value[max_pattern] = bad_value[bad_i];

      pattern_penalty[max_pattern] = bad_penalty[bad_i];

      max_pattern++;

      bad_i++;

    }

  }

}

// Read/Write part

#define FILEBUF_DIM 10000

/* This is the buffer used by read_myfile */

char myfilebuf[FILEBUF_DIM];

/* This is the number of bytes read by read_myfile */

int myfilebuf_length;

/* the buffer b is scannedc to search for numbers

   at the first non-number the function stops */

int geti(char *b, int *pos, int maxpos)

{

  int res = 0;

  // skip first chars

  while (!isdigit(b[*pos])) {

    (*pos)++;

    if (*pos == maxpos) return -1;  // Error!!!

  }

  // read the numbers

  do {

    res = (res * 10) + b[*pos] - '0';

    (*pos)++;

  } while (isdigit(b[*pos]));

  return res;

}

void parse_shape(void)

{

  int curr_filepos = 0;

  int i = 0;

  // read the number of tasks into the data file

  max_shape = geti(myfilebuf, &curr_filepos, myfilebuf_length);

  if (max_shape == -1) {

    cprintf("Error parsing shape.dat file...\n");

    sys_end();

  }

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

      // read the seven datas

      shape_T[i]      = geti(myfilebuf, &curr_filepos, myfilebuf_length);

      shape_B[i]      = geti(myfilebuf, &curr_filepos, myfilebuf_length);

      // check the last one for an error

      if (shape_B[i] == -1) {

        cprintf("Error parsing shape %d...\n",i);

        sys_end();

      }

  }

}

void read_shapes(void)

{

  char name[]="shape.dat";

  /* DOS file descriptor */

  DOS_FILE *f;

  /* Error code */

  int err;

  /* open the DOS file for reading  (you can specify only "r" or "w") */

  f = DOS_fopen(name,"r");

  /* check for open errors */

  if (!f) {

    /* error!! */

    err = DOS_error();

    /* note that if you call DOS_error() here, it return 0!!! */

    cprintf("Error %d opening %s...\n", err, name);

    myfilebuf_length = 0;

    return;

  }

  /* read up to 1000 chars */

  myfilebuf_length = DOS_fread(&myfilebuf,1,FILEBUF_DIM,f);

  /* check for errors */

  err = DOS_error();

  cprintf("Read %d bytes from %s...\n", myfilebuf_length, name);

  if (err) {

    cprintf("Error %d reading %s...\n", err, name);

    myfilebuf_length = 0;

   /* there is not return because I want to close the file! */

  }

  /* Close the file */

  DOS_fclose(f);

}

/* This function write myfile.out (up to 30 chars) */

void write_vpattern(void *arg)

{

  DOS_FILE *f;  /* DOS file descriptor */

  int err=0;  /* Error code */

  int writtenbytes = 0;  /* number of files written */

  char buf[100];

  int i;

  /* open the DOS file for writing  (you can specify only "r" or "w") */

  f = DOS_fopen("vpattern.dat","w");

  /* check for open errors */

  if (!f) {

    /* error!! */

    err = DOS_error();

    /* note that if you call DOS_error() here, it return 0!!! */

    cprintf("Error %d opening hpattern.dat...\n", err);

    return;

  }

  sprintf(buf,"%d\r\n",max_pattern);

  writtenbytes += DOS_fwrite(buf,1,strlen(buf),f);

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

    sprintf(buf,"%ld %ld %ld %ld %ld %ld\r\n",

            pattern_t[i],

            pattern_period[i],

            pattern_wcet[i],

            pattern_iter[i],

            pattern_value[i],

            pattern_penalty[i]);

    writtenbytes += DOS_fwrite(buf,1,strlen(buf),f);

    /* check for errors */

    err = DOS_error();

    if (err) break;

  }

  cprintf("Written %d bytes into vpattern.dat...\n", writtenbytes);

  if (err) {

    cprintf("Error %d writing vpattern.dat...\n", err);

    /* there is not return because I want to close the file! */

  }

  /* Close the file */

  DOS_fclose(f);

}

/*+ sysyem tick in us +*/

#define TICK 0

/*+ RR tick in us +*/

#define RRTICK 10000

void read_myfile(void);

TIME __kernel_register_levels__(void *arg)

{

  struct multiboot_info *mb = (struct multiboot_info *)arg;

  EDF_register_level(EDF_ENABLE_ALL);

  RR_register_level(RRTICK, RR_MAIN_NO, mb);

  RR_register_level(RRTICK, RR_MAIN_YES, mb);

  dummy_register_level();

  SEM_register_module();

  read_shapes();

  return TICK;

}

NRT_TASK_MODEL keyb_model;

TASK __init__(void *arg)

{

  KEYB_PARMS kparms = BASE_KEYB;

  HARTPORT_init();

  nrt_task_default_model(keyb_model);

  nrt_task_def_system(keyb_model);

  nrt_task_def_nokill(keyb_model);

  keyb_def_task(kparms,(TASK_MODEL *)&keyb_model);

  KEYB_init(&kparms);

  set_exchandler_grx();

  srand(sys_gettime(NULL));

  clear();

  sys_atrunlevel(write_vpattern, NULL, RUNLEVEL_AFTER_EXIT);

  parse_shape();

  // random load...

  generate_random_load();

  // a big task and a lot of small tasks that uses 2*(MAX_BANDWIDTH-shape)

  generate_bad_load();

  // mixes the two loads

  generate_pattern();

  tune_pattern();

  return (void *)0;

}

// never called!!!

int main()

{

  return 0;

}