---

spinlock.c

Go to the documentation of this file.

#ifdef VXWORKS
#include <stdioLib.h>           /* fprintf(), stderr */
#include <sysLib.h>             /* sysClkRateGet() */
#include <taskLib.h>            /* taskLock(), taskUnlock(), taskDelay() */
#include <tickLib.h>            /* tickGet() */

#if 0
/* FIXME: can't include taskLib.h (Where is REG_SET?) */
#include <taskLib.h>            /* taskLock(), taskUnlock(), taskDelay() */
#endif
#else
#include <stdio.h>              /* fprintf(), stderr */
#endif

#include "spinlock.h"
#include "rcs_prnt.hh"          /* rcs_print_error() */

extern int increment_read_status (short int *);
extern int decrement_read_status (short int *);

/* acquire access to a semaphored data buffer */
int
acquire_access (short int *sem, double timeout)
{
  ULONG timeout_ticks, start_ticks, current_ticks, elapsed_ticks;
  if (timeout == 0.0)
    {
      timeout_ticks = 1;
      start_ticks = tickGet ();
      elapsed_ticks = 0;
    }
  else if (timeout > 0.0)
    {
      timeout_ticks = (int) (timeout * sysClkRateGet ());
      start_ticks = tickGet ();
      elapsed_ticks = 0;
    }

  /* loop until timeout_count expires */
  while (elapsed_ticks <= timeout_ticks && (timeout >= 0.0))
    {
      taskLock ();
      if (!increment_read_status (sem))
        {
          return 0;             /* success */
        }
      else
        {
          taskUnlock ();
          taskDelay (1);
          if (timeout >= 0.0)
            {
              current_ticks = tickGet ();
              elapsed_ticks = current_ticks - start_ticks;
            }
        }
    }

  taskUnlock ();
  rcs_print_error ("timed out while acquiring access on semaphore 0x%x\n",
                   (int) sem);
  return -1;                    /* indicate timeout failure */
}

/* release semaphore when done  */
int
release_access (short int *sem, double timeout)
{
  int tst;
  ULONG timeout_ticks, start_ticks, current_ticks, elapsed_ticks;
  timeout_ticks = (ULONG) (timeout * sysClkRateGet ());
  start_ticks = tickGet ();
  elapsed_ticks = 0;

  while (elapsed_ticks <= timeout_ticks)
    {
      tst = decrement_read_status (sem);
      if (tst == 0)
        {
          taskUnlock ();
          return 0;             /* success */
        }
      else
        {
          if (tst < 0)
            {
              taskUnlock ();
              rcs_print_error ("invalid semaphore on 0x%x", (int) sem);
              return -1;        /* invalid semaphore  */
            }
        }
      current_ticks = tickGet ();
      elapsed_ticks = current_ticks - start_ticks;
    }

  taskUnlock ();
  rcs_print_error ("timed out while releasing access on semphore 0x%x",
                   (int) sem);
  return -1;                    /* timeout failure */
}

---