localmemcache 0.0.1

data/src/tests/alloc.rb

@@ -0,0 +1,61 @@
+$DIR=File.dirname(__FILE__)
+['.', '..'].each {|p| $:.unshift File.join($DIR, p) }
+
+require 'bacon'
+require 'lmctestapi'
+$a = Alloc.new(1000)
+
+Bacon.summary_on_exit
+
+describe 'Alloc' do
+
+  it 'should support basic allocation and freeing of memory' do
+    $a.dispose($a.get(100))
+  end
+
+  it 'should merge free chunks' do
+    free = $a.free_mem
+    v1 = $a.get(100)
+    $a.free_mem.should.equal(free - 108)
+    v2 = $a.get(100)
+    $a.free_mem.should.equal(free - 216)
+    $a.free_chunks.should.equal 1
+    $a.dispose(v1)
+    $a.free_mem.should.equal(free - 108)
+    $a.free_chunks.should.equal 2
+    $a.dispose(v2)
+    $a.free_mem.should.equal free
+    $a.free_chunks.should.equal 1
+  end
+
+  it 'should handle memory exhaustion' do
+    v1 = $a.get($a.free_mem)
+    $a.free_mem.should.equal 0
+    $a.free_mem.should.equal 0
+    $a.free_mem.should.equal 0
+    should.raise(OutOfMemoryError) { $a.get(1) }
+    $a.dispose(v1)
+  end
+
+  it 'should manage free memory only if there is enough mem left to hold the struct ' do
+    $a.free_chunks.should.equal 1
+    v1 = $a.get($a.free_mem - 100)
+    $a.free_chunks.should.equal 1
+    v2 = $a.get(90)
+    $a.dump
+    $a.free_chunks.should.equal 0
+    $a.dispose(v1)
+    $a.dispose(v2)
+  end
+
+  it 'should deal with calling free for already freed items' do
+    v = $a.get(90)
+    $a.dispose(v)
+    $a.dispose(v)
+  end
+
+  it 'should deal with calling free with nasty parameters' do
+    $a.dispose(0)
+  end
+
+end

data/src/tests/bacon.rb

@@ -0,0 +1,301 @@
+# Bacon -- small RSpec clone.
+#
+# "Truth will sooner come out from error than from confusion." ---Francis Bacon
+
+# Copyright (C) 2007, 2008 Christian Neukirchen <purl.org/net/chneukirchen>
+#
+# Bacon is freely distributable under the terms of an MIT-style license.
+# See COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+module Bacon
+  VERSION = "0.9"
+
+  Counter = Hash.new(0)
+  ErrorLog = ""
+  Shared = Hash.new { |_, name|
+    raise NameError, "no such context: #{name.inspect}"
+  }
+
+  RestrictName    = //  unless defined? RestrictName
+  RestrictContext = //  unless defined? RestrictContext
+
+  def self.summary_on_exit
+    return  if Counter[:installed_summary] > 0
+    at_exit {
+      handle_summary
+      if $!
+        raise $!
+      elsif Counter[:errors] + Counter[:failed] > 0
+        exit 1
+      end
+    }
+    Counter[:installed_summary] += 1
+  end
+
+  module SpecDoxOutput
+    def handle_specification(name)
+      puts name
+      yield
+      puts
+    end
+
+    def handle_requirement(description)
+      print "- #{description}"
+      error = yield
+      puts error.empty? ? "" : " [#{error}]"
+    end
+
+    def handle_summary
+      print ErrorLog
+      puts "%d specifications (%d requirements), %d failures, %d errors" %
+        Counter.values_at(:specifications, :requirements, :failed, :errors)
+    end
+  end
+
+  module TestUnitOutput
+    def handle_specification(name)  yield  end
+
+    def handle_requirement(description)
+      error = yield
+      if error.empty?
+        print "."
+      else
+        print error[0..0]
+      end
+    end
+
+    def handle_summary
+      puts "", ErrorLog
+      puts "%d tests, %d assertions, %d failures, %d errors" %
+        Counter.values_at(:specifications, :requirements, :failed, :errors)
+    end
+  end
+
+  module TapOutput
+    def handle_specification(name)  yield  end
+
+    def handle_requirement(description)
+      ErrorLog.replace ""
+      error = yield
+      if error.empty?
+        printf "ok %-3d - %s\n" % [Counter[:specifications], description]
+      else
+        printf "not ok %d - %s: %s\n" %
+          [Counter[:specifications], description, error]
+        puts ErrorLog.strip.gsub(/^/, '# ')
+      end
+    end
+
+    def handle_summary
+      puts "1..#{Counter[:specifications]}"
+      puts "# %d tests, %d assertions, %d failures, %d errors" %
+        Counter.values_at(:specifications, :requirements, :failed, :errors)
+    end
+  end
+
+  extend SpecDoxOutput          # default
+
+  class Error < RuntimeError
+    attr_accessor :count_as
+
+    def initialize(count_as, message)
+      @count_as = count_as
+      super message
+    end
+  end
+
+  class Context
+    def initialize(name, &block)
+      @name = name
+      @before, @after = [], []
+
+      return  unless name =~ RestrictContext
+      Bacon.handle_specification(name) { instance_eval(&block) }
+    end
+
+    def before(&block); @before << block; end
+    def after(&block);  @after << block; end
+
+    def behaves_like(*names)
+      names.each { |name| instance_eval(&Shared[name]) }
+    end
+
+    def it(description, &block)
+      return  unless description =~ RestrictName
+      Counter[:specifications] += 1
+      run_requirement description, block
+    end
+
+    def run_requirement(description, spec)
+      Bacon.handle_requirement description do
+        begin
+          Counter[:depth] += 1
+          @before.each { |block| instance_eval(&block) }
+          instance_eval(&spec)
+        rescue Object => e
+          ErrorLog << "#{e.class}: #{e.message}\n"
+          e.backtrace.find_all { |line| line !~ /bin\/bacon|\/bacon\.rb:\d+/ }.
+            each_with_index { |line, i|
+            ErrorLog << "\t#{line}#{i==0 ? ": #@name - #{description}" : ""}\n"
+          }
+          ErrorLog << "\n"
+
+          if e.kind_of? Error
+            Counter[e.count_as] += 1
+            e.count_as.to_s.upcase
+          else
+            Counter[:errors] += 1
+            "ERROR: #{e.class}"
+          end
+        else
+          ""
+        ensure
+	  begin
+            @after.each { |block| instance_eval(&block) }
+	  rescue 
+	  end
+          Counter[:depth] -= 1
+        end
+      end
+    end
+
+    def raise?(*args, &block); block.raise?(*args); end
+    def throw?(*args, &block); block.throw?(*args); end
+    def change?(*args, &block); block.change?(*args); end
+  end
+end
+
+
+class Object
+  def true?; false; end
+  def false?; false; end
+end
+
+class TrueClass
+  def true?; true; end
+end
+
+class FalseClass
+  def false?; true; end
+end
+
+class Proc
+  def raise?(*exceptions)
+    exceptions << RuntimeError if exceptions.empty?
+    call
+
+  # Only to work in 1.9.0, rescue with splat doesn't work there right now
+  rescue Object => e
+    case e
+    when *exceptions
+      e
+    else
+      raise e
+    end
+  else
+    false
+  end
+
+  def throw?(sym)
+    catch(sym) {
+      call
+      return false
+    }
+    return true
+  end
+
+  def change?
+    pre_result = yield
+    called = call
+    post_result = yield
+    pre_result != post_result
+  end
+end
+
+class Numeric
+  def close?(to, delta)
+    (to.to_f - self).abs <= delta.to_f  rescue false
+  end
+end
+
+
+class Object
+  def should(*args, &block)   Should.new(self).be(*args, &block)  end
+end
+
+module Kernel
+  private
+
+  def describe(name, &block)  Bacon::Context.new(name, &block) end
+  def shared(name, &block)    Bacon::Shared[name] = block      end
+end
+
+
+class Should
+  # Kills ==, ===, =~, eql?, equal?, frozen?, instance_of?, is_a?,
+  # kind_of?, nil?, respond_to?, tainted?
+  instance_methods.each { |method|
+    undef_method method  if method =~ /\?|^\W+$/
+  }
+
+  def initialize(object)
+    @object = object
+    @negated = false
+  end
+
+  def not(*args, &block)
+    @negated = !@negated
+
+    if args.empty?
+      self
+    else
+      be(*args, &block)
+    end
+  end
+
+  def be(*args, &block)
+    if args.empty?
+      self
+    else
+      block = args.shift  unless block_given?
+      satisfy(*args, &block)
+    end
+  end
+
+  alias a  be
+  alias an be
+
+  def satisfy(*args, &block)
+    if args.size == 1 && String === args.first
+      description = args.shift
+    else
+      description = ""
+    end
+
+    r = yield(@object, *args)
+    if Bacon::Counter[:depth] > 0
+      raise Bacon::Error.new(:failed, description)  unless @negated ^ r
+      Bacon::Counter[:requirements] += 1
+    end
+    @negated ^ r ? r : false
+  end
+
+  def method_missing(name, *args, &block)
+    name = "#{name}?"  if name.to_s =~ /\w[^?]\z/
+
+    desc = @negated ? "not " : ""
+    desc << @object.inspect << "." << name.to_s
+    desc << "(" << args.map{|x|x.inspect}.join(", ") << ") failed"
+
+    satisfy(desc) { |x| x.__send__(name, *args, &block) }
+  end
+
+  def equal(value)         self == value      end
+  def match(value)         self =~ value      end
+  def identical_to(value)  self.equal? value  end
+  alias same_as identical_to
+
+  def flunk(reason="Flunked")
+    raise Bacon::Error.new(:failed, reason)
+  end
+end

data/src/tests/bench

@@ -0,0 +1,11 @@
+#! /bin/sh
+D=`dirname $0`
+DIR=`cd $D; pwd`
+script=$DIR/bench.rb
+
+if test "x$1" = "x-d"; then
+  irb -r $script
+else
+  #valgrind --leak-check=full --tool=memcheck ruby $script
+  ruby $script
+fi

data/src/tests/bench.rb

@@ -0,0 +1,46 @@
+$DIR=File.dirname(__FILE__)
+['.', '..', '../ruby-binding/'].each {|p| $:.unshift File.join($DIR, p) }
+
+require 'bacon'
+require 'localmemcache'
+
+Bacon.summary_on_exit
+
+LocalMemCache.clear_namespace("speed-comparison");
+$lm2 = LocalMemCache.new :namespace=>"speed-comparison"
+
+def compare_speed(n)
+  
+  puts "LocalMemCache"
+  measure_time(n) {
+    r = rand(10000).to_s
+    $lm2.set(r, r)
+    $lm2.get(r)
+  }
+  
+  puts "builtin"
+  $hh = {}
+  measure_time(n) {
+    r = rand(10000).to_s
+    $hh[r] = r
+    $hh[r]
+  }
+end
+
+def measure_time(c, &block)
+  _then = Time.now
+  c.times { block.call }
+  now = Time.now
+  puts "#{(now - _then)*1000} ms"
+end
+
+compare_speed(2_000_000)
+
+#$stdout.write "ht shm setting x 20000: "
+#tmeasure (2_000_000) { 
+#  v = $lm2.get("f").to_i + 1
+#  #puts "v:#{v}"
+#  $lm2.set("f", v) 
+#}
+#puts "foo: #{$lm2.get("f")}"
+ 

data/src/tests/extconf.rb

@@ -0,0 +1,14 @@
+require 'mkmf'
+
+dir = File.dirname(__FILE__)
+
+$defs << "-DRUBY_VERSION_CODE=#{RUBY_VERSION.gsub(/\D/, '')}"
+
+$srcs = ['lmctestapi.c']
+$objs = ['lmctestapi.o']
+
+$CFLAGS << " -D_REENTRANT -g -I .."
+$LDFLAGS << " ../liblmc.a -lpthread -lrt"
+
+dir_config('lmctestapi')
+create_makefile('lmctestapi')

data/src/tests/lmc

@@ -0,0 +1,11 @@
+#! /bin/sh
+D=`dirname $0`
+DIR=`cd $D; pwd`
+script=$DIR/lmc.rb
+
+if test "x$1" = "x-d"; then
+  irb -r $script
+else
+  #valgrind --leak-check=full --tool=memcheck ruby $script
+  ruby $script
+fi

data/src/tests/lmc.rb

@@ -0,0 +1,85 @@
+$DIR=File.dirname(__FILE__)
+['.', '..', '../ruby-binding/'].each {|p| $:.unshift File.join($DIR, p) }
+
+require 'bacon'
+require 'localmemcache'
+
+Bacon.summary_on_exit
+
+$lm = LocalMemCache.new :namespace=>"testing"
+
+describe 'LocalMemCache' do
+
+  it 'should allow to set and query keys' do
+    $lm.get("non-existant").should.be.nil
+    $lm.set("foo", "1")
+    $lm.get("foo").should.equal "1"
+  end
+
+  it 'should support the [] and []= operators' do
+    $lm["boo"] = "2"
+    $lm["boo"].should.equal "2"
+  end
+
+  it 'should allow deletion of keys' do
+    $lm["deleteme"] = "blah"
+    $lm["deleteme"].should.not.be.nil
+    $lm.delete("deleteme")
+    $lm["deleteme"].should.be.nil
+    $lm.delete("non-existant")
+  end
+
+  #it 'should support iteration' do
+  #  puts "TBD"
+  #end
+
+  it 'should support clearing of namespaces' do
+    LocalMemCache.clear_namespace("testing");
+  end
+
+end
+
+def tmeasure(c, &block)
+  _then = Time.now
+  c.times { block.call }
+  now = Time.now
+  puts "#{(now - _then)*1000} ms"
+end
+
+$lm2 = LocalMemCache.new :namespace=>"speed-comparison"
+
+def compare_speed(n)
+  
+  puts "LocalMemCache"
+  tmeasure(n) {
+    r = rand(10000).to_s
+#    $lm2.get(r)
+    $lm2.set(r, r)
+#    nr = $lm2.get(r)
+#    if nr != r
+#      $stderr.puts "FAILED: #{nr.inspect} != #{r.inspect}"
+#    end
+  }
+  
+  puts "builtin"
+  $hh = {}
+  tmeasure(n) {
+    r = rand(10000).to_s
+#    $hh[r]
+    $hh[r] = r
+#    if $hh[r] != r
+#      $stderr.puts "FAILED!"
+#    end
+  }
+end
+
+compare_speed(2_000_000)
+
+#$stdout.write "ht shm setting x 20000: "
+#tmeasure (2_000_000) { 
+#  v = $lm2.get("f").to_i + 1
+#  #puts "v:#{v}"
+#  $lm2.set("f", v) 
+#}
+#puts "foo: #{$lm2.get("f")}"
+ 

data/src/tests/lmctestapi.c

@@ -0,0 +1,162 @@
+/*
+ * Copyright (C) 2009, Sven C. Koehler
+ */
+
+#include <ruby.h>
+#include "lmc_shm.h"
+#include "lmc_hashtable.h"
+#include "lmc_valloc.h"
+
+void *memp = NULL;
+static VALUE OutOfMemoryError;
+
+long long_value(VALUE i) { return NUM2LONG(rb_Integer(i)); }
+VALUE num2string(long i) { return rb_big2str(rb_int2big(i), 10); }
+char *rstring_ptr(VALUE s) { 
+  char* r = NIL_P(s) ? "nil" : RSTRING_PTR(rb_String(s)); 
+  return r ? r : "nil";
+}
+static VALUE ruby_string(char *s) { return s ? rb_str_new2(s) : Qnil; }
+
+static VALUE Alloc__new(VALUE klass, VALUE size) {
+  size_t s = long_value(size);
+  memp = malloc(s);
+#ifdef DEBUG_ALLOC
+  printf("memp: %0x, end: %0x\n", memp, memp+s);
+  memset(memp, 0xF0, s);
+#endif
+  lmc_init_memory(memp, s);
+  return rb_class_new_instance(0, NULL, klass);
+}
+
+static VALUE Alloc__get(VALUE obj, VALUE size) {
+  size_t va = lmc_valloc(memp, long_value(size));
+  if (!va) { rb_raise(OutOfMemoryError, "Out of memory"); }
+  size_t v = long_value(size);
+#ifdef DEBUG_ALLOC
+  memset(memp + va, va, v);
+#endif
+  return rb_int2big(va);
+}
+
+static VALUE Alloc__dispose(VALUE obj, VALUE adr) {
+  lmc_free(memp, long_value(adr));
+  return Qnil;
+}
+
+static VALUE Alloc__dump(VALUE obj) {
+  lmc_dump(memp);
+  return Qnil;
+}
+
+static VALUE Alloc__free_mem(VALUE obj) {
+  return rb_int2inum(lmc_status(memp, "f").free_mem);
+}
+
+static VALUE Alloc__largest_chunk(VALUE obj) {
+  return rb_int2inum(lmc_status(memp, "lc").largest_chunk);
+}
+
+static VALUE Alloc__free_chunks(VALUE obj) {
+  return rb_int2inum(lmc_status(memp, "fc").free_chunks);
+}
+
+static VALUE SHMError;
+
+static lmc_shm_t* get_Shm(VALUE obj) {
+  lmc_shm_t *ls;
+  Data_Get_Struct(obj, lmc_shm_t, ls);
+  if (ls == NULL) { rb_raise(SHMError, "Not active"); }
+  return ls;
+}
+
+static VALUE SHM__new(VALUE klass, VALUE namespace) {
+  Check_Type(namespace, T_STRING);
+  lmc_shm_t *ls = lmc_shm_create("test2", 2000000, 0, 0); 
+  return Data_Wrap_Struct(klass, NULL, lmc_shm_destroy, ls);
+}
+
+static VALUE SHM__close(VALUE obj) {
+  lmc_shm_destroy(get_Shm(obj), 0);
+  DATA_PTR(obj) = NULL;
+  return Qnil;
+}
+
+static VALUE SHM__get(VALUE obj, VALUE id) {
+  return num2string(((int *)get_Shm(obj)->base)[long_value(id)]);
+}
+
+static VALUE SHM__set(VALUE obj, VALUE id, VALUE value) {
+  ((int *)get_Shm(obj)->base)[long_value(id)] = long_value(value);
+  return Qnil;
+}
+
+//typedef struct  { 
+//  va_ht_hash_t va; 
+//  mem_cache_t *mc;
+//  lmc_lock_t *ll;
+//} ht_desc_t;
+//
+//static VALUE Hashtable__new(VALUE klass) {
+//  lmc_lock_obtain("Hashtable__new");
+//  size_t s = 20401094656;
+//  lmc_lock_t *ll = lmc_lock_init("test11");
+//  mem_cache_t *mc = local_mem_cache_create(s); // namespace?
+//  lmc_init_memory(mc->shm, s);
+//  va_ht_hash_t va_ht = ht_hash_create(mc->shm); 
+//  ht_desc_t* ht = malloc(sizeof(ht_desc_t));
+//  ht->va = va_ht;
+//  ht->mc = mc;
+//  ht->ll = ll;
+//  lmc_lock_release("Hashtable__new");
+//  return Data_Wrap_Struct(klass, NULL, NULL, ht);
+//}
+//
+//ht_desc_t *get_Hashtable(VALUE obj) {
+//  ht_desc_t *ht;
+//  Data_Get_Struct(obj, ht_desc_t, ht);
+//  return ht;
+//}
+//
+//static VALUE Hashtable__get(VALUE obj, VALUE key) {
+//  ht_desc_t *ht = get_Hashtable(obj);
+//  return ruby_string(ht_get(ht->mc->shm, ht->va, rstring_ptr(key)));
+//}
+//
+//static VALUE Hashtable__set(VALUE obj, VALUE key, VALUE value) {
+//  ht_desc_t *ht = get_Hashtable(obj);
+//  ht_set(ht->mc->shm, ht->va, rstring_ptr(key), rstring_ptr(value));
+//  return Qnil;
+//}
+
+static VALUE Alloc;
+static VALUE SHM;
+//static VALUE Hashtable;
+
+#include <stdio.h>
+#include <fcntl.h>     
+#include <sys/stat.h>   
+#include <sys/mman.h>   
+
+void Init_lmctestapi() {
+  OutOfMemoryError = rb_define_class("OutOfMemoryError", rb_eStandardError);
+  Alloc = rb_define_class("Alloc", rb_cObject);
+  rb_define_singleton_method(Alloc, "new", Alloc__new, 1);
+  rb_define_method(Alloc, "get", Alloc__get, 1);
+  rb_define_method(Alloc, "dispose", Alloc__dispose, 1);
+  rb_define_method(Alloc, "dump", Alloc__dump, 0);
+  rb_define_method(Alloc, "free_mem", Alloc__free_mem, 0);
+  rb_define_method(Alloc, "largest_chunk", Alloc__largest_chunk, 0);
+  rb_define_method(Alloc, "free_chunks", Alloc__free_chunks, 0);
+
+  SHM = rb_define_class("SHM", rb_cObject);
+  rb_define_singleton_method(SHM, "new", SHM__new, 1);
+  rb_define_method(SHM, "get", SHM__get, 1);
+  rb_define_method(SHM, "set", SHM__set, 2);
+  rb_define_method(SHM, "close", SHM__close, 0);
+
+  //Hashtable = rb_define_class("Hashtable", rb_cObject);
+  //rb_define_singleton_method(Hashtable, "new", Hashtable__new, 0);
+  //rb_define_method(Hashtable, "get", Hashtable__get, 1);
+  //rb_define_method(Hashtable, "set", Hashtable__set, 2);
+}

data/src/tests/runtest.sh

@@ -0,0 +1,9 @@
+#! /bin/sh
+cd `dirname $0`
+
+test -f Makefile || ruby extconf.rb
+test -f mctestapi.so || make
+make clean 
+make
+./hashtable
+