semian 0.6.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5f129376bb8de391e650f09c9c5bd7fdc0b59522
-  data.tar.gz: fb49ab21418fc18bf30c20b79c510c1db310a015
+  metadata.gz: 9844c9c807927ab334939c439c4de127033f5189
+  data.tar.gz: 5bb4675179a75c585cd05206dbdbf2777002f403
 SHA512:
-  metadata.gz: 4dbfd5d330c92ab3c3bb74a6b0b083903a5aaec0453423d05c53e9ef615125e76e3c5578a5b3b23975916261915ab7e2a5b0707312173f166b6508bd7acfa5c3
-  data.tar.gz: 2cb0dc4d9765fa70cd7fd7572a532306aba89a4cea16c228634874c1e0ccc12776661c2e9579e284a874d9f47eb25dbee1ac192ef4b1f06bf7e3c94c79da1b79
+  metadata.gz: 9331e3c0cdd6c41084d9e7a1ec4ed74914ad6b73ec2b7bd90f22b6a9aebb5ec296ca1995c1a02ff28168c73797f7789c4cdbc35f7bdecb39b89faaf284194379
+  data.tar.gz: 12949dc756b01c369844e6742cebf49626ad1af9a1eb37233e2c4aad4dc5ba4faeb8f9260563fd617e93605870f7ad94acf0a9720dfd6feaf68036a1ca264905

data/ext/semian/resource.c

@@ -0,0 +1,257 @@
+#include "resource.h"
+
+static VALUE
+cleanup_semian_resource_acquire(VALUE self);
+
+static int
+check_tickets_arg(VALUE tickets);
+
+static long
+check_permissions_arg(VALUE permissions);
+
+static const
+char *check_id_arg(VALUE id);
+
+static double
+check_default_timeout_arg(VALUE default_timeout);
+
+static void
+ms_to_timespec(long ms, struct timespec *ts);
+
+static const rb_data_type_t
+semian_resource_type;
+
+VALUE
+semian_resource_acquire(int argc, VALUE *argv, VALUE self)
+{
+  semian_resource_t *self_res = NULL;
+  semian_resource_t res = { 0 };
+
+  if (!rb_block_given_p()) {
+    rb_raise(rb_eArgError, "acquire requires a block");
+  }
+
+  TypedData_Get_Struct(self, semian_resource_t, &semian_resource_type, self_res);
+  res = *self_res;
+
+  /* allow the default timeout to be overridden by a "timeout" param */
+  if (argc == 1 && TYPE(argv[0]) == T_HASH) {
+    VALUE timeout = rb_hash_aref(argv[0], ID2SYM(id_timeout));
+    if (TYPE(timeout) != T_NIL) {
+      if (TYPE(timeout) != T_FLOAT && TYPE(timeout) != T_FIXNUM) {
+        rb_raise(rb_eArgError, "timeout parameter must be numeric");
+      }
+      ms_to_timespec(NUM2DBL(timeout) * 1000, &res.timeout);
+    }
+  } else if (argc > 0) {
+    rb_raise(rb_eArgError, "invalid arguments");
+  }
+
+  /* release the GVL to acquire the semaphore */
+  WITHOUT_GVL(acquire_semaphore_without_gvl, &res, RUBY_UBF_IO, NULL); // FIXME - replace with wrapped version
+  if (res.error != 0) {
+    if (res.error == EAGAIN) {
+      rb_raise(eTimeout, "timed out waiting for resource '%s'", res.name);
+    } else {
+      raise_semian_syscall_error("semop()", res.error);
+    }
+  }
+
+  return rb_ensure(rb_yield, self, cleanup_semian_resource_acquire, self);
+}
+
+VALUE
+semian_resource_destroy(VALUE self)
+{
+  semian_resource_t *res = NULL;
+
+  TypedData_Get_Struct(self, semian_resource_t, &semian_resource_type, res);
+  if (semctl(res->sem_id, SI_NUM_SEMAPHORES, IPC_RMID) == -1) {
+    raise_semian_syscall_error("semctl()", errno);
+  }
+
+  return Qtrue;
+}
+
+VALUE
+semian_resource_count(VALUE self)
+{
+  int ret;
+  semian_resource_t *res = NULL;
+
+  TypedData_Get_Struct(self, semian_resource_t, &semian_resource_type, res);
+  ret = semctl(res->sem_id, SI_SEM_TICKETS, GETVAL);
+  if (ret == -1) {
+    raise_semian_syscall_error("semctl()", errno);
+  }
+
+  return LONG2FIX(ret);
+}
+
+VALUE
+semian_resource_id(VALUE self)
+{
+  semian_resource_t *res = NULL;
+  TypedData_Get_Struct(self, semian_resource_t, &semian_resource_type, res);
+  return LONG2FIX(res->sem_id);
+}
+
+VALUE
+semian_resource_initialize(VALUE self, VALUE id, VALUE tickets, VALUE permissions, VALUE default_timeout)
+{
+  key_t key;
+  int c_permissions;
+  double c_timeout;
+  int c_tickets;
+  int created = 0;
+  semian_resource_t *res = NULL;
+  const char *c_id_str = NULL;
+
+  // Check and cast arguments
+  c_tickets = check_tickets_arg(tickets);
+  c_permissions = check_permissions_arg(permissions);
+  c_id_str = check_id_arg(id);
+  c_timeout = check_default_timeout_arg(default_timeout);
+
+  // Build semian resource structure
+  TypedData_Get_Struct(self, semian_resource_t, &semian_resource_type, res);
+
+  // Populate struct fields
+  ms_to_timespec(c_timeout * 1000, &res->timeout);
+  res->name = strdup(c_id_str);
+
+  // Get or create semaphore set
+  //  note that tickets = 0 will be used to acquire a semaphore set after it's been created elswhere
+  key = generate_key(c_id_str);
+  res->sem_id = c_tickets == 0 ? get_semaphore(key) : create_semaphore(key, c_permissions, &created);
+  if (res->sem_id == -1) {
+    raise_semian_syscall_error("semget()", errno);
+  }
+
+  set_semaphore_permissions(res->sem_id, c_permissions);
+
+  // Configure semaphore ticket counts
+  configure_tickets(res->sem_id, c_tickets, created);
+
+  return self;
+}
+
+VALUE
+semian_resource_alloc(VALUE klass)
+{
+  semian_resource_t *res;
+  VALUE obj = TypedData_Make_Struct(klass, semian_resource_t, &semian_resource_type, res);
+  return obj;
+}
+
+static VALUE
+cleanup_semian_resource_acquire(VALUE self)
+{
+  semian_resource_t *res = NULL;
+  TypedData_Get_Struct(self, semian_resource_t, &semian_resource_type, res);
+  if (perform_semop(res->sem_id, SI_SEM_TICKETS, 1, SEM_UNDO, NULL) == -1) {
+    res->error = errno;
+  }
+  return Qnil;
+}
+
+static long
+check_permissions_arg(VALUE permissions)
+{
+  Check_Type(permissions, T_FIXNUM);
+  return FIX2LONG(permissions);
+}
+
+static int
+check_tickets_arg(VALUE tickets)
+{
+  int c_tickets;
+
+  if (TYPE(tickets) != T_NIL) {
+    if (TYPE(tickets) == T_FLOAT) {
+      rb_warn("semian ticket value %f is a float, converting to fixnum", RFLOAT_VALUE(tickets));
+      tickets = INT2FIX((int) RFLOAT_VALUE(tickets));
+    }
+    Check_Type(tickets, T_FIXNUM);
+
+    if (FIX2LONG(tickets) < 0 || FIX2LONG(tickets) > system_max_semaphore_count) {
+      rb_raise(rb_eArgError, "ticket count must be a non-negative value and less than %d", system_max_semaphore_count);
+    }
+    c_tickets = FIX2LONG(tickets);
+  } else {
+    c_tickets = -1;
+  }
+
+  return c_tickets;
+}
+
+static const char*
+check_id_arg(VALUE id)
+{
+  const char *c_id_str = NULL;
+
+  if (TYPE(id) != T_SYMBOL && TYPE(id) != T_STRING) {
+    rb_raise(rb_eTypeError, "id must be a symbol or string");
+  }
+  if (TYPE(id) == T_SYMBOL) {
+    c_id_str = rb_id2name(rb_to_id(id));
+  } else if (TYPE(id) == T_STRING) {
+    c_id_str = RSTRING_PTR(id);
+  }
+
+  return c_id_str;
+}
+
+static double
+check_default_timeout_arg(VALUE default_timeout)
+{
+  if (TYPE(default_timeout) != T_FIXNUM && TYPE(default_timeout) != T_FLOAT) {
+    rb_raise(rb_eTypeError, "expected numeric type for default_timeout");
+  }
+
+  if (NUM2DBL(default_timeout) < 0) {
+    rb_raise(rb_eArgError, "default timeout must be non-negative value");
+  }
+  return NUM2DBL(default_timeout);
+}
+
+static void
+ms_to_timespec(long ms, struct timespec *ts)
+{
+  ts->tv_sec = ms / 1000;
+  ts->tv_nsec = (ms % 1000) * 1000000;
+}
+
+static inline void
+semian_resource_mark(void *ptr)
+{
+  /* noop */
+}
+
+static inline void
+semian_resource_free(void *ptr)
+{
+  semian_resource_t *res = (semian_resource_t *) ptr;
+  if (res->name) {
+    free(res->name);
+    res->name = NULL;
+  }
+  xfree(res);
+}
+
+static inline size_t
+semian_resource_memsize(const void *ptr)
+{
+  return sizeof(semian_resource_t);
+}
+
+static const rb_data_type_t
+semian_resource_type = {
+  "semian_resource",
+  {
+    semian_resource_mark,
+    semian_resource_free,
+    semian_resource_memsize
+  },
+  NULL, NULL, RUBY_TYPED_FREE_IMMEDIATELY
+};

data/ext/semian/resource.h

@@ -0,0 +1,75 @@
+/*
+For core semian resource functions exposed directly to ruby.
+
+Functions here are associated with rubyland operations.
+*/
+
+#ifndef SEMIAN_RESOURCE_H
+#define SEMIAN_RESOURCE_H
+
+#include "semian.h" // FIXME remove this once temporary declarations are removed
+#include "types.h"
+
+// Ruby variables
+ID id_timeout;
+int system_max_semaphore_count;
+
+/*
+ * call-seq:
+ *    Semian::Resource.new(id, tickets, permissions, default_timeout) -> resource
+ *
+ * Creates a new Resource. Do not create resources directly. Use Semian.register.
+ */
+VALUE
+semian_resource_initialize(VALUE self, VALUE id, VALUE tickets, VALUE permissions, VALUE default_timeout);
+
+/*
+ * call-seq:
+ *    resource.acquire(timeout: default_timeout) { ... }  -> result of the block
+ *
+ * Acquires a resource. The call will block for <code>timeout</code> seconds if a ticket
+ * is not available. If no ticket is available within the timeout period, Semian::TimeoutError
+ * will be raised.
+ *
+ * If no timeout argument is provided, the default timeout passed to Semian.register will be used.
+ *
+ */
+VALUE
+semian_resource_acquire(int argc, VALUE *argv, VALUE self);
+
+/*
+ * call-seq:
+ *   resource.destroy() -> true
+ *
+ * Destroys a resource. This method will destroy the underlying SysV semaphore.
+ * If there is any code in other threads or processes blocking or using the resource
+ * they will likely raise.
+ *
+ * Use this method very carefully.
+ */
+VALUE
+semian_resource_destroy(VALUE self);
+
+/*
+ * call-seq:
+ *    resource.count -> count
+ *
+ * Returns the current ticket count for a resource.
+ */
+VALUE
+semian_resource_count(VALUE self);
+
+/*
+ * call-seq:
+ *    resource.semid -> id
+ *
+ * Returns the SysV semaphore id of a resource.
+ */
+VALUE
+semian_resource_id(VALUE self);
+
+// Allocate a semian_resource_type struct for ruby memory management
+VALUE
+semian_resource_alloc(VALUE klass);
+
+#endif //SEMIAN_RESOURCE_H

data/ext/semian/semian.c

@@ -1,122 +1,40 @@
-#include <sys/types.h>
-#include <sys/ipc.h>
-#include <sys/sem.h>
-#include <sys/time.h>
-#include <errno.h>
-#include <string.h>
-
-#include <ruby.h>
-#include <ruby/util.h>
-#include <ruby/io.h>
-
-#include <openssl/sha.h>
-
-#include <stdio.h>
-
-union semun {
-  int              val;    /* Value for SETVAL */
-  struct semid_ds *buf;    /* Buffer for IPC_STAT, IPC_SET */
-  unsigned short  *array;  /* Array for GETALL, SETALL */
-  struct seminfo  *__buf;  /* Buffer for IPC_INFO
-                             (Linux-specific) */
-};
-
-#if defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL) && defined(HAVE_RUBY_THREAD_H)
-// 2.0
-#include <ruby/thread.h>
-#define WITHOUT_GVL(fn,a,ubf,b) rb_thread_call_without_gvl((fn),(a),(ubf),(b))
-#elif defined(HAVE_RB_THREAD_BLOCKING_REGION)
- // 1.9
-typedef VALUE (*my_blocking_fn_t)(void*);
-#define WITHOUT_GVL(fn,a,ubf,b) rb_thread_blocking_region((my_blocking_fn_t)(fn),(a),(ubf),(b))
-#endif
-
-static ID id_timeout;
-static VALUE eSyscall, eTimeout, eInternal;
-static int system_max_semaphore_count;
-
-static const int kIndexTickets = 0;
-static const int kIndexTicketMax = 1;
-static const int kIndexLock = 2;
-
-static const int kNumSemaphores = 3;
-
-typedef struct {
-  int sem_id;
-  struct timespec timeout;
-  int error;
-  char *name;
-} semian_resource_t;
-
-static key_t
+#include "semian.h"
+
+// Time to wait for timed ops to complete
+#define INTERNAL_TIMEOUT 5 // seconds
+
+key_t
 generate_key(const char *name)
 {
+  char semset_size_key[20];
+  char *uniq_id_str;
+
+  // It is necessary for the cardinatily of the semaphore set to be part of the key
+  // or else sem_get will complain that we have requested an incorrect number of sems
+  // for the desired key, and have changed the number of semaphores for a given key
+  sprintf(semset_size_key, "_NUM_SEMS_%d", SI_NUM_SEMAPHORES);
+  uniq_id_str = malloc(strlen(name)+strlen(semset_size_key)+1);
+  strcpy(uniq_id_str, name);
+  strcat(uniq_id_str, semset_size_key);
+
   union {
     unsigned char str[SHA_DIGEST_LENGTH];
     key_t key;
   } digest;
-  SHA1((const unsigned char *) name, strlen(name), digest.str);
+  SHA1((const unsigned char *) uniq_id_str, strlen(uniq_id_str), digest.str);
+  free(uniq_id_str);
   /* TODO: compile-time assertion that sizeof(key_t) > SHA_DIGEST_LENGTH */
   return digest.key;
 }
 
-static void
-ms_to_timespec(long ms, struct timespec *ts)
-{
-  ts->tv_sec = ms / 1000;
-  ts->tv_nsec = (ms % 1000) * 1000000;
-}
-
-static void
+void
 raise_semian_syscall_error(const char *syscall, int error_num)
 {
   rb_raise(eSyscall, "%s failed, errno: %d (%s)", syscall, error_num, strerror(error_num));
 }
 
-static void
-semian_resource_mark(void *ptr)
-{
-  /* noop */
-}
-
-static void
-semian_resource_free(void *ptr)
-{
-  semian_resource_t *res = (semian_resource_t *) ptr;
-  if (res->name) {
-    free(res->name);
-    res->name = NULL;
-  }
-  xfree(res);
-}
-
-static size_t
-semian_resource_memsize(const void *ptr)
-{
-  return sizeof(semian_resource_t);
-}
-
-static const rb_data_type_t
-semian_resource_type = {
-  "semian_resource",
-  {
-    semian_resource_mark,
-    semian_resource_free,
-    semian_resource_memsize
-  },
-  NULL, NULL, RUBY_TYPED_FREE_IMMEDIATELY
-};
-
-static VALUE
-semian_resource_alloc(VALUE klass)
-{
-  semian_resource_t *res;
-  VALUE obj = TypedData_Make_Struct(klass, semian_resource_t, &semian_resource_type, res);
-  return obj;
-}
-
-static void
-set_semaphore_permissions(int sem_id, int permissions)
+void
+set_semaphore_permissions(int sem_id, long permissions)
 {
   union semun sem_opts;
   struct semid_ds stat_buf;
@@ -135,14 +53,14 @@ static const int kInternalTimeout = 5; /* seconds */
 static int
 get_max_tickets(int sem_id)
 {
-  int ret = semctl(sem_id, kIndexTicketMax, GETVAL);
+  int ret = semctl(sem_id, SI_SEM_CONFIGURED_TICKETS, GETVAL);
   if (ret == -1) {
     rb_raise(eInternal, "error getting max ticket count, errno: %d (%s)", errno, strerror(errno));
   }
   return ret;
 }
 
-static int
+int
 perform_semop(int sem_id, short index, short op, short flags, struct timespec *ts)
 {
   struct sembuf buf = { 0 };
@@ -158,11 +76,6 @@ perform_semop(int sem_id, short index, short op, short flags, struct timespec *t
   }
 }
 
-typedef struct {
-  int sem_id;
-  int tickets;
-} update_ticket_count_t;
-
 static VALUE
 update_ticket_count(update_ticket_count_t *tc)
 {
@@ -173,11 +86,11 @@ update_ticket_count(update_ticket_count_t *tc)
   if (get_max_tickets(tc->sem_id) != tc->tickets) {
     delta = tc->tickets - get_max_tickets(tc->sem_id);
 
-    if (perform_semop(tc->sem_id, kIndexTickets, delta, 0, &ts) == -1) {
+    if (perform_semop(tc->sem_id, SI_SEM_TICKETS, delta, 0, &ts) == -1) {
       rb_raise(eInternal, "error setting ticket count, errno: %d (%s)", errno, strerror(errno));
     }
 
-    if (semctl(tc->sem_id, kIndexTicketMax, SETVAL, tc->tickets) == -1) {
+    if (semctl(tc->sem_id, SI_SEM_CONFIGURED_TICKETS, SETVAL, tc->tickets) == -1) {
       rb_raise(eInternal, "error updating max ticket count, errno: %d (%s)", errno, strerror(errno));
     }
   }
@@ -185,18 +98,18 @@ update_ticket_count(update_ticket_count_t *tc)
   return Qnil;
 }
 
-static void
+void
 configure_tickets(int sem_id, int tickets, int should_initialize)
 {
   struct timespec ts = { 0 };
-  unsigned short init_vals[kNumSemaphores];
+  unsigned short init_vals[SI_NUM_SEMAPHORES];
   struct timeval start_time, cur_time;
   update_ticket_count_t tc;
   int state;
 
   if (should_initialize) {
-    init_vals[kIndexTickets] = init_vals[kIndexTicketMax] = tickets;
-    init_vals[kIndexLock] = 1;
+    init_vals[SI_SEM_TICKETS] = init_vals[SI_SEM_CONFIGURED_TICKETS] = tickets;
+    init_vals[SI_SEM_LOCK] = 1;
     if (semctl(sem_id, 0, SETALL, init_vals) == -1) {
       raise_semian_syscall_error("semctl()", errno);
     }
@@ -222,7 +135,7 @@ configure_tickets(int sem_id, int tickets, int should_initialize)
     if (get_max_tickets(sem_id) != tickets) {
       ts.tv_sec = kInternalTimeout;
 
-      if (perform_semop(sem_id, kIndexLock, -1, SEM_UNDO, &ts) == -1) {
+      if (perform_semop(sem_id, SI_SEM_LOCK, -1, SEM_UNDO, &ts) == -1) {
         raise_semian_syscall_error("error acquiring internal semaphore lock, semtimedop()", errno);
       }
 
@@ -230,7 +143,7 @@ configure_tickets(int sem_id, int tickets, int should_initialize)
       tc.tickets = tickets;
       rb_protect((VALUE (*)(VALUE)) update_ticket_count, (VALUE) &tc, &state);
 
-      if (perform_semop(sem_id, kIndexLock, 1, SEM_UNDO, NULL) == -1) {
+      if (perform_semop(sem_id, SI_SEM_LOCK, 1, SEM_UNDO, NULL) == -1) {
         raise_semian_syscall_error("error releasing internal semaphore lock, semop()", errno);
       }
 
@@ -241,214 +154,40 @@ configure_tickets(int sem_id, int tickets, int should_initialize)
   }
 }
 
-static int
-create_semaphore(int key, int permissions, int *created)
+int
+create_semaphore(int key, long permissions, int *created)
 {
   int semid = 0;
   int flags = 0;
 
   *created = 0;
-  flags = IPC_EXCL | IPC_CREAT | FIX2LONG(permissions);
+  flags = IPC_EXCL | IPC_CREAT | permissions;
 
-  semid = semget(key, kNumSemaphores, flags);
+  semid = semget(key, SI_NUM_SEMAPHORES, flags);
   if (semid >= 0) {
     *created = 1;
   } else if (semid == -1 && errno == EEXIST) {
     flags &= ~IPC_EXCL;
-    semid = semget(key, kNumSemaphores, flags);
+    semid = semget(key, SI_NUM_SEMAPHORES, flags);
   }
   return semid;
 }
 
-static int
-get_semaphore(int key)
-{
-  return semget(key, kNumSemaphores, 0);
-}
-
-/*
- * call-seq:
- *    Semian::Resource.new(id, tickets, permissions, default_timeout) -> resource
- *
- * Creates a new Resource. Do not create resources directly. Use Semian.register.
- */
-static VALUE
-semian_resource_initialize(VALUE self, VALUE id, VALUE tickets, VALUE permissions, VALUE default_timeout)
-{
-  key_t key;
-  int created = 0;
-  semian_resource_t *res = NULL;
-  const char *id_str = NULL;
-
-  if (TYPE(id) != T_SYMBOL && TYPE(id) != T_STRING) {
-    rb_raise(rb_eTypeError, "id must be a symbol or string");
-  }
-  if (TYPE(tickets) == T_FLOAT) {
-    rb_warn("semian ticket value %f is a float, converting to fixnum", RFLOAT_VALUE(tickets));
-    tickets = INT2FIX((int) RFLOAT_VALUE(tickets));
-  }
-  Check_Type(tickets, T_FIXNUM);
-  Check_Type(permissions, T_FIXNUM);
-  if (TYPE(default_timeout) != T_FIXNUM && TYPE(default_timeout) != T_FLOAT) {
-    rb_raise(rb_eTypeError, "expected numeric type for default_timeout");
-  }
-  if (FIX2LONG(tickets) < 0 || FIX2LONG(tickets) > system_max_semaphore_count) {
-    rb_raise(rb_eArgError, "ticket count must be a non-negative value and less than %d", system_max_semaphore_count);
-  }
-  if (NUM2DBL(default_timeout) < 0) {
-    rb_raise(rb_eArgError, "default timeout must be non-negative value");
-  }
-
-  if (TYPE(id) == T_SYMBOL) {
-    id_str = rb_id2name(rb_to_id(id));
-  } else if (TYPE(id) == T_STRING) {
-    id_str = RSTRING_PTR(id);
-  }
-  TypedData_Get_Struct(self, semian_resource_t, &semian_resource_type, res);
-  key = generate_key(id_str);
-  ms_to_timespec(NUM2DBL(default_timeout) * 1000, &res->timeout);
-  res->name = strdup(id_str);
-
-  res->sem_id = FIX2LONG(tickets) == 0 ? get_semaphore(key) : create_semaphore(key, permissions, &created);
-  if (res->sem_id == -1) {
-    raise_semian_syscall_error("semget()", errno);
-  }
-
-  configure_tickets(res->sem_id, FIX2LONG(tickets), created);
-
-  set_semaphore_permissions(res->sem_id, FIX2LONG(permissions));
-
-  return self;
-}
-
-static VALUE
-cleanup_semian_resource_acquire(VALUE self)
-{
-  semian_resource_t *res = NULL;
-  TypedData_Get_Struct(self, semian_resource_t, &semian_resource_type, res);
-  if (perform_semop(res->sem_id, kIndexTickets, 1, SEM_UNDO, NULL) == -1) {
-    res->error = errno;
-  }
-  return Qnil;
-}
-
-static void *
+void *
 acquire_semaphore_without_gvl(void *p)
 {
   semian_resource_t *res = (semian_resource_t *) p;
   res->error = 0;
-  if (perform_semop(res->sem_id, kIndexTickets, -1, SEM_UNDO, &res->timeout) == -1) {
+  if (perform_semop(res->sem_id, SI_SEM_TICKETS, -1, SEM_UNDO, &res->timeout) == -1) {
     res->error = errno;
   }
   return NULL;
 }
 
-/*
- * call-seq:
- *    resource.acquire(timeout: default_timeout) { ... }  -> result of the block
- *
- * Acquires a resource. The call will block for <code>timeout</code> seconds if a ticket
- * is not available. If no ticket is available within the timeout period, Semian::TimeoutError
- * will be raised.
- *
- * If no timeout argument is provided, the default timeout passed to Semian.register will be used.
- *
- */
-static VALUE
-semian_resource_acquire(int argc, VALUE *argv, VALUE self)
-{
-  semian_resource_t *self_res = NULL;
-  semian_resource_t res = { 0 };
-
-  if (!rb_block_given_p()) {
-    rb_raise(rb_eArgError, "acquire requires a block");
-  }
-
-  TypedData_Get_Struct(self, semian_resource_t, &semian_resource_type, self_res);
-  res = *self_res;
-
-  /* allow the default timeout to be overridden by a "timeout" param */
-  if (argc == 1 && TYPE(argv[0]) == T_HASH) {
-    VALUE timeout = rb_hash_aref(argv[0], ID2SYM(id_timeout));
-    if (TYPE(timeout) != T_NIL) {
-      if (TYPE(timeout) != T_FLOAT && TYPE(timeout) != T_FIXNUM) {
-        rb_raise(rb_eArgError, "timeout parameter must be numeric");
-      }
-      ms_to_timespec(NUM2DBL(timeout) * 1000, &res.timeout);
-    }
-  } else if (argc > 0) {
-    rb_raise(rb_eArgError, "invalid arguments");
-  }
-
-  /* release the GVL to acquire the semaphore */
-  WITHOUT_GVL(acquire_semaphore_without_gvl, &res, RUBY_UBF_IO, NULL);
-  if (res.error != 0) {
-    if (res.error == EAGAIN) {
-      rb_raise(eTimeout, "timed out waiting for resource '%s'", res.name);
-    } else {
-      raise_semian_syscall_error("semop()", res.error);
-    }
-  }
-
-  return rb_ensure(rb_yield, self, cleanup_semian_resource_acquire, self);
-}
-
-/*
- * call-seq:
- *   resource.destroy() -> true
- *
- * Destroys a resource. This method will destroy the underlying SysV semaphore.
- * If there is any code in other threads or processes blocking or using the resource
- * they will likely raise.
- *
- * Use this method very carefully.
- */
-static VALUE
-semian_resource_destroy(VALUE self)
-{
-  semian_resource_t *res = NULL;
-
-  TypedData_Get_Struct(self, semian_resource_t, &semian_resource_type, res);
-  if (semctl(res->sem_id, 0, IPC_RMID) == -1) {
-    raise_semian_syscall_error("semctl()", errno);
-  }
-
-  return Qtrue;
-}
-
-/*
- * call-seq:
- *    resource.count -> count
- *
- * Returns the current ticket count for a resource.
- */
-static VALUE
-semian_resource_count(VALUE self)
-{
-  int ret;
-  semian_resource_t *res = NULL;
-
-  TypedData_Get_Struct(self, semian_resource_t, &semian_resource_type, res);
-  ret = semctl(res->sem_id, 0, GETVAL);
-  if (ret == -1) {
-    raise_semian_syscall_error("semctl()", errno);
-  }
-
-  return LONG2FIX(ret);
-}
-
-/*
- * call-seq:
- *    resource.semid -> id
- *
- * Returns the SysV semaphore id of a resource.
- */
-static VALUE
-semian_resource_id(VALUE self)
+int
+get_semaphore(int key)
 {
-  semian_resource_t *res = NULL;
-  TypedData_Get_Struct(self, semian_resource_t, &semian_resource_type, res);
-  return LONG2FIX(res->sem_id);
+  return semget(key, SI_NUM_SEMAPHORES, 0);
 }
 
 void Init_semian()