process_shared 0.0.1

data/COPYING

@@ -0,0 +1,19 @@
+Copyright (c) 2011 Patrick Mahoney
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,69 @@
+== Description
+
+Concurrency primitives that may be used in a cross-process way to
+coordinate share memory between processes.
+
+A small C library (libpsem) is compiled to provide portable access to
+semaphores.  This library is then accessed using FFI to implement Ruby
+classes ProcessShared::Semaphore, ProcessShared::BoundedSemaphore,
+ProcessShared::Mutex, and ProcessShared::SharedMemory.
+
+This is an incomplete work in progress.
+
+== License
+
+MIT
+
+== Install
+Install the gem with:
+
+    gem install process_shared
+
+== Usage
+
+    require 'process_shared'
+
+    mutex = ProcessShared::Mutex.new
+    mem = ProcessShared::SharedMemory.new(:int)  # extends FFI::Pointer
+    mem.put_int(0, 0)
+
+    pid1 = fork do
+      puts "in process 1 (#{Process.pid})"
+      10.times do
+        sleep 0.01
+        mutex.synchronize do
+          value = mem.get_int(0)
+          sleep 0.01
+          puts "process 1 (#{Process.pid}) incrementing"
+          mem.put_int(0, value + 1)
+        end
+      end
+    end
+
+    pid2 = fork do
+      puts "in process 2 (#{Process.pid})"
+      10.times do
+        sleep 0.01
+        mutex.synchronize do
+          value = mem.get_int(0)
+          sleep 0.01
+          puts "process 2 (#{Process.pid}) decrementing"
+          mem.put_int(0, value - 1)
+        end
+      end
+    end
+
+    Process.wait(pid1)
+    Process.wait(pid2)
+
+    puts "value should be zero: #{mem.get_int(0)}"
+
+== Todo
+
+* Implement ConditionVariable
+* Implement optional override of core Thread/Mutex classes
+* Extend libpsem to win32?  (See Python's processing library)
+* Break out tests that use PSem.getvalue() (which isn't supported on Mac OS X)
+  so that the test suite will pass
+* Add finalizer to Mutex? (finalizer on Semaphore objects may be enough) or a method to
+  explicitly close and release resources?

data/ext/libpsem/bsem.c

@@ -0,0 +1,188 @@
+/*
+ * Extensions atop psem.  Recursive mutex, bounded semaphore.
+ */
+
+#include <stdlib.h>		/* malloc, free */
+
+#include "mempcpy.h"            /* includes string.h */
+#include "psem.h"
+#include "psem_error.h"
+#include "bsem.h"
+
+#define MAX_NAME 128            /* This is much less the POSIX max
+                                   name. Users of this library must
+                                   not use longer names. */
+
+static const char bsem_lock_suffix[] = "-bsem-lock";
+
+#define MAX_LOCK_NAME (MAX_NAME + strlen(bsem_lock_suffix) + 1)
+
+/**
+ * Assumes dest has sufficient space to hold "[MAX_NAME]-bsem-lock".
+ */
+static int
+make_lockname(char *dest, const char *name, error_t **err)
+{
+  int namelen;
+
+  namelen = strlen(name);
+  if (namelen > MAX_NAME) {
+    error_new(err, E_SOURCE_PSEM, E_NAME_TOO_LONG);
+    return ERROR;
+  }
+
+  *((char *) mempcpy(mempcpy(dest, name, namelen),
+                     bsem_lock_suffix,
+                     strlen(bsem_lock_suffix))) = '\0';
+}
+
+size_t sizeof_bsem_t = sizeof (bsem_t);
+
+bsem_t *
+bsem_alloc(void) {
+  return malloc(sizeof(bsem_t));
+}
+
+void
+bsem_free(bsem_t *bsem) {
+  free(bsem);
+}
+
+#define call_or_return(exp)					\
+  do { if ((exp) == ERROR) { return ERROR; } } while (0)
+
+#define bsem_lock_or_return(bsem, err) call_or_return(bsem_lock((bsem), (err)))
+
+#define bsem_unlock_or_return(bsem, err) call_or_return(bsem_unlock((bsem), (err)))
+
+int
+bsem_open(bsem_t *bsem, const char *name, unsigned int maxvalue, unsigned int value, error_t **err)
+{
+  char lockname[MAX_LOCK_NAME];
+
+  call_or_return(psem_open(&bsem->psem, name, value, err));
+  call_or_return(make_lockname(lockname, name, err));
+  call_or_return(psem_open(&bsem->lock, lockname, 1, err));
+
+  bsem->maxvalue = maxvalue;
+  
+  return OK;
+}
+
+static int
+bsem_lock(bsem_t *bsem, error_t **err)
+{
+  call_or_return(psem_wait(&bsem->lock, err));
+  return OK;
+}
+
+static int
+bsem_unlock(bsem_t *bsem, error_t **err)
+{
+  call_or_return(psem_post(&bsem->lock, err));
+  return OK;
+}
+
+int
+bsem_close(bsem_t *bsem, error_t **err)
+{
+  bsem_lock_or_return(bsem, err);
+
+  if (psem_close(&bsem->psem, err) == ERROR) {
+    bsem_unlock(bsem, NULL);
+    return ERROR;
+  }
+
+  bsem_unlock_or_return(bsem, err);
+
+  call_or_return(psem_close(&bsem->lock, err));
+  return OK;
+}
+
+int
+bsem_unlink(const char *name, error_t **err)
+{
+  char lockname[MAX_LOCK_NAME];
+
+  call_or_return(psem_unlink(name, err));
+  call_or_return(make_lockname(lockname, name, err));
+  call_or_return(psem_unlink(lockname, err));
+  return OK;
+}
+
+int
+bsem_post(bsem_t *bsem, error_t **err)
+{
+  int sval;
+
+  bsem_lock_or_return(bsem, err);
+
+  /* FIXME: maxvalue is broken on some systems... (cygwin? mac?) */
+  if (psem_getvalue(&bsem->psem, &sval, err) == ERROR) {
+    bsem_unlock(bsem, err);
+    return ERROR;
+  }
+
+  if (sval >= bsem->maxvalue) {
+    /* ignored silently */
+    bsem_unlock(bsem, err);
+    return OK;
+  }
+
+  if (psem_post(&bsem->psem, err) == ERROR) {
+    bsem_unlock(bsem, err);
+    return ERROR;
+  }
+
+  bsem_unlock_or_return(bsem, err);
+  return OK;
+}
+
+int
+bsem_wait(bsem_t *bsem, error_t **err)
+{
+  call_or_return(psem_wait(&bsem->psem, err));
+  return OK;
+}
+
+int
+bsem_trywait(bsem_t *bsem, error_t **err)
+{
+  bsem_lock_or_return(bsem, err);
+
+  if (psem_trywait(&bsem->psem, err) == ERROR) {
+    bsem_unlock(bsem, NULL);
+    return ERROR;
+  }
+
+  bsem_unlock_or_return(bsem, err);
+  return OK;
+}
+
+int
+bsem_timedwait(bsem_t *bsem, float timeout_s, error_t **err)
+{
+  bsem_lock_or_return(bsem, err);
+
+  if (psem_timedwait(&bsem->psem, timeout_s, err) == ERROR) {
+    bsem_unlock(bsem, NULL);
+    return ERROR;
+  }
+
+  bsem_unlock_or_return(bsem, err);
+  return OK;
+}
+
+int
+bsem_getvalue(bsem_t *bsem, int *sval, error_t **err)
+{
+  bsem_lock_or_return(bsem, err);
+
+  if (psem_getvalue(&bsem->psem, sval, err) == ERROR) {
+    bsem_unlock(bsem, NULL);
+    return ERROR;
+  }
+
+  bsem_unlock_or_return(bsem, err);
+  return OK;
+}

data/ext/libpsem/bsem.h

@@ -0,0 +1,32 @@
+#ifndef __BSEM_H__
+#define __BSEM_H__
+
+#include "psem.h"
+#include "psem_error.h"
+
+struct bsem {
+  psem_t psem;
+  psem_t lock;
+  int maxvalue;
+};
+
+typedef struct bsem bsem_t;
+
+extern size_t sizeof_bsem_t;
+
+bsem_t * bsem_alloc();
+void bsem_free(bsem_t *bsem);
+
+int bsem_open(bsem_t *, const char *, unsigned int, unsigned int, error_t **);
+int bsem_close(bsem_t *, error_t **);
+int bsem_unlink(const char *, error_t **);
+
+int bsem_post(bsem_t *, error_t **);
+int bsem_wait(bsem_t *, error_t **);
+int bsem_trywait(bsem_t *, error_t **);
+int bsem_timedwait(bsem_t *, float, error_t **);
+
+int bsem_getvalue(bsem_t *, int *, error_t **);
+
+#endif /* __BSEM_H__ */
+

data/ext/libpsem/constants.c

@@ -0,0 +1,22 @@
+/**
+ * Define and extern various constants defined as macros.
+ */
+
+#include <sys/mman.h>		/* PROT_*, MAP_* */
+#include <fcntl.h>		/* O_* */
+
+#include "constants.h"
+
+int o_rdwr = O_RDWR;
+int o_creat = O_CREAT;
+int o_excl = O_EXCL;
+
+int prot_read = PROT_READ;
+int prot_write = PROT_WRITE;
+int prot_exec = PROT_EXEC;
+int prot_none = PROT_NONE;
+
+void * map_failed = MAP_FAILED;
+
+int map_shared = MAP_SHARED;
+int map_private = MAP_PRIVATE;

data/ext/libpsem/constants.h

@@ -0,0 +1,18 @@
+#ifndef __CONSTANTS_H__
+#define __CONSTANTS_H__
+
+extern int o_rdwr;
+extern int o_creat;
+extern int o_excl;
+
+extern int prot_read;
+extern int prot_write;
+extern int prot_exec;
+extern int prot_none;
+
+extern void * map_failed;
+
+extern int map_shared;
+extern int map_private;
+
+#endif

data/ext/libpsem/extconf.rb

@@ -0,0 +1,36 @@
+require 'mkmf'
+
+$objs = []
+
+# posix semaphores
+if have_func('sem_open', 'semaphore.h')
+  have_func('floorf', 'math.h') or abort("Missing required floorf() in math.h")
+  have_library('m', 'floorf')
+
+  unless have_func('mempcpy', 'string.h')
+    $objs << 'mempcpy.o'
+  end
+
+  have_library('rt', 'sem_open')
+end
+
+c_sources = ['psem.c', 'psem_error.c', 'psem_posix.c', 'bsem.c', 'constants.c']
+$objs += ['psem.o', 'psem_error.o', 'bsem.o', 'constants.o']
+
+depend_rules <<-END
+psem.c: psem.h psem_posix.c
+psem_error.c: psem_error.h
+
+bsem.h: psem.h psem_error.h
+bsem.c: psem.h psem_error.h bsem.h
+
+constants.c: constants.h
+mempcpy.c: mempcpy.h
+
+#{$objs.map { |o| "#{o}: #{o.chomp(".o")}.c" }.join("\n")}
+
+libpsem.o: #{$objs.join(' ')}
+END
+
+
+create_makefile('libpsem')

data/ext/libpsem/mempcpy.c

@@ -0,0 +1,7 @@
+#include "mempcpy.h"
+
+void *
+mempcpy(void *dest, const void *src, size_t n)
+{
+  return (char *) memcpy(dest, src, n) + n;
+}

data/ext/libpsem/mempcpy.h

@@ -0,0 +1,13 @@
+#ifndef __MEMPCPY_H__
+#define __MEMPCPY_H__
+
+#ifdef HAVE_MEMPCPY
+#define __USE_GNU
+#else
+#include <stdlib.h>
+void *mempcpy(void *, const void *, size_t);
+#endif
+
+#include <string.h>
+
+#endif	/* __MEMPCPY_H__ */

data/ext/libpsem/mutex.c

@@ -0,0 +1,15 @@
+#include <stdlib.h>		/* malloc, free */
+
+#include "mutex.h"
+
+size_t sizeof_mutex_t = sizeof (mutex_t);
+
+mutex_t *
+mutex_alloc(void) {
+  return malloc(sizeof(mutex_t));
+}
+
+void
+mutex_free(mutex_t * mutex) {
+  free(mutex);
+}

data/ext/libpsem/mutex.h

@@ -0,0 +1,14 @@
+#ifndef __MUTEX_H__
+#define __MUTEX_H__
+
+#include "bsem.h"
+
+struct mutex {
+  bsem_t *bsem;
+};
+
+typedef struct mutex mutex_t;
+
+extern size_t sizeof_mutex_t;
+
+#endif /* __MUTEX_H__ */