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: step2.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];

void record_pattern(TIME t, TIME period, TIME wcet)
{
  pattern_t[max_pattern] = t;
  pattern_period[max_pattern] = period;
  pattern_wcet[max_pattern] = wcet;
  max_pattern++;
}

#define WCET_SLACK 500

void tune_pattern(void)
{
  int i,w;

  for (i=0; i<max_pattern; i++) {
    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=0; // current shape threshold

int current_shape = 0;
bandwidth_t shape_B[MAX_SHAPE];
TIME shape_T[MAX_SHAPE];
int max_shape;

void shape_event(void *arg)
{
  struct timespec t;

  shape = shape_B[current_shape];

  current_shape++;

  if (current_shape == max_shape)
    ending = 1;

  NULL_TIMESPEC(&t);
  ADDUSEC2TIMESPEC((shape_T[current_shape]*1000000+DEFAULT_SHIFT),&t);

//  cprintf("At Time=%10ld.%10ld T=%10d Shape=%10d\n",t.tv_sec,t.tv_nsec,
//          shape_T[current_shape],shape_B[current_shape]);

  kern_event_post(&t,shape_event,NULL);
}

void start_shape(void)
{
  struct timespec t;

  NULL_TIMESPEC(&t);
  ADDUSEC2TIMESPEC(DEFAULT_SHIFT,&t);
  kern_cli();
  kern_event_post(&t,shape_event,NULL);
  kern_sti();
}

// Hard task
#define ASTER_LIM 80
void *hard_task(void *arg)
{
  int j, x, y;
  char s[2];

  x = 0;
  y = rand() % 6 + 3;
  s[0] = '*'; s[1] = 0;
  while (x < ASTER_LIM) {
    for (j=0; j<50; j++) {
      s[0] = '*' + rand() % 100;
      puts_xy(x,y,rand()%15+1,s);
    }

    task_endcycle();

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

  return (void *)0;
}


#define MAX_PERIOD 100
// Load creation
void *create_load(void *arg)
{
    PID p;

    HARD_TASK_MODEL m;
    TIME period = 0;
    TIME wcet = 0;
    int x; // adaptive bandwidth...
    int counter=0;

    char buf[100];

    hard_task_default_model(m);

    x = MAX_PERIOD/3;

    place(0,11);

    // waiting for the start time :-)
    while (sys_gettime(NULL)<DEFAULT_SHIFT);

    while (1) {
      sprintf(buf,"Shape: %5.3f Band: %5.3f period: %10ld wcet: %10ld Time: %d",
              (double)shape/(double)MAX_BANDWIDTH,
              (double)EDF_usedbandwidth(0)/(double)MAX_BANDWIDTH,
              period, wcet, sys_gettime(NULL)/1000000);
      puts_xy(0,10,WHITE,buf);

      period = (x+rand() % (MAX_PERIOD-x+1))*1000;
      wcet = rand()%1000 * (period/1500);

      if ((MAX_BANDWIDTH/period)*wcet > shape - EDF_usedbandwidth(0))
        wcet = (shape - EDF_usedbandwidth(0))/period;

      if (wcet < period/40) wcet=period/40;
      if (wcet < 500) wcet=500;

      if (EDF_usedbandwidth(0) + (MAX_BANDWIDTH/period)*wcet < shape) {

        hard_task_def_mit(m, period);
        hard_task_def_wcet(m, wcet);
        p = task_create("hard_task",hard_task,&m,NULL);
        if (p == -1) {
          x += rand()%10-4;
        }
        else {
          record_pattern(sys_gettime(NULL),period,wcet);
          cprintf("%d ",++counter);
          task_activate(p);
          x *= 3;
          x /= 4;
        }
        if (x<MAX_PERIOD/3) x = MAX_PERIOD/3;
        if (x > MAX_PERIOD) x = MAX_PERIOD;
      }

      if (ending) return (void *)0;
    }
}


// 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_hpattern(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("hpattern.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\r\n", pattern_t[i], pattern_period[i],
                            pattern_wcet[i], pattern_iter[i]);

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

    /* check for errors */
    err = DOS_error();
    if (err) break;
  }


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

  if (err) {
    cprintf("Error %d writing hpattern.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)
{
  NRT_TASK_MODEL nrt;

  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();

  nrt_task_default_model(nrt);

  srand(sys_gettime(NULL));

  clear();

  sys_atrunlevel(write_hpattern, NULL, RUNLEVEL_AFTER_EXIT);

  parse_shape();

  start_shape();

  task_activate(task_create("create_load",create_load,&nrt,NULL));

  cputs("\nWaiting the end of the periodic tasks...\n");
  while (task_counter != 1);

  // the task create_load preempt __init__ until all is finished!
  tune_pattern();

  return (void *)0;
}

// never called!!!
int main()
{
  return 0;
}