distrib/sources/tas/stb/stb_ctk_mutex.c

   1
   2
   3 #include MUT_H
   4 #include INF_H
   5 #include STM_H
   6 #include TTV_H
   7 #include TRC_H
   8
   9 #include "stb_ctk_mutex.h"
  10
  11 static chain_list *ALL_MUTEX=NULL;
  12 static unsigned int NB_MUTEX=0;
  13
  14 typedef struct {
  15   chain_list *HEAD ;
  16   one_mutex  *MTX ;
  17 } tabmtx ;
  18
  19 tabmtx* STB_CTK_TAB_MTX = NULL ;
  20
  21 static void __CtkMutexInit(ttvfig_list *tvf, int num, long level)
  22 {
  23   inffig_list *ifl;
  24   lofig_list *lf;
  25   chain_list *chain, *head, *chainsig, *cl, *ch;
  26   ttvsig_list *tvs;
  27   ttvevent_list *tvn;
  28   losig_list *ls;
  29   unsigned int i;
  30   ptype_list *pt;
  31   one_mutex *om;
  32   const struct
  33   {
  34     char *section;
  35     char edge;
  36     int mutextype;
  37   } annot[]=
  38     {
  39       {INF_CROSSTALKMUXU, 'u', MUTEX_ONLY_ONE},
  40       {INF_CROSSTALKMUXD, 'd', MUTEX_ONLY_ONE}
  41     };
  42
  43   ifl=getinffig(tvf->INFO->FIGNAME);
  44   lf=rcx_getlofig(tvf->INFO->FIGNAME, NULL);
  45
  46   for (i=0; i<sizeof(annot)/sizeof(*annot); i++)
  47     {
  48       if (inf_GetPointer(ifl, annot[i].section, "", (void **)&head))
  49         {
  50           for (chain=head ; chain ; chain=chain->NEXT)
  51             {
  52               om=NULL;
  53               for (ch=(chain_list *)chain->DATA; ch!=NULL; ch=ch->NEXT)
  54                 {
  55                   cl = addchain(NULL,ch->DATA) ;
  56                   chainsig = ttv_getsigbytype_and_netname(tvf,NULL,TTV_SIG_TYPEALL,cl) ;
  57                   freechain(cl);
  58                   for (cl=chainsig; cl!=NULL; cl=cl->NEXT)
  59                     {
  60                       tvs=(ttvsig_list *)cl->DATA;
  61                       ls=rcx_gethtrcxsig( NULL, lf, tvs->NETNAME);
  62                       if (ls!=NULL)
  63                         tvs=ttv_getttvsig_sub(tvf, ls, level, TTV_FIND_LINE | TTV_FIND_MIN | TTV_FIND_MAX);
  64
  65                       if (annot[i].edge=='u') tvn=&tvs->NODE[1];
  66                       else if (annot[i].edge=='d') tvn=&tvs->NODE[0];
  67                       else { tvn=&tvs->NODE[0]; exit(1);}
  68                       if ((pt=getptype(tvn->USER, CTK_MUTEX_PTYPE))!=NULL)
  69                         {
  70                           if (((one_mutex *)pt->DATA)->mutexnum!=num)
  71                             {
  72 /*                              avt_error("stbctk", 1, AVT_ERR, "signal '%s' %s in multiple crosstalk mutex\n", tvs->NETNAME, annot[i].edge=='u'?"rising":"falling"),
  73                               exit(2);*/
  74                               continue;
  75                             }
  76                         }
  77                       else
  78                         {
  79                           if (om==NULL)
  80                             {
  81                               om=(one_mutex *)mbkalloc(sizeof(one_mutex));
  82                               om->mutexnum=num;
  83                               om->mutextype=annot[i].mutextype;
  84                               om->allttvevents=NULL;
  85                               ALL_MUTEX=addchain(ALL_MUTEX, om);
  86                             }
  87                           tvn->USER=addptype(tvn->USER, CTK_MUTEX_PTYPE, om);
  88                           om->allttvevents=addchain(om->allttvevents, tvn);
  89                         }
  90                     }
  91                   freechain(chainsig);
  92                 }
  93               if (om!=NULL) num++;
  94             }
  95         }
  96     }
  97   NB_MUTEX=num;
  98
  99   if( STB_CTK_TAB_MTX )
 100     mbkfree( STB_CTK_TAB_MTX );
 101
 102   STB_CTK_TAB_MTX = mbkalloc( sizeof( tabmtx ) * NB_MUTEX );
 103   for( i=0 ; i<NB_MUTEX ; i++ ) {
 104     STB_CTK_TAB_MTX[i].HEAD = NULL ;
 105     STB_CTK_TAB_MTX[i].MTX  = NULL ;
 106   }
 107
 108   // recursive call for the sons
 109   for(chain = tvf->INS ; chain != NULL ; chain = chain->NEXT)
 110     {
 111       __CtkMutexInit((ttvfig_list *)chain->DATA, num, level) ;
 112     }
 113 }
 114
 115 void CtkMutexInit(ttvfig_list *tvf)
 116 {
 117   __CtkMutexInit(tvf, 0, tvf->INFO->LEVEL);
 118 }
 119
 120 void CtkMutexFree(ttvfig_list *tvf)
 121 {
 122   chain_list *cl, *ch;
 123   ttvevent_list *tev;
 124   one_mutex *om;
 125   for (cl=ALL_MUTEX; cl!=NULL; cl=cl->NEXT)
 126     {
 127       om=(one_mutex *)cl->DATA;
 128       for (ch=om->allttvevents; ch!=NULL; ch=ch->NEXT)
 129         {
 130           tev=(ttvevent_list *)ch->DATA;
 131           if (getptype(tev->USER, CTK_MUTEX_PTYPE)==NULL) exit(8); // temporaire
 132           tev->USER=delptype(tev->USER, CTK_MUTEX_PTYPE);
 133         }
 134       freechain(om->allttvevents);
 135       mbkfree(om);
 136     }
 137   freechain(ALL_MUTEX);
 138   ALL_MUTEX=NULL;
 139   NB_MUTEX=0;
 140
 141   if( STB_CTK_TAB_MTX )
 142     mbkfree( STB_CTK_TAB_MTX );
 143   STB_CTK_TAB_MTX = NULL ;
 144   tvf = NULL;
 145 }
 146
 147 one_mutex *GetCtkMutex(ttvfig_list *tvf, ttvevent_list *tev)
 148 {
 149   ptype_list *pt;
 150   if ((pt=getptype(tev->USER, CTK_MUTEX_PTYPE))!=NULL)
 151     return (one_mutex *)pt->DATA;
 152   return NULL;
 153   tvf=NULL;
 154 }
 155
 156 int GetCtkMutexType(one_mutex *om)
 157 {
 158   return om->mutextype;
 159 }
 160
 161 int GetCtkMutexIdent(one_mutex *om)
 162 {
 163   return om->mutexnum;
 164 }
 165
 166 chain_list* GetCtkMutexEventList(one_mutex *om)
 167 {
 168   return om->allttvevents;
 169 }
 170
 171 int GetCtkMutexNumber(ttvfig_list *tvf)
 172 {
 173   return NB_MUTEX;
 174   tvf = NULL;
 175 }
 176
 177 sortedmutex* stb_ctk_sort_by_mutex( ttvfig_list *tvf, ttvevent_list *victim, chain_list *eventlist )
 178 {
 179   one_mutex       *m ;
 180   sortedmutex     *mutex ;
 181   sortedmutexlist *ml ;
 182   chain_list      *chain ;
 183   num_list        *todo ;
 184   num_list        *num ;
 185   int              n ;
 186   ttvevent_list   *event ;
 187
 188   todo = NULL;
 189
 190   if (ALL_MUTEX!=NULL) {
 191     for( chain = eventlist ; chain ; chain = chain->NEXT ) {
 192
 193       event = (ttvevent_list*)chain->DATA ;
 194
 195       m = GetCtkMutex( tvf, event ) ;
 196
 197       if( m ) {
 198         n = GetCtkMutexIdent( m ) ;
 199         if( STB_CTK_TAB_MTX[n].MTX == NULL )
 200           todo = addnum( todo, n ) ;
 201         STB_CTK_TAB_MTX[n].HEAD = addchain( STB_CTK_TAB_MTX[n].HEAD, event ) ;
 202         STB_CTK_TAB_MTX[n].MTX  = m ;
 203       }
 204     }
 205   }
 206   if( !todo ) {
 207     return NULL ;
 208   }
 209
 210   mutex = (sortedmutex*)addptype( NULL, 0l, NULL );
 211
 212   mutex->MUTEX = GetCtkMutex( tvf, victim );
 213   mutex->NOMUTEX = NULL ;
 214
 215   for( chain = eventlist ; chain ; chain = chain->NEXT ) {
 216     event = (ttvevent_list*)chain->DATA ;
 217     m = GetCtkMutex( tvf, event ) ;
 218     if( !m )
 219       mutex->NOMUTEX = addchain( mutex->NOMUTEX, event );
 220   }
 221
 222   mutex->LIST = NULL ;
 223   for( num = todo ; num ; num = num->NEXT ) {
 224     ml = ( sortedmutexlist* ) addptype( NULL, 0l, NULL );
 225     ml->NEXT = mutex->LIST ;
 226     mutex->LIST = ml ;
 227     ml->MUTEX = STB_CTK_TAB_MTX[num->DATA].MTX ;
 228     ml->LIST  = STB_CTK_TAB_MTX[num->DATA].HEAD ;
 229     STB_CTK_TAB_MTX[num->DATA].MTX  = NULL ;
 230     STB_CTK_TAB_MTX[num->DATA].HEAD = NULL ;
 231   }
 232   freenum(todo);
 233
 234   return mutex ;
 235 }
 236
 237
 238 void stb_ctk_free_sortedmutex( ttvfig_list *tvf, sortedmutex *mutex )
 239 {
 240   sortedmutexlist *ml ;
 241
 242   for( ml = mutex->LIST ; ml ; ml = ml->NEXT )
 243     freechain( ml->LIST );
 244   freeptype( (ptype_list*)mutex->LIST );
 245   freechain( mutex->NOMUTEX );
 246
 247   ((ptype_list*)mutex)->NEXT = NULL ;
 248   freeptype( (ptype_list*)mutex );
 249
 250   tvf=NULL;
 251 }