c.m4.sgi

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

divert(-1)
define(ENDLAB, 5283) dnl
define(SH_MEM, 20000000)

define(SLINIT, `
 {
  $1 = usnewlock (sc_handle);
  if ($1 == NULL) {
    perror ("usnewlock");
    fprintf (stderr, "Error in sync variable $1 creation (handle = 0x%x).\n",
		sc_handle);
    fprintf (stderr, "%d locks created.\n", _num_usnewlocks);
    exit (-1);
  }
  _num_usnewlocks++;
 }')

define(SEMINIT, `
 {
  $1 = usnewsema (sc_handle, $2);
  if ($1 == NULL) {
    perror ("");
    fprintf (stderr, "Error in sync variable $1 creation.\n"); exit (-1);
  }
  if (usinitsema ($1, $2) == -1) {
    perror ("");
    fprintf (stderr, "Error in sync variable $1 initialization.\n"); exit (-1);
  }
 }')
define(SPINLOCK, `
 {
  if (ussetlock ($1) != 1) {
    perror (""); fprintf (stderr, "Lock $1 failed.\n"); exit (-1); 
  }
 }')
define(RELEASELOCK, `{ usunsetlock ($1); }')
define(ENQUEUE, `
 {
  if (uspsema ($1) == -1) {
    perror (""); fprintf (stderr, "Lock $1 failed.\n"); exit (-1); 
  }
 }')
define(DEQUEUE, `{ usvsema ($1); }')

define(SYS_MONINIT, ` 
 {
  int mon_dum1, mon_dum2;

  ifelse(eval($2 > 0),1, `
  for (mon_dum1 = 0; mon_dum1 < $3; mon_dum1++)
    for (mon_dum2 = 0; mon_dum2 < $2; mon_dum2++) {
      $1[mon_dum1].count[mon_dum2] = 0;
      SEMINIT($1[mon_dum1].queue[mon_dum2], 0)
    }' ,,)

  for (mon_dum1 = 0; mon_dum1 < $3; mon_dum1++) 
    SLINIT($1[mon_dum1].lock, 1)
 }')
define(SYS_MENTER, `SPINLOCK($1[$2].lock);')
define(SYS_MENTER2, `SPINLOCK($1.lock);')
define(SYS_DELAY, `
 {
  $1[$3].count[$2]++;
  RELEASELOCK($1[$3].lock)
  ENQUEUE($1[$3].queue[$2]);   
 }')
define(SYS_CONTINUE, `
 {
  if ($1[$3].count[$2]) {
    ($1[$3].count[$2])--;
    DEQUEUE($1[$3].queue[$2])   
  } else
    RELEASELOCK($1[$3].lock)   
  goto `L'ENDLAB;
`LGO'ENDLAB: ;
 }')
define(SYS_MEXIT, `
 {
  RELEASELOCK($1[$2].lock); `L'ENDLAB: ; 
  define(`ENDLAB', eval(ENDLAB+1))
 }')

define(SYS_MEXIT2, `
 {
  RELEASELOCK($1.lock); `L'ENDLAB: ; 
  define(`ENDLAB', eval(ENDLAB+1))
 }')

define(DECVAR, `
  struct $1TYP {                                                    
    ulock_t lock;
    ifelse(eval($2 > 0), 1, `int count[$2]; usema_t *queue[$2];',)
    $4                       
  } $1[$3];
')
    
define(CREATE, `
 {
  int rc;

  fflush (stdout);
  fflush (stderr);
  rc = fork ();
  if (rc == 0)  {
    $1 (); exit (0);
  } else if (rc == -1) {
    perror(""); fprintf (stderr, "failure in create\n"); exit (-1);
  }
  sc_myid++;
 }')

define(CLOCK, `
 {
  if (gettimeofday (&sc_tp, (struct timezone *)0)) {
    perror (""); fprintf (stderr, "error in clock macro\n"); exit (-1); }
  $1 = (sc_tp.tv_sec & 0x7ff)*1000000 + sc_tp.tv_usec;
 }')

define(INCLUDES, `
#include <stdio.h>
#include <sys/types.h>
#include <ulocks.h>
#include <sys/signal.h>
#include <sys/file.h>
#include <sys/time.h>
#include <errno.h>
#include <stdlib.h>
#ifndef w_coredump
#include <sys/wait.h>
#endif
#if defined(c_plusplus) || defined(__cplusplus)
/* #include <osfcn.h> */
extern "C" {
char* share_malloc (unsigned);
void share_malloc_init(unsigned);
void sem_init (int );
void remove_sem();
void remove_shmem();
}
#else
char* share_malloc (unsigned);
void share_malloc_init(unsigned);
void sem_init (int );
void remove_sem();
void remove_shmem();
#endif
void perror (), exit ();
')
define(MAIN_ENV, `
  INCLUDES
  extern int shmem_range_lo, shmem_range_hi;
  int sc_myid = 0;
  usptr_t *sc_handle;
  struct timeval sc_tp;
  int _num_usnewlocks = 0;	/* for counting successful usnewlock() calls */
')
define(EXTERN_ENV, `
  INCLUDES
  extern int shmem_range_lo, shmem_range_hi;
  extern int sc_myid;
  extern usptr_t *sc_handle;
  extern struct timeval sc_tp;
  extern int _num_usnewlocks;
')

define(INITENV, `
 { 
  char filespec[256];
  /* causes problems for c++ compilation -- jev */
  /* unsigned short getuid(); */

  ifelse($2,,,`define(`SH_MEM',$2)')
  share_malloc_init (SH_MEM);
  (void)sprintf (filespec, "/usr/local/lib/tango/locks/%u", getuid());
  /* (void)sprintf (filespec, "/usr/tmp/locks/%u", getuid()); */
  sc_handle = usinit (filespec);
  if (sc_handle == NULL) {
    perror (""); fprintf (stderr, "unable to access lock file %s\n", filespec);
    exit (-1);
  }
  
 }')
define(MAIN_INITENV, `INITENV($1,$2)')
define(MAIN_END, `{ remove_shmem (); exit (ifelse($1,,0,$1));}')

define(NU_MALLOC, `share_malloc ($1);')
define(G_MALLOC, `share_malloc ($1);')
define(NU_FREE, `share_free ($1);')
define(G_FREE, `share_free ($1);')
define(SET_HOME, `{}')

define(WAIT_FOR_END,`{ int i; for (i = 1; i <= $1; i++) wait (0); }')

define(GET_PID,
`{
  $1 = sc_myid;
 }')
define(AUG_OFF, ` ')
define(AUG_ON, ` ')
define(ST_LOG, ` ')
define(ST_INFO_INIT, ` ')
divert(0)
divert(-1)
define(MENTER,
`{
  AUG_OFF
  ST_LOG(ST_MENTER, (int *)&($1[$2].lock));
  SYS_MENTER($1, $2)
  AUG_ON
 }')
    
define(MEXIT,
`{
  AUG_OFF
  ST_LOG(ST_MEXIT, (int *)&($1[$2].lock));
  SYS_MEXIT($1, $2)
  AUG_ON
 }')
    
define(DELAY,
`{
  AUG_OFF
  ST_LOG(ST_DELAY, (int *)&($1[$3].lock));
  SYS_DELAY($1, $2, $3)
  AUG_ON
 }')

define(CONTINUE,
`{
  AUG_OFF
  ST_LOG(ST_CONTINUE, (int *)&($1[$3].lock));
  SYS_CONTINUE($1, $2, $3)
  AUG_ON
 }')

define(MONINIT, 
`{
  AUG_OFF
  SYS_MONINIT($1, $2, $3)
  AUG_ON
 }')

define(BARRIER, 
` {
    register int *lockAddr;

    AUG_OFF
    lockAddr = (int *)&($1[0].lock);
    ST_LOG(ST_BAR_ENTER, lockAddr)
    SYS_MENTER($1, 0)
    if ( $1[0].count[0] < ($2 -1) ) {
	SYS_DELAY($1, 0, 0)
        ST_LOG(ST_BAR_EXIT, lockAddr)
    } else {
        ST_LOG(ST_BAR_EXIT_LAST, lockAddr)
    }
    SYS_CONTINUE($1,0,0)
    SYS_MEXIT($1,0)
    AUG_ON
 }')

define(BARDEC, `DECVAR($1,1,1,)')

define(BARINIT, 
` {
  AUG_OFF
  SYS_MONINIT($1,1,1)
  ST_INFO_INIT($1, ST_BAR_LOCK, &($1[0].lock) )
  ST_INFO_INIT($1, ST_BAR_QUEUE, &($1[0].queue[0]) )
  ST_LOG(ST_BAR_INIT, (int *)&($1[0].lock))
  AUG_ON
 }')

define(GSDEC, `DECVAR($1,1,1,`int sub;')')

define(GSINIT, 
` {
  AUG_OFF
  SYS_MONINIT($1,1,1)
  $1[0].sub = 0;
  ST_INFO_INIT($1, ST_GS_LOCK, &($1[0].lock) )
  ST_INFO_INIT($1, ST_GS_QUEUE, &($1[0].queue[0]) )
  ST_LOG(ST_GS_INIT, (int *)&($1[0].lock))
  AUG_ON
 }')

define(GETSUB, 
` {
  register int *lockAddr;
  AUG_OFF
  lockAddr = (int *)&($1[0].lock);
  ST_LOG(ST_GS_ENTER, lockAddr)
  SYS_MENTER($1, 0);
  if ($1[0].sub <= $3) {
    $2 = $1[0].sub++;
    ST_LOG(ST_GS_EXIT, lockAddr)
  } else {
    $2 = -1;
    if ($1[0].count[0] < ($4 - 1)) {
      SYS_DELAY($1,0,0)
    } else {
      $1[0].sub = 0;
    }
    ST_LOG(ST_GS_EXIT_LAST, lockAddr)
    SYS_CONTINUE($1,0,0)
  }
  SYS_MEXIT($1,0)
  AUG_ON
 }')

define(NU_GSDEC, `DECVAR($1,1,1,`int *s, ssize, sub, mapsize; char *map;')')

define(NU_GSINIT, 
` {
  AUG_OFF
  SYS_MONINIT($1,1,1)
  $1[0].s = NULL;
  $1[0].ssize = 0;
  $1[0].sub = 0;
  $1[0].mapsize = 0;
  $1[0].map = NULL;
  ST_INFO_INIT($1, ST_GS_LOCK, &($1[0].lock) )
  ST_INFO_INIT($1, ST_GS_QUEUE, &($1[0].queue[0]) )
  ST_LOG(ST_GS_INIT, (int *)&($1[0].lock))
  AUG_ON
 }')

define(NU_GETSUB, 
`{
  int *lockAddr, ti;
  AUG_OFF
  lockAddr = (int *)&($1[0].lock);
  ST_LOG(ST_GS_ENTER, lockAddr)
  SYS_MENTER($1, 0);
  if (($1)[0].mapsize < ($3)+1) {
    if (($1)[0].map != NULL)
      share_free (($1)[0].map);
    ($1)[0].map = (char *)nu_share_malloc(sizeof(char)*(($3)+1), PAGE_FORTANGO);
    ($1)[0].mapsize = ($3)+1;
    for (ti = 0; ti <= ($3); ti++) 
      ($1)[0].map[ti] = 0;
  }
  if (($1)[0].ssize < ($4)) {
    if (($1)[0].s != NULL)
      share_free (($1)[0].s);
    ($1)[0].s = (int *)nu_share_malloc(sizeof(int)*($4), PAGE_FORTANGO);
    ($1)[0].ssize = ($4);
    for (ti = 0; ti < ($4); ti++) 
      ($1)[0].s[ti] = 0;
  }
  if (($1)[0].sub <= ($3)) {
    if (($1)[0].s[st_threadID] <= ($3)) {
      ($2) = ($1)[0].s[st_threadID];
      while (($2) <= ($3) && ($1[0].map[$2] || nu_home ((char *)$5) != ($6)))
        ($2)++;
      if (($2) > ($3)) 
        ($2) = ($1)[0].sub;
    } else
      ($2) = ($1)[0].sub;
    ($1)[0].map[$2] = 1;
    while (($1)[0].sub <= ($3) && ($1)[0].map[($1)[0].sub])
      (($1)[0].sub)++;
    while (($1)[0].s[st+threadID] <= ($3) && 
           ($1)[0].map[($1)[0].s[st_threadID]])
      (($1)[0].s[st_threadID])++;
    ST_LOG(ST_GS_EXIT, lockAddr)
  } else {
    $2 = -1;
    if ($1[0].count[0] < ($4 - 1)) {
      SYS_DELAY($1,0,0)
    } else {
      $1[0].sub = 0;
      for (ti = 0; ti < ($4); ti++) 
        ($1)[0].s[ti] = 0;
      for (ti = 0; ti <= ($3); ti++) 
        ($1)[0].map[ti] = 0;
    }
    ST_LOG(ST_GS_EXIT_LAST, lockAddr)
    SYS_CONTINUE($1,0,0)
  }
  SYS_MEXIT($1,0)
  AUG_ON