Subversion Repositories shark

/*
 * Project: HARTIK (HA-rd R-eal TI-me K-ernel)
 *
 * Coordinators: Giorgio Buttazzo <giorgio@sssup.it>
 *               Gerardo Lamastra <gerardo@sssup.it>
 *
 * Authors     : Massimiliano Giorgi <massy@hartik.sssup.it>
 * (see authors.txt for full list of hartik's authors)
 *
 * ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy)
 *
 * http://www.sssup.it
 * http://retis.sssup.it
 * http://hartik.sssup.it
 */

/*
 * Copyright (C) 1999 Massimiliano Giorgi
 *
 * 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
 *
 */

/*
 * CVS :        $Id: jdump.c,v 1.1.1.1 2002-09-02 09:37:48 pj Exp $
 *
 * File:        $File$
 * Revision:    $Revision: 1.1.1.1 $
 * Last update: $Date: 2002-09-02 09:37:48 $
 */

#include <netinet/in.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>

#include "types.h"
#include <trace.h>
#include "util.h"

/*
 *
 *
 *
 */

/* All times are dived by this costant. */
#define TIMESCALE 1

/* If defined dump on stdout the packets (in ascii) that will be written
 * on the output file (the file of the tracer).
 */

#define DUMPOUT

/*
 *
 *
 *
 */

int pippo=0;

int writeInt(int h, int x)
{
  int y,res;
  y=htonl(x);
  res=write(h,&y,sizeof(int));
  return res!=sizeof(int);
}


int writeStr(int h, char *s)
{
  int res,size;
  size=strlen(s);
  writeInt(h,size);
  res=write(h,s,size);
  return res!=size;
}

/*
 *
 */

#define TASK_ARRIVAL      0
#define TASK_SCHEDULE     1
#define TASK_DESCHEDULE   2
#define TASK_END          3
#define TASK_DLINEPOST    4
#define TASK_DLINESET     5
#define TASK_WAIT         6
#define TASK_SIGNAL       7
#define TASK_IDLE         8
#define TASK_NAME         9

#define EVT_NUMBER       10

char *eventsname[]={
  "task_arrival",
  "task_schedule",
  "task_deschedule",
  "task_end",
  "task_dlinepost",
  "task_dlineset",
  "task_wait",
  "task_signal",
  "task_idle",
  "task_name"
};

struct j_evt_prolog {
  int                 type;
  int                 time;
};

struct j_evt_task {
  struct j_evt_prolog p;
  int                 task;
};

struct j_evt_dlinepost {
  struct j_evt_task   t;
  int                 taskD;
  int                 taskD2;
};

struct j_evt_dlineset {
  struct j_evt_task   t;
  int                 taskD;
};

struct j_evt_semaph {
  struct j_evt_task   t;
  int                 res;
  char                *name;
};

struct j_evt_name {
  struct j_evt_task   t;
  char                *name;
};

/*
 *
 */

int j_write_prolog(int h, void *ptr)
{
#ifdef DUMPOUT
  printf("%10i ",((struct j_evt_prolog *)ptr)->time);
  printf("%-18s ",eventsname[((struct j_evt_prolog *)ptr)->type]);
#endif
  if (writeInt(h,((struct j_evt_prolog *)ptr)->type)) return -2;
  if (writeInt(h,((struct j_evt_prolog *)ptr)->time)) return -3;
  return 0;
}

int j_write_task(int h, void *ptr)
{
  int res;
  res=j_write_prolog(h,ptr);
#ifdef DUMPOUT
  printf("tsk=%i ",((struct j_evt_task *)ptr)->task);
#endif
  if (res) return res;
  if (writeInt(h,((struct j_evt_task *)ptr)->task)) return -4;
  return 0;
}

int j_write_dlinepost(int h, void *ptr)
{
  int res;
  res=j_write_task(h,ptr);
  if (res) return res;
  if (writeInt(h,((struct j_evt_dlinepost *)ptr)->taskD)) return -5;
  if (writeInt(h,((struct j_evt_dlinepost *)ptr)->taskD2)) return -6;
  return 0;
}

int j_write_dlineset(int h, void *ptr)
{
  int res;
  res=j_write_task(h,ptr);
  if (res) return res;
  if (writeInt(h,((struct j_evt_dlineset *)ptr)->taskD)) return -7;
  return 0;
}

int j_write_semaph(int h, void *ptr)
{
  int res;
  res=j_write_task(h,ptr);
  if (res) return res;
  if (writeInt(h,((struct j_evt_semaph *)ptr)->res)) return -8;
  if (writeStr(h,((struct j_evt_semaph *)ptr)->name)) return -9;
  return 0;
}

int j_write_name(int h, void *ptr)
{
  int res;
  res=j_write_task(h,ptr);
#ifdef DUMPOUT
  printf("name='%s' ",((struct j_evt_name *)ptr)->name);
#endif
  if (res) return res;
  if (writeStr(h,((struct j_evt_name *)ptr)->name)) return -10;
  return 0;
}
 
int writeEvent(int h, void *ptr)
{
  int res;
   
  //printf("<%i>",((struct j_evt_prolog*)ptr)->type);
   
  ((struct j_evt_prolog*)ptr)->time/=TIMESCALE;

  switch(((struct j_evt_prolog*)ptr)->type) {
  case TASK_ARRIVAL:
  case TASK_SCHEDULE:
  case TASK_DESCHEDULE:
  case TASK_END:
  case TASK_IDLE:
    res=j_write_task(h,ptr);
    break;
  case TASK_DLINEPOST:
    res=j_write_dlinepost(h,ptr);
    break;
  case TASK_DLINESET:
    res=j_write_dlineset(h,ptr);
    break;
  case TASK_WAIT:
  case TASK_SIGNAL:
    res=j_write_semaph(h,ptr);
    break;
  case TASK_NAME:
    res=j_write_name(h,ptr);
    break;
  default:
    return -1;
   
  }

#ifdef DUMPOUT
  printf(" \n");
#endif

  return res;
}

/*
 *
 *
 *
 */

#define MAX_PROC 150

//int activated[MAX_PROC];

int cxx=0;
/* write MAXC-1 events */
#define MAXC 14

long lasttime;

int sys_event(int h, void *param)
{
  static int prevtask=-1;
  trc_event_t *ptr=(trc_event_t *)param;
  struct j_evt_task evt;

  evt.p.time=ptr->time;
  evt.task=ptr->x.sys.task;

  lasttime=ptr->time;
  switch(ptr->event) {
     
  case TRC_CREATE:
    return 0;

  case TRC_ACTIVATE:
  case TRC_INTACTIVATION:


    //activated[ptr->x.sys.task]=1;


    evt.p.type=TASK_ARRIVAL;
    break;
     
  case TRC_DESTROY:


    //activated[ptr->x.sys.task]=0;



    return 0;                    
     
  case TRC_DELAY:
    prevtask=-1;
    evt.p.type=TASK_DESCHEDULE;
    break;
     
  case TRC_SLEEP:
    prevtask=-1;
    evt.p.type=TASK_DESCHEDULE;
    break;
     
  case TRC_ENDCYCLE:
    evt.p.type=TASK_END;
    break;

  case TRC_SCHEDULE:
    if (prevtask!=-1) {
      struct j_evt_task evt2;
      int res;
      evt2.p.time=ptr->time;
      evt2.p.type=TASK_DESCHEDULE;
      evt2.task=prevtask;
      res=writeEvent(h,&evt2);  
      if (res!=0) return -1;
    }

    /*
      if (!activated[ptr->x.sys.task]) {
      struct j_evt_task evt2;

      evt2.p.time=ptr->time-1;
      evt2.task=ptr->x.sys.task;
      evt2.p.type=TASK_ARRIVAL;

      writeEvent(h,&evt2);  
       
      activated[ptr->x.sys.task]=1;
      }
    */

    evt.p.type=TASK_SCHEDULE;
    prevtask=ptr->x.sys.task;
    break;

  default:
    return 0;
  }

  cxx++;
  if (cxx==MAXC) return -1;

  return writeEvent(h,&evt);  
}


int sem_event(int h,void *param)
{
  //trc_event_t *ptr=(trc_event_t *)param;
  //struct j_evt_semaph evt;

  return 0;
  /*  
  evt.t.p.time=ptr->x.norm.when;
  evt.t.task=ptr->x.norm.who;
  switch(ptr->what) {
    case TRC_SEM_WAIT:   evt.t.p.type=TASK_WAIT; break;
    case TRC_SEM_SIGNAL: evt.t.p.type=TASK_SIGNAL; break;
    case TRC_SEM_WAITNB: return 0;
    default:             return 0;
  }
  evt.res=1;
  evt.name="NoName";
  return j_write_semaph(h,&evt);
  */
}

/* -- */

#define MAX_PROC 150
int names[MAX_PROC];

int outfile;

int dumpfunc(trc_event_t *ptr)
{
  //printf("{%i}",ptr->event);

  if (!names[ptr->x.sys.task]) {
    struct j_evt_name evtname;
    static char name[24];

    cxx++;
    if (cxx==MAXC) return -1;
 
    evtname.t.p.time=lasttime;
    evtname.t.task=ptr->x.sys.task;
    evtname.t.p.type=TASK_NAME;
    sprintf(name,"task%03i",ptr->x.sys.task);
    evtname.name=name;
    writeEvent(outfile,&evtname);
    names[ptr->x.sys.task]=1;

  }

  switch(event_class(ptr->event)) {
    case TRC_CLASS_SYSTEM:
      return sys_event(outfile,ptr);
    case TRC_CLASS_SEM:
      return 0;
      return sem_event(outfile,ptr);
    case TRC_CLASS_USER:
      return 0;
  }
  return 0;
}

/*
 *
 */

#ifndef O_BINARY
#define O_BINARY 0
#endif

int main(int argc, char *argv[])
{
  int res;
  int i;

  if (argc!=3) {
    fprintf(stderr,"missing filenames\n");
    fprintf(stderr,"usage: jdump H4tracefilename JTRACERtracefilename\n");
    return -1;
  }

  for (i=0;i<MAX_PROC;i++) {
    names[i]=0;
    //activated[i]=0;
  }

  outfile=open(argv[2],O_WRONLY|O_CREAT|O_TRUNC|O_BINARY,0777);
  if (outfile==-1) {
    perror("can't open outfile");
    return -1;
  }  
  res=read_trace(argv[1],dumpfunc);
  close(outfile);
 
  //fprintf(stderr,"result=%i",res);
  return 0;
}