Subversion Repositories shark

#include "hlpdemo.h"
#include <drivers/shark_keyb26.h>
#include "snapshot.h"

//#define ESC 27

/*
#define DEBUG
*/

/* tipologia di task e mutex */
HARD_TASK_MODEL m;

/* scala temporale del sistema in us */
#define TIMESCALE (100 * 1000)

/* buffer che contiene la configurazione letto in nrt mode */
extern char myfilebuf[1000];

extern int read_conf(char *, unsigned int);
extern void print_taskconf(taskconf_list_t *);

void trace_info_hlp(void);

/* tempo dell'avvio */
TIME start;

/* struttura dati contenente la configurazione */
taskconf_list_t *taskconf = NULL;

/* lista dei mutex del sistema */
mutex_list_t *mutexes = NULL;

#define YMENU    10             /* menu level                   */
#define XMIN     50
#define XMAX     600
#define YMIN     100
#define YMAX     450
#define YFLOOR(index) YMIN + (50 * (index + 1))

#define COLWHITE rgb16(255,255,255)
#define COLLOAD  rgb16(180,180,180)

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

/* posizione lungo l'asse x dopo t sec. */
int xpost(unsigned int t)
{
  int ret;

  ret = XMIN + 10 + (((sys_gettime(NULL) - start) / TIMESCALE) + t);
  if (ret > XMAX)
    ret = XMAX;
  if (ret < XMIN)
    ret = XMIN;

  return ret;
}

/* posizione lungo l'asse x al tempo t corrente */
int xpos(void)
{
  return xpost(0);
}

typedef struct color_stack {
  int color;
  struct color_stack *next;
} color_stack_t;

void color_stack_push(int color, color_stack_t **head)
{
  color_stack_t *new;

  new = (color_stack_t *)kern_alloc(sizeof(color_stack_t));
  new->color = color;
  new->next = *head;

  *head = new;
}

int color_stack_pop(color_stack_t **head)
{
  int ret = COLLOAD;
  color_stack_t *tmp = *head;

  if (*head != NULL)
    {
      ret = (*head)->color;
      *head = (*head)->next;
      kern_free(tmp, (sizeof(color_stack_t)));
    }
 
  return ret;
}


void load(int time, int i, int color, char *name)
{
  int j;
  TIME last;
  char buf[50];

  for (j = 0; j < time; j++)
    {
      last = sys_gettime(NULL);

      grx_line(xpos(), YFLOOR(i), xpos(), YFLOOR(i) - 10, color);
      sprintf(buf,
              "Time: %.4d, task active: %.5s(PID=%.2d, Shadow=%.2d)",
              (int)((sys_gettime(NULL) - start) / TIMESCALE) + 2,
              name,
              exec,
              exec_shadow);
      grx_text(buf, 100,100,COLWHITE,0);

      while (sys_gettime(NULL) - last + (TIMESCALE/100) < TIMESCALE);
    }
}

TASK    Ji(void *arg)
{
  taskconf_list_t *cur = (taskconf_list_t *)arg;
  action_list_t *act;
  color_stack_t *colorstack;

  color_stack_push(COLLOAD, &colorstack);

  while (1)
    {
 
      act = cur->actionlist;

      while (act)
        {
          switch (act->type)
            {
            case LOAD:
              load(act->time, cur->i, colorstack->color, cur->name);
              if (xpos() == XMAX)
                {
                  task_kill(cur->pid);
                  return 0;
                }
              break;
             
            case LOCK: /* task lock */
              color_stack_push(act->mutex->color, &colorstack);
              grx_text(act->mutex->name, xpos() - 2, YFLOOR(cur->i) + 10, COLWHITE, 0);
              mutex_lock(&act->mutex->m);
              trace_info_hlp();
              break;
             
            case UNLOCK: /* task unlock */
              color_stack_pop(&colorstack);
              mutex_unlock(&act->mutex->m);
              trace_info_hlp();
              break;
            }
          act = act->next;
        }
      task_endcycle();
    }

  return 0;
}

void draw_scenario(void)
{
  /* The scenario */
  grx_rect(XMIN-1, YMIN-1, XMAX+1, YMAX+1, COLWHITE);
  grx_text("Simulation of HLP tasks", XMIN, YMENU+10, COLWHITE, 0);
  grx_text("SPACE Start demo"        , XMIN, YMENU+20, COLWHITE, 0);
  grx_text("ESC   exit to DOS"         , XMIN, YMENU+30, COLWHITE, 0);
}

void trace_info_hlp()
{
  HLP_mutex_resource_des *m;
  RLEVEL l;
  HLP_mutex_t *mutscan;
  HLP_tasklist_t *taskscan;
  int i = 0;
  char buf[60];

  if (mutexes)
    {
      l = mutexes->m.mutexlevel;
      m = (HLP_mutex_resource_des *)(resource_table[l]);
     
      for (mutscan = m->mutexlist; mutscan; mutscan = mutscan->next)
        {
          if (mutscan->owner != NIL)
            sprintf(buf, "mutex: %p owner=%2d, used by", mutscan, mutscan->owner);
          else
            sprintf(buf, "mutex: %p no owner, used by", mutscan);
         
          grx_text(buf, 50, 320, COLWHITE, 0);
         
          for (i = 1, taskscan = mutscan->tasklist; taskscan; taskscan = taskscan->next, i++)
            {
              sprintf(buf, "task: %p, pid=%d, preempt=%ld",
                      taskscan,
                      taskscan->pid,
                      taskscan->preempt);
              grx_text(buf, 100, 320+i*8, COLWHITE, 0);
            }
        }

      grx_text("All tasks:", 100, 320 + i++ * 8, COLWHITE, 0);

      if (taskconf)
        for (taskscan = m->tasklist; taskscan; taskscan = taskscan->next, i++)
          {
            sprintf(buf,
                    "task: %p, pid=%d, preempt=%ld",
                    taskscan,
                    taskscan->pid,
                    taskscan->preempt);

            grx_text(buf, 100, 320+i*8, COLWHITE, 0);
          }
    }
  else
    {
      grx_text("No mutexes", 200, 200, COLWHITE, 0);
    }

}

/* get preemption level inverse proportional to period and starting by 1 */
int get_preemption_level(taskconf_list_t *task)
{
  taskconf_list_t *scan;
  int ret = 1;
 
  for (scan = taskconf; scan; scan = scan->next)
    if (scan != task && scan->period < task->period)
      ret++;

  return ret;
}

/****************************** MAIN ******************************/

int main(int argc, char **argv)
{
    char c;             /* character from keyboard      */
    int i = 0, j = 0, started = 0, numtask = 0, nummutex = 0;
    taskconf_list_t *curtask = NULL;
    mutex_list_t *mutexlist = NULL, *curmut = NULL;
    PID pid = NIL;
    HLP_mutexattr_t a;
    HLP_RES_MODEL r;

    if (read_conf(myfilebuf, 1000) == -1)
      {
        sys_shutdown_message("Error reading configuration file");
        sys_end();
      }

    for (curtask = taskconf; curtask != NULL; curtask = curtask->next)
      numtask++;

    draw_scenario();
    curtask = taskconf;

    for (curmut = mutexes; curmut; curmut = curmut->next)
      {
        HLP_mutexattr_default(a);
        mutex_init(&(curmut->m), &a);
      }
   
    snapshot_freeslot(0);

    c = keyb_getch(BLOCK);
    i = started = 0;
    do {
     
      if ((c == ' ') && !started) {
        started = 1;
        start = sys_gettime(NULL);

        while (curtask) {

          /* traccio gli assi temporali per ogni task */
          grx_line(XMIN + 10, YFLOOR(i), XMAX - 10, YFLOOR(i), COLWHITE);
          grx_text(curtask->name, XMIN - 20, YFLOOR(i) - 10, COLWHITE, 0);                     
         
          /* disegna frecce di attivazione */
          for (j = 0; xpost(j) < XMAX; j += curtask->period)
            {
              grx_line(xpost(j), YFLOOR(i), xpost(j), YFLOOR(i) - 20, COLWHITE);
              grx_line(xpost(j), YFLOOR(i) - 20, xpost(j) - 5, YFLOOR(i) - 15, COLWHITE);
              grx_line(xpost(j), YFLOOR(i) - 20, xpost(j) + 5, YFLOOR(i) - 15, COLWHITE);
            }

          hard_task_default_model(m);
          hard_task_def_level(m,0);
          hard_task_def_ctrl_jet(m);
          hard_task_def_periodic(m);
          hard_task_def_wcet(m, (curtask->wcet + 2) * TIMESCALE);
          hard_task_def_mit(m, curtask->period * TIMESCALE);
          hard_task_def_arg(m,(void *)curtask);
          hard_task_def_group(m, 1);
         
          /* registro i mutex per il pid */
          nummutex = 0;
          mutexlist = curtask->mutexlist;
          while(mutexlist) {
            mutexlist = mutexlist->next;
            nummutex++;
          }
         
          //      HLP_res_default_model(r, get_preemption_level(curtask));
          HLP_res_default_model(r, 1000 - curtask->period);
         
          switch (nummutex) {
          case 0:
            pid = task_create(curtask->name, Ji, &m, &r);
            break;
           
          case 1:
            pid = task_createn(curtask->name, Ji, (TASK_MODEL *)&m, &r,
                               HLP_usemutex(&(curtask->mutexlist->m)), NULL);
            break;
           
          case 2:
            pid = task_createn(curtask->name, Ji, (TASK_MODEL *)&m, &r,
                               HLP_usemutex(&(curtask->mutexlist->m)),
                               HLP_usemutex(&(curtask->mutexlist->next->m)), NULL);
            break;
          case 3:
            pid = task_createn(curtask->name, Ji, (TASK_MODEL *)&m, &r,
                               HLP_usemutex(&(curtask->mutexlist->m)),
                               HLP_usemutex(&(curtask->mutexlist->next->m)),
                               HLP_usemutex(&(curtask->mutexlist->next->next->m)), NULL);
            break;
          case 4:
            pid = task_createn(curtask->name, Ji, (TASK_MODEL *)&m, &r,
                               HLP_usemutex(&(curtask->mutexlist->m)),
                               HLP_usemutex(&(curtask->mutexlist->next->m)),
                               HLP_usemutex(&(curtask->mutexlist->next->next->m)),
                               HLP_usemutex(&(curtask->mutexlist->next->next->next->m)), NULL);
            break;
           
          default:
            sys_shutdown_message("Too many mutexes! I am stupid!");
            sys_end();
          }
         
          if (pid == NIL)
            {
              sys_shutdown_message("Could not create task %s", curtask->name);
              sys_end();
              print_taskconf(curtask);
              return 0;
            }
          curtask->pid = pid;
          curtask->i = i++;
         
          curtask = curtask->next;
        }
       
        trace_info_hlp();
       
        start = sys_gettime(NULL);
        group_activate(1);
      }


      c = keyb_getch(BLOCK);

      if (xpos() > XMAX)
        {
          group_kill(1);
        }
     
    } while (c != ESC);

    snapshot_getslot(0, 640, 480, 2);
    snapshot_grab(0);

    sys_end();
   
    snapshot_save_ppm(0, "snapshot.ppm");

    return 0;
   
}

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