Subversion Repositories shark

#include "hlpdemo.h"

#include <drivers/shark_keyb26.h>

/* #define DEBUG */

/* tipologia di task e mutex */

HARD_TASK_MODEL m;

/* scala temporale del sistema in us */

#define TIMESCALE (100 * 1000)

/* fine del mondo in TIMESCALE */

#define END_OF_WORLD 280

// utility

#define CURTIME ((sys_gettime(NULL) - start) / TIMESCALE)

void anykey(int sec)

{

  /*  char c;

  cprintf("Premere il tasto 'c' per continuare\n");

  do {

    c = keyb_getch(BLOCK);

    } while(c != 'c');*/

  TIME last;

  last = sys_gettime(NULL);

  while (sys_gettime(NULL) - last < sec * 1000 * 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;

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

void load(int time, char *name)

{

  int i;

  TIME last;

  for (i = 0; i < time; i++)

    {

      last = sys_gettime(NULL);

      cprintf(".");

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

    }

}

TASK    Ji(void *arg)

{

  taskconf_list_t *cur = (taskconf_list_t *)arg;

  action_list_t *act;

  while (1)

    {

      if (CURTIME > END_OF_WORLD)

        {

          task_kill(cur->pid);

          return 0;

        }

      act = cur->actionlist;

      while (act)

        {

          switch (act->type)

            {

            case LOAD:

              cprintf("%ld -- task: %s -- NonCritic section:(exec=%.2d,Shadow=%.2d),load %d",

                          CURTIME,

                          cur->name,

                          exec,

                          exec_shadow,

                          act->time);

              load(act->time, cur->name);

              cprintf("end %ld\n", CURTIME);

              break;

            case LOCK: /* task lock */

              cprintf("%ld -- Task %s -- locks mutex %s\n", CURTIME, cur->name, act->mutex->name);

              mutex_lock(&act->mutex->m);

              break;

            case UNLOCK: /* task unlock */

              cprintf("%ld -- Task %s -- unlocks mutex %s\n", CURTIME, cur->name, act->mutex->name);

              mutex_unlock(&act->mutex->m);

              break;

            }

          act = act->next;

        }

      task_endcycle();

    }

  return 0;

}

void trace_info_hlp()

{

  HLP_mutex_resource_des *m;

  RLEVEL l;

  HLP_mutex_t *mutscan;

  HLP_tasklist_t *taskscan;

  int i = 0;

  if (mutexes)

    {

      l = mutexes->m.mutexlevel;

      m = (HLP_mutex_resource_des *)(resource_table[l]);

      for (mutscan = m->mutexlist; mutscan; mutscan = mutscan->next)

        {

          cprintf("mutex: %p owner=%d, used by\n", mutscan, mutscan->owner);

          for (i = 1, taskscan = mutscan->tasklist; taskscan; taskscan = taskscan->next, i++)

            {

              cprintf("task: %p, pid=%d, preempt=%ld\n",

                      taskscan,

                      taskscan->pid,

                      taskscan->preempt);

            }

        }

      cprintf("All tasks:\n");

      if (taskconf)

        for (taskscan = m->tasklist; taskscan; taskscan = taskscan->next, i++)

          {

            cprintf("task: %p, pid=%d, preempt=%ld\n",

                    taskscan,

                    taskscan->pid,

                    taskscan->preempt);

          }

    }

  else

    {

      cprintf("No mutexes\n");

    }

}

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

int main(int argc, char **argv)

{

  int i = 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();

    }

  clear();

  print_taskconf(taskconf);

  anykey(5);

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

    numtask++;

  curtask = taskconf;

  for (curmut = mutexes; curmut; curmut = curmut->next)

    {

      HLP_mutexattr_default(a);

      mutex_init(&(curmut->m), &a);

    }

  while (curtask) {

    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, 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;

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

        perror("errore nella creazione del task");

        return 0;

      }

    else

      {

        cprintf("Task %s pid %d creato con successo!\n", curtask->name, pid);

      }

    curtask->pid = pid;

    curtask->i = i++;

    curtask = curtask->next;

  }

#ifndef USESRP

  clear();

  cprintf("informazioni dal modulo HLP:\n");

  trace_info_hlp();

  anykey(5);

#endif

  clear();

  cprintf("Attivazione dei task\n");

  anykey(2);

  start = sys_gettime(NULL);

  group_activate(1);

  while(keyb_getch(BLOCK) != 27); // Ascii code of ESC == 27

  anykey(20);

  sys_end();

  return 0;

}

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