c.m4.sgi

是一个linux下面实现的非阻塞的堆

 }')

define(ADEC, `DECVAR($1,1,1,`int pgdone, pbdone;')')

define(AINIT, 
`{
  AUG_OFF
  SYS_MONINIT($1,1,1)
  $1[0].pgdone = $1[0].pbdone = 0;
  AUG_ON
 }')

/* aSKFOR(name, 0success/1exhaust/-1prog_end/nprob_end, P, getProb, <reset>) */
define(ASKFOR, 
`{
  register int *lockAddr;
  AUG_OFF
  lockAddr = (int *)&($1[0].lock);
  ST_LOG(ST_AS_ENTER, lockAddr)
  SYS_MENTER($1,0)
  if (($1[0].pgdone == 0) && ($1[0].pbdone != 0)) {
    if ($1[0].count[0] < ($3 - 1)) {
      SYS_DELAY($1,0,0)
    }
    ST_LOG(ST_AS_PROBDONE, lockAddr)
  } else {
    $2 = -2;
    while (($1[0].pgdone == 0) && ($1[0].pbdone == 0)) {
      $4
      if ($2 == 0) {
	ST_LOG(ST_AS_GOTTASK, lockAddr)
        SYS_CONTINUE($1,0,0)
      } else {
        if ($1[0].count[0] == ($3 - 1)) {
          $1[0].pbdone = 1;
        } else {
          SYS_DELAY($1,0,0)
	  ST_LOG(ST_AS_WORKWAIT, lockAddr)
        }
      }
    }
  }
  if ($1[0].pgdone != 0) {
    $2 = -1;
    ST_LOG(ST_AS_PROGDONE, lockAddr)
    SYS_CONTINUE($1,0,0)
  } else {
    $2 = $1[0].pbdone;
    if ($1[0].count[0] == 0) {
      $5
      $1[0].pbdone = 0;
    }
    ST_LOG(ST_AS_RESET, lockAddr)
    SYS_CONTINUE($1,0,0)
  }
  SYS_MEXIT($1,0)
  AUG_ON
 }')

define(PROBEND, 
`{
  AUG_OFF
  SYS_MENTER($1,0)
  $1[0].pbdone = $2;
  SYS_MEXIT($1,0)
  AUG_ON
 }')

define(PROGEND, 
`{
  AUG_OFF
  SYS_MENTER($1,0)
  $1[0].pgdone = 1;
  MAIN_END
  SYS_CONTINUE($1,0,0)
  SYS_MEXIT($1,0)
  AUG_ON
 }')

define(LOCKDEC, `DECVAR($1,0,1)')
define(NLOCKDEC, `LOCKDEC($1,$2,$3)')

define(LOCKINIT, 
`{
  AUG_OFF
  SYS_MONINIT($1,0,1)
  ST_INFO_INIT($1, ST_MUTEX, &($1[0].lock) )
  ST_LOG(ST_LOCK_INIT, (int *)&($1[0].lock))
  AUG_ON
 }')
define(NLOCKINIT, `LOCKINIT($1)')

define(LOCK, 
` {
  register int *lockAddr;
  AUG_OFF
  lockAddr = (int *)&($1[0].lock);
  ST_LOG(ST_LOCK_ENTER, lockAddr )
  SYS_MENTER($1,0)
  ST_LOG(ST_LOCK_EXIT, lockAddr )
  AUG_ON
 }')
define(NLOCK, `LOCK($1)')

/* note, should log before exit to ensure lock addr expression valid */
define(UNLOCK, 
` {
  register int *lockAddr;
  AUG_OFF
  lockAddr = (int *)&($1[0].lock);
  ST_LOG(ST_UNLOCK, lockAddr )
  SYS_MEXIT($1,0)
  AUG_ON
 }')
define(NUNLOCK, `UNLOCK($1)')

define(ALOCKDEC, `DECVAR($1,0,$2)')

define(ALOCKINIT, 
`{
  int smacs_dum1;
  for (smacs_dum1=0; smacs_dum1 < $2; smacs_dum1++) {
    ST_INFO_INIT($1, ST_MUTEX_ARRAY, &($1[smacs_dum1].lock) )
    ST_LOG(ST_LOCK_INIT, (int *)&($1[smacs_dum1].lock))
  }
  SYS_MONINIT($1,0,$2)
 }')

define(ALOCK, 
`{  
  register int *lockAddr;
  AUG_OFF
  lockAddr = (int *)&($1[$2].lock) ;
  ST_LOG(ST_ALOCK_ENTER, lockAddr )
  SYS_MENTER($1,$2)
  ST_LOG(ST_ALOCK_EXIT, lockAddr )
  AUG_ON
 }')

define(AULOCK, 
`{  
  register int *lockAddr;
  AUG_OFF
  lockAddr = (int *)&($1[$2].lock);
  ST_LOG(ST_AULOCK, lockAddr )
  SYS_MEXIT($1,$2)
  AUG_ON
 }')

define(ALOCK2, 
`{  
  register int *lockAddr;
  AUG_OFF
  lockAddr = (int *)&($1.lock) ;
  ST_LOG(ST_ALOCK_ENTER, lockAddr )
  SYS_MENTER2($1)
  ST_LOG(ST_ALOCK_EXIT, lockAddr )
  AUG_ON
 }')

define(AULOCK2, 
`{  
  register int *lockAddr;
  AUG_OFF
  lockAddr = (int *)&($1.lock);
  ST_LOG(ST_AULOCK, lockAddr )
  SYS_MEXIT2($1)
  AUG_ON
 }')

define(PAUSEDEC, `DECVAR($1,2,ifelse($2,,1,$2),int flag;)')

define(PAUSEINIT,
`{
  int p_dummy;
  AUG_OFF
  for (p_dummy = 0; (p_dummy < ifelse($2,,1,$2)); p_dummy++)
    $1[p_dummy].flag = 0;
  SYS_MONINIT($1,2,ifelse($2,,1,$2))
  AUG_ON
 }')

define(CLEARPAUSE,
`{
  register int *lockAddr;

  AUG_OFF
  lockAddr = (int *)&($1[ifelse($2,,0,$2)].lock);
  ST_LOG(ST_EVENT_ENTER, lockAddr )
  SYS_MENTER($1,ifelse($2,,0,$2))
  $1[ifelse($2,,0,$2)].flag = 0;
  SYS_CONTINUE($1,0,ifelse($2,,0,$2))
  SYS_MEXIT($1,ifelse($2,,0,$2))
  ST_LOG(ST_EVENT_EXIT, lockAddr)
  AUG_ON
 }')

define(SETPAUSE,
`{
  register int *lockAddr;

  AUG_OFF
  lockAddr = (int *)&($1[ifelse($2,,0,$2)].lock);
  ST_LOG(ST_EVENT_ENTER, lockAddr )
  SYS_MENTER($1,ifelse($2,,0,$2))
  $1[ifelse($2,,0,$2)].flag = 1;
  SYS_CONTINUE($1,0,ifelse($2,,0,$2))
  SYS_MEXIT($1,ifelse($2,,0,$2))
  ST_LOG(ST_EVENT_EXIT, lockAddr)
  AUG_ON
 }')

define(EVENT,
`{
  register int *lockAddr;
  AUG_OFF
  lockAddr = (int *)&($1[ifelse($2,,0,$2)].lock);
  ST_LOG(ST_EVENT_ENTER, lockAddr )
  SYS_MENTER($1,ifelse($2,,0,$2))
  if ($1[ifelse($2,,0,$2)].flag) {
    SYS_DELAY($1,0,ifelse($2,,0,$2))
  }
  $1[ifelse($2,,0,$2)].flag = 1;
  SYS_CONTINUE($1,1,ifelse($2,,0,$2))
  SYS_MEXIT($1,ifelse($2,,0,$2))
  ST_LOG(ST_EVENT_EXIT, lockAddr)
  AUG_ON
 }')

define(WAITPAUSE,
`{
  register int *lockAddr;

  AUG_OFF
  lockAddr = (int *)&($1[ifelse($2,,0,$2)].lock);
  ST_LOG(ST_PAUSE_ENTER,lockAddr)
  SYS_MENTER($1,ifelse($2,,0,$2))
  if (!$1[ifelse($2,,0,$2)].flag) {
    SYS_DELAY($1,0,ifelse($2,,0,$2))
  }
  SYS_CONTINUE($1,0,ifelse($2,,0,$2))
  SYS_MEXIT($1,ifelse($2,,0,$2))
  ST_LOG(ST_PAUSE_EXIT,lockAddr)
  AUG_ON
 }')

define(PAUSE,
`{
  register int *lockAddr;
  AUG_OFF
  lockAddr = (int *)&($1[ifelse($2,,0,$2)].lock);
  ST_LOG(ST_PAUSE_ENTER, lockAddr )
  SYS_MENTER($1,ifelse($2,,0,$2))
  if (!$1[ifelse($2,,0,$2)].flag) {
    SYS_DELAY($1,1,ifelse($2,,0,$2))
  }
  $1[ifelse($2,,0,$2)].flag = 0;
  SYS_CONTINUE($1,0,ifelse($2,,0,$2))
  SYS_MEXIT($1,ifelse($2,,0,$2))
  ST_LOG(ST_PAUSE_EXIT, lockAddr )
  AUG_ON
 }')

define(SRDEC, `DECVAR($1,2,ifelse($2,,1,$2),int flag;)')

define(SRINIT,
`{
  int s_dummy;
  AUG_OFF
  for (s_dummy = 0; (s_dummy < ifelse($2,,1,$2)); s_dummy++)
    $1[s_dummy].flag = 0;
  SYS_MONINIT($1,2,ifelse($2,,1,$2))
  AUG_ON
 }')

define(SEND,
`{
  register int *lockAddr;
  AUG_OFF
  lockAddr = (int *)&($1[ifelse($3,,0,$3)].lock);
  ST_LOG(ST_SEND_ENTER, lockAddr )
  SYS_MENTER($1,ifelse($3,,0,$3))
  if ($1[ifelse($3,,0,$3)].flag) {
    SYS_DELAY($1,0,ifelse($3,,0,$3))
  }
  $2
  $1[ifelse($3,,0,$3)].flag = 1;
  SYS_CONTINUE($1,1,ifelse($3,,0,$3))
  SYS_MEXIT($1,ifelse($3,,0,$3))
  ST_LOG(ST_SEND_EXIT, lockAddr)
  AUG_ON
 }')

define(RECEIVE,
`{
  register int *lockAddr;
  AUG_OFF
  lockAddr = (int *)&($1[ifelse($3,,0,$3)].lock);
  ST_LOG(ST_RECEIVE_ENTER, lockAddr )
  SYS_MENTER($1,ifelse($3,,0,$3))
  if (!$1[ifelse($3,,0,$3)].flag) {
    SYS_DELAY($1,1,ifelse($3,,0,$3))
  }
  $2
  $1[ifelse($3,,0,$3)].flag = 0;
  SYS_CONTINUE($1,0,ifelse($3,,0,$3))
  SYS_MEXIT($1,ifelse($3,,0,$3))
  ST_LOG(ST_RECEIVE_EXIT, lockAddr)
  AUG_ON
 }')

define(HSEND,
`{
  register int *lockAddr;
  AUG_OFF
  lockAddr = (int *)&($1[ifelse($3,,0,$3)].lock);
  ST_LOG(ST_HSEND_ENTER, lockAddr)
  SYS_MENTER($1,ifelse($4,,0,$4))
  if ($1[ifelse($4,,0,$4)].flag) {
    SYS_DELAY($1,0,ifelse($4,,0,$4))
  }
  $3
  $1[ifelse($4,,0,$4)].flag = $2;
  SYS_CONTINUE($1,1,ifelse($4,,0,$4))
  SYS_MEXIT($1,ifelse($4,,0,$4))
  ST_LOG(ST_HSEND_EXIT, lockAddr)
  AUG_ON
 }')

define(HRECEIVE,
`{
  register int *lockAddr;
  AUG_OFF
  lockAddr = (int *)&($1[ifelse($3,,0,$3)].lock);
  ST_LOG(ST_HRECEIVE_ENTER, lockAddr )
  SYS_MENTER($1,ifelse($4,,0,$4))
  while ((!($1[ifelse($4,,0,$4)].flag)) ||
               ($1[ifelse($4,,0,$4)].flag == $2)) {
    SYS_DELAY($1,1,ifelse($4,,0,$4))
  }
  $3
  $1[ifelse($4,,0,$4)].flag = 0;
  SYS_CONTINUE($1,0,ifelse($4,,0,$4))
  SYS_MEXIT($1,ifelse($4,,0,$4))
  ST_LOG(ST_HRECEIVE_EXIT, lockAddr ) 
  AUG_ON
 }')

define(DYNMASK, `0xffff')

define(TASKDEC, `DECTVAR($1)')

define(TASKINIT,
`{
  AUG_OFF
  if (spy_gm->taskTblIndex < MAXTASKS) {
    (spy_gm->taskTbl[spy_gm->taskTblIndex]).name = "$1";
    $1[0].addr = (int *) (spy_gm->taskTblIndex << 16);
    ++(spy_gm->taskTblIndex);
  } else {
    fprintf(stderr,"Too many tasks\n"); exit(-2);
  }
  ST_LOG(ST_TASK_INIT, (char *) $1[0].addr)
  AUG_ON
 }')

define(BEGINTASK,
`{
  AUG_OFF
  ST_LOG(ST_BEGINTASK, ((int) $1[0].addr | (($2) & DYNMASK)))
  AUG_ON
 }')

define(ENDTASK,
`{
  AUG_OFF
  ST_LOG(ST_ENDTASK, ((int) $1[0].addr | (($2) & DYNMASK)))
  AUG_ON
 }')

divert(0)