pcg_random 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e9d916ffcf05c6305989a4a440ad40a7b3b6143e
-  data.tar.gz: 8db0e0f2fb5feee3390d0503c56f60ad0c33ce22
+  metadata.gz: e26f09fa3ea5290710f41975fcf1a22e4265e794
+  data.tar.gz: 792f5b3ffddb3c984d58aa93c8146443e7837682
 SHA512:
-  metadata.gz: 8074251b1e55a97ede7e8d34e815067f5032908c809d6cf26c578a9c55abb4974bf1d071796396d4ef430cd02802c89763d1dd289a9dbe6945bcc373decb2672
-  data.tar.gz: 8a0d123279a6973c28b4a10f33f42f58deac929fa37d1931067e20c34cd7b2b510ad16755d3b2cf3a8ebad8e0bc8c638de1aa83eb9f4529268c113e37db951e4
+  metadata.gz: 8bf992989aa751a8cd99dc153f78469dc3da4c16b6e2ec3e8dc8a8589aaa1407d0f78b42b9b1a33123ef6b0b83b3b700853afbac5bb23ccc9151e799cd8d7b92
+  data.tar.gz: 8addc87f54888e50b8bdeb08f6959da746054f5d8014c498842121596b6b0c64c314d1b5cd841fd650a97924cc6a69778cd2f36633428b1a352fd0f801ac73b4

data/benchmarks/new_seed.md

@@ -0,0 +1,17 @@
+```bash
+Benchmark of Random.new_seed vs PCGRandom.new_seed
+==================================================
+
+Benchmark created around: 2016-03-25 18:27:27 +0000
+
+Running for: 100000 iterations
+
+Rehearsal ------------------------------------------------------
+Random.new_seed      0.120000   1.060000   1.180000 (  1.173928)
+PCGRandom.new_seed   0.070000   1.020000   1.090000 (  1.096108)
+--------------------------------------------- total: 2.270000sec
+
+                         user     system      total        real
+Random.new_seed      0.100000   1.090000   1.190000 (  1.188864)
+PCGRandom.new_seed   0.110000   1.090000   1.200000 (  1.197528)
+```

data/benchmarks/new_seed_bench.rb

@@ -1,26 +1,8 @@
 require 'benchmark'
 require 'pcg_random'
 
-
-# Benchmark of Random.new_seed vs PCGRandom.new_seed
-# ==================================================
-#
-# Benchmark created around: 2016-03-20 14:28:07 +0000
-#
-# Running for: 100000 iterations
-#
-# Rehearsal ------------------------------------------------------
-# Random.new_seed      0.110000   1.030000   1.140000 (  1.135205)
-# PCGRandom.new_seed   0.090000   1.060000   1.150000 (  1.157619)
-# --------------------------------------------- total: 2.290000sec
-#
-#                         user     system      total        real
-# Random.new_seed      0.090000   1.250000   1.340000 (  1.348947)
-# PCGRandom.new_seed   0.150000   1.000000   1.150000 (  1.146167)
-
-
 Iterations = 100_000
-
+puts "```bash"
 puts "Benchmark of Random.new_seed vs PCGRandom.new_seed"
 puts "=================================================="
 puts ""
@@ -32,8 +14,9 @@ Benchmark.bmbm do |bench|
   bench.report("Random.new_seed") do
     Iterations.times {Random.new_seed}
   end
-  
+
   bench.report("PCGRandom.new_seed") do
     Iterations.times {PCGRandom.new_seed}
   end
-end
+end
+puts "```"

data/benchmarks/raw_seed.md

@@ -0,0 +1,17 @@
+```bash
+Benchmark of Random.raw_seed(16) vs PCGRandom.raw_seed(16)
+==================================================
+
+Benchmark created around: 2016-03-25 18:27:35 +0000
+
+Running for: 100000 iterations
+
+Rehearsal ----------------------------------------------------------
+Random.raw_seed(16)      0.040000   0.980000   1.020000 (  1.031410)
+PCGRandom.raw_seed(16)   0.050000   0.970000   1.020000 (  1.021024)
+------------------------------------------------- total: 2.040000sec
+
+                             user     system      total        real
+Random.raw_seed(16)      0.090000   0.990000   1.080000 (  1.076778)
+PCGRandom.raw_seed(16)   0.060000   1.000000   1.060000 (  1.067268)
+```

data/benchmarks/raw_seed_bench.rb

@@ -1,27 +1,10 @@
 require 'benchmark'
 require 'pcg_random'
 
-
-# Benchmark of Random.raw_seed(16) vs PCGRandom.raw_seed(16)
-# ==================================================
-#
-# Benchmark created around: 2016-03-20 14:34:40 +0000
-#
-# Running for: 100000 iterations
-#
-# Rehearsal ----------------------------------------------------------
-# Random.raw_seed(16)      0.060000   1.110000   1.170000 (  1.173924)
-# PCGRandom.raw_seed(16)   0.060000   1.110000   1.170000 (  1.175782)
-# ------------------------------------------------- total: 2.340000sec
-#
-#                             user     system      total        real
-# Random.raw_seed(16)      0.060000   1.230000   1.290000 (  1.292141)
-# PCGRandom.raw_seed(16)   0.080000   1.100000   1.180000 (  1.189046)
-
-
-
 Iterations = 100_000
 SeedSize = 16
+
+puts "```bash"
 puts "Benchmark of Random.raw_seed(#{SeedSize}) vs PCGRandom.raw_seed(#{SeedSize})"
 puts "=================================================="
 puts ""
@@ -33,8 +16,9 @@ Benchmark.bmbm do |bench|
   bench.report("Random.raw_seed(#{SeedSize})") do
     Iterations.times {Random.raw_seed SeedSize}
   end
-  
+
   bench.report("PCGRandom.raw_seed(#{SeedSize})") do
     Iterations.times {PCGRandom.raw_seed SeedSize}
   end
-end
+end
+puts "```"

data/ext/pcg_random/depend

@@ -0,0 +1,3 @@
+entropy.o: entropy.c pcg_spinlock.h entropy.h
+pcg_random.o: pcg_random.c pcg_random.h pcg_seed.h
+pcg_seed.o: pcg_seed.c entropy.h pcg_seed.h

data/ext/pcg_random/extconf.rb

@@ -1,8 +1,8 @@
-require "mkmf"
+require 'mkmf'
 
 RbConfig::MAKEFILE_CONFIG['CC'] = ENV['CC'] if ENV['CC']
 
-$CFLAGS = " -Wall -pedantic -ansi -std=c99"
+$CFLAGS = " -ggdb -Wall -pedantic -std=c99"
 
 LIBDIR      = RbConfig::CONFIG['libdir']
 INCLUDEDIR  = RbConfig::CONFIG['includedir']

data/ext/pcg_random/pcg_random.c

@@ -1,24 +1,193 @@
 #include <ruby.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <math.h>
 #include <pcg_variants.h>
-#include <inttypes.h>
-#include <string.h>
 
-#include "rb_constants.h"
 #include "pcg_random.h"
 #include "pcg_seed.h"
 
 VALUE rb_cPCGRandom;
 
+static void pcg_random_mark(void *ptr);
+static void pcg_random_free(void *rand_data);
+static size_t pcg_random_memsize(const void *ptr);
+static pcg_rb_rand_t *pcg_get_rand_type(VALUE obj);
+static VALUE pcg_random_alloc(VALUE klass);
+static VALUE pcg_func_init(int argc, VALUE *argv, VALUE self);
+static VALUE pcg_func_get_state(VALUE self);
+static VALUE pcg_func_get_seq(VALUE self);
+
+/*
+ * Structure wrapping our rng's data type's GC related functions
+ */
+static const rb_data_type_t pcg_rand_data_t = {
+     "pcg_random",
+    {
+        pcg_random_mark,
+        pcg_random_free,
+        pcg_random_memsize,
+    },
+};
+
+/*
+ * Internal - Mark the internal seed value for garbage collection since a VALUE
+ * inside a C struct is not marked by the GC automatically, and isn't freed
+ * correctly either.
+ */
+static void
+pcg_random_mark(void *ptr)
+{
+     rb_gc_mark(((pcg_rb_rand_t *) ptr)->seed.val);
+}
+
+/*
+ * Internal - Free internal C-types in the `pcg_rb_rand_t` struct
+ */
+static void
+pcg_random_free(void *rand_data)
+{
+    xfree(((pcg_rb_rand_t *) rand_data)->rng);
+    xfree((pcg_rb_rand_t *)(rand_data));
+}
+
+/*
+ * Internal - Get the size of a valid pcg_rb_rand_t pointer
+ *
+ * @return the size of `pcg_rb_rand_t` struct if it is initialized correctly.
+ *  0 if given a NULL pointer
+ */
+static size_t
+pcg_random_memsize(const void *ptr)
+{
+    return ptr ? sizeof(pcg_rb_rand_t) : 0;
+}
+
+/*
+ * Internal - Helper function to get a pointer to a pcg_rb_rand_t struct given
+ * an instance of the `PCGRandom` class
+ *
+ * Returns an object wrapping a C struct, with default initializations
+ */
+static pcg_rb_rand_t *
+pcg_get_rand_type(VALUE obj)
+{
+    pcg_rb_rand_t *ptr;
+    TypedData_Get_Struct(obj, pcg_rb_rand_t, &pcg_rand_data_t, ptr);
+    return ptr;
+}
+
+/*
+ * Memory allocation function that is called by new before `initialize` is
+ * The chain is similar to: `new -> allocate -> initialize`
+ *
+ * Returns an object wrapping a C struct, with default initializations
+ */
+static VALUE
+pcg_random_alloc(VALUE klass)
+{
+    pcg_rb_rand_t *rand_data;
+    VALUE obj;
+    /*
+     * ISO C forbids braced-groups within expressions
+     * See: http://stackoverflow.com/questions/1238016/
+     */
+    obj = __extension__ TypedData_Make_Struct(klass, pcg_rb_rand_t, &pcg_rand_data_t, rand_data);
+
+    rand_data->seed.val     = INT2FIX(0);
+    rand_data->seed.state   = 0;
+    rand_data->seed.seq     = 0;
+    rand_data->rng          = ALLOC(pcg32_random_t);
+
+    return obj;
+}
+
+/*
+ * Internal - Initialize the requested instance using a pre-allocated ruby
+ * object (TypedStruct). Sets the instance variables and relevant accessor
+ * methods where applicable.
+ */
+static VALUE
+pcg_func_init(int argc, VALUE *argv, VALUE self)
+{
+    VALUE seed;
+    uint64_t cseeds[2];
+    pcg_rb_rand_t* rand_data = pcg_get_rand_type(self);
+
+    if(argc == 0)
+    {
+        seed = DEFAULT_SEED_VALUE;
+    }
+    else
+    {
+        rb_scan_args(argc, argv, "01", &seed);
+    }
+
+    rb_integer_pack(seed, (void *) cseeds, 2, sizeof(uint64_t), 0,
+        INTEGER_PACK_MSWORD_FIRST|INTEGER_PACK_NATIVE_BYTE_ORDER);
+
+    rand_data->seed.val     = seed;
+    rand_data->seed.state   = cseeds[0];
+    rand_data->seed.seq     = cseeds[1];
+    pcg32_srandom_r(rand_data->rng, cseeds[0], cseeds[1]);
+
+    /* Add & set private instance variables */
+    rb_iv_set(self, "@seed", seed);
+    rb_iv_set(self, "state", LONG2NUM(rand_data->seed.state));
+    rb_iv_set(self, "sequence", LONG2NUM(rand_data->seed.seq));
+    return self;
+}
+
+/*
+ * Internal - Private method to access internal rng state parameter
+ * (Most significant word of seed)
+ */
+static VALUE
+pcg_func_get_state(VALUE self)
+{
+    VALUE state;
+    state = rb_iv_get(self, "state");
+    return state;
+}
+
+/*
+ * Internal - Private method to access internal rng state parameter
+ * (Most significant word of seed)
+ */
+static VALUE
+pcg_func_get_seq(VALUE self)
+{
+    VALUE seq;
+    seq = rb_iv_get(self, "sequence");
+    return seq;
+}
+
 void
 Init_pcg_random(void)
 {
-    /* Initialize constants used by C-code*/
-    pcg_init_rb_constants();
-    
-    /* Define encapsulating module */
+    /* Initializations */
+
+    /* Constants / Classes */
     rb_cPCGRandom = rb_define_class("PCGRandom", rb_cObject);
-    
-    /* Define methods under PCGRandom */
-    rb_define_singleton_method(rb_cPCGRandom, "new_seed", pcg_func_new_seed, -1);
+
+    rb_define_const(rb_cPCGRandom, "DEFAULT_SEED_BYTES", INT2FIX(DEFAULT_SEED_BYTES));
+
+    /* Singleton methods */
+    rb_define_singleton_method(rb_cPCGRandom, "new_seed", pcg_func_new_seed, 0);
     rb_define_singleton_method(rb_cPCGRandom, "raw_seed", pcg_func_raw_seed, 1);
+
+    /* Public instance methods */
+    rb_define_alloc_func(rb_cPCGRandom, pcg_random_alloc);
+    rb_define_attr(rb_cPCGRandom, "seed", 1, 0);
+    // rb_define_method(rb_cPCGRandom, "rand", pcg_func_rand, -1);
+    // rb_define_method(rb_cPCGRandom, "bytes", pcg_func_rand_bytes, 1);
+    // rb_define_method(rb_cPCGRandom, "initialize_copy", pcg_func_rand_copy, 1);
+    // rb_define_method(rb_cPCGRandom, "==", pcg_func_equal, 1);
+
+    /* Private instance methods */
+    rb_define_method(rb_cPCGRandom, "initialize", pcg_func_init, -1);
+    // rb_define_private_method(rb_cPCGRandom, "marshal_dump", pcg_func_dump, 0);
+    // rb_define_private_method(rb_cPCGRandom, "marshal_load", pcg_func_load, 1);
+    rb_define_private_method(rb_cPCGRandom, "state", pcg_func_get_state, 0);
+    rb_define_private_method(rb_cPCGRandom, "sequence", pcg_func_get_seq, 0);
 }

data/ext/pcg_random/pcg_random.h

@@ -2,8 +2,21 @@
 #define PCG_RANDOM_H 1
 
 #include <ruby.h>
-#include <inttypes.h>
+#include <stdint.h>
 
 extern VALUE rb_cPCGRandom;
 
+struct pcg_rb_seed
+{
+    VALUE val;
+    uint64_t state;
+    uint64_t seq;
+};
+
+typedef struct
+{
+    struct pcg_rb_seed seed;
+    pcg32_random_t *rng;
+} pcg_rb_rand_t;
+
 #endif /* PCG_RANDOM_H */

data/ext/pcg_random/pcg_seed.c

@@ -4,49 +4,22 @@
 #include <stdint.h>
 
 #include "entropy.h"
-#include "rb_constants.h"
 #include "pcg_seed.h"
 
-static VALUE pcg_new_seed_bytestr(unsigned long seed_size);
-static VALUE pcg_raw_seed_bytestr(size_t size);
-
 /*
- * Returns a n-byte integer that stores the seed value used to seed the 
+ * Returns a 16-byte integer that stores the seed value used to seed the
  * initial state and sequence for the PCG generator.
- * If no parameters are supplied it default to a 128-bit seed size
- * 
- * @param size Number of bytes (EVEN!) that the generated seed must contain.
- *  Defaults to 16 Bytes (uint8_t) = 128 bits
- *
- * @raise ArgumentError if size is not even
- */ 
+ */
 VALUE
-pcg_func_new_seed(int argc, VALUE *argv, VALUE self)
+pcg_func_new_seed(VALUE self)
 {
-    VALUE seed_size;
-    unsigned long n;
-    
-    if(argc == 0)
-    {
-        return pcg_new_seed_bytestr(16 * sizeof(uint8_t));
-    }
-    
-    rb_scan_args(argc, argv, "01", &seed_size);
-    n = NUM2ULONG(seed_size);
-    
-    // Only accept even seed sizes since this later needs to be split into
-    // two parts!
-    if(n % 2 == 1)
-    {
-        rb_raise(rb_eArgError, "Seed size must be even! Found %lu", n);
-    }
-    return pcg_new_seed_bytestr(n * sizeof(uint8_t));
+    return DEFAULT_SEED_VALUE;
 }
 
 /*
- * Generates a random seed string represented as a sequence of bytes 
+ * Generates a random seed string represented as a sequence of bytes
  *
- * @param size Size of the bytestring to generate
+ * @param byte_size Size of the bytestring to generate
  */
 VALUE
 pcg_func_raw_seed(VALUE self, VALUE byte_size)
@@ -59,11 +32,33 @@ pcg_func_raw_seed(VALUE self, VALUE byte_size)
     return pcg_raw_seed_bytestr(n);
 }
 
+/*
+ * Gets `size` number of random bytes from a platform source
+ * and returns those as a ruby string
+ */
+VALUE
+pcg_raw_seed_bytestr(size_t size)
+{
+    VALUE result;
+    char *bytestr = ALLOCA_N(char, size + 1);
+    if(bytestr == NULL)
+    {
+        rb_raise(rb_eNoMemError,
+            "Could not allocate enough space for %lu-byte seed!", size);
+    }
+    MEMZERO(bytestr, char, size + 1);
+    pcg_func_entropy_getbytes((void *)bytestr, size);
+
+    result = rb_str_new2(bytestr);
+
+    return result;
+}
+
 /*
  * Generates a sequence of random bytes using device entropy
  * or a fallback mechanism based on pcg32_random_r
  */
-bool 
+bool
 pcg_func_entropy_getbytes(void *dest, size_t size)
 {
     // Get random bytes from /dev/random or a fallback source
@@ -76,65 +71,27 @@ pcg_func_entropy_getbytes(void *dest, size_t size)
 }
 
 /*
- * Internal - gets `size` number of random bytes from a platform source
- * and returns those as a ruby string
- */
-static VALUE
-pcg_raw_seed_bytestr(size_t size)
-{
-    VALUE result;
-    char *bytestr = (char *) malloc(size + 1);
-    if(bytestr == NULL)
-    {
-        rb_raise(rb_eNoMemError, 
-            "Could not malloc enough space for %lu-byte seed!", size);
-    }
-    memset(bytestr, 0, size + 1);
-    pcg_func_entropy_getbytes((void *)bytestr, size);
-    
-    result = rb_str_new2(bytestr);
-    free(bytestr);
-    
-    return result;
-}
-
-/*
- * Internal - Two random integers are sourced from /dev/random or a fallback
- * source 
+ * Random integers are sourced from /dev/random or a fallback
+ * source
  * Seed generated by manipulating a 16byte string & unpacking it to Q*
  */
-static VALUE
+VALUE
 pcg_new_seed_bytestr(unsigned long seed_size)
 {
-    VALUE result;
-    uint8_t *bytes = (uint8_t *) malloc(seed_size * sizeof(uint8_t));
-    unsigned long *buf = (unsigned long *) malloc(seed_size * sizeof(unsigned long));
-    
-    if(bytes == NULL || buf == NULL)
+    uint8_t *bytes =  ALLOCA_N(uint8_t, seed_size);
+
+    if(bytes == NULL)
     {
-        rb_raise(rb_eNoMemError, "Could not malloc enough memory!");
+        rb_raise(rb_eNoMemError, "Could not allocate enough memory!");
     }
-    
-    memset(bytes, 0, seed_size);
-    
+
+    MEMZERO(bytes, uint8_t, seed_size);
+
     if(!pcg_func_entropy_getbytes((void *)bytes, seed_size))
     {
         rb_raise(rb_eRuntimeError, "Unable to generate seed!");
     }
-    
-    // Populate an array of longs to feed to rb_big_unpack()
-    for(int i = 0; i < seed_size; ++i)
-    {
-        buf[i] = (unsigned long) bytes[i];
-    }
-    
-    // Inspired from ruby's very own random.c
-    // see: http://rxr.whitequark.org/mri/source/random.c#493
-    // Also: http://rxr.whitequark.org/mri/source/random.c#443
-    result = rb_big_unpack(buf, seed_size);
-    
-    free(bytes);
-    free(buf);
-    
-    return result;
-}
+
+    return rb_integer_unpack((void *) bytes, seed_size, sizeof(uint8_t), 0,
+        INTEGER_PACK_MSWORD_FIRST|INTEGER_PACK_NATIVE_BYTE_ORDER);
+}

data/ext/pcg_random/pcg_seed.h

@@ -4,8 +4,20 @@
 #include <ruby.h>
 #include <stdbool.h>
 
-VALUE pcg_func_new_seed(int argc, VALUE *argv, VALUE self);
+#ifndef DEFAULT_SEED_BYTES
+#   define DEFAULT_SEED_BYTES 16
+#endif
+
+#ifndef DEFAULT_SEED_VALUE
+#   define DEFAULT_SEED_VALUE pcg_new_seed_bytestr(DEFAULT_SEED_BYTES * sizeof(uint8_t))
+#endif
+
 bool pcg_func_entropy_getbytes(void* dest, size_t size);
+
+VALUE pcg_func_new_seed(VALUE self);
+VALUE pcg_new_seed_bytestr(unsigned long seed_size);
+
 VALUE pcg_func_raw_seed(VALUE self, VALUE byte_size);
+VALUE pcg_raw_seed_bytestr(size_t size);
 
 #endif /* PCG_SEED_H */

data/lib/pcg_random/version.rb

@@ -1,3 +1,3 @@
 class PCGRandom
-  VERSION = "0.1.3"
+  VERSION = "0.1.4"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pcg_random
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Vaibhav Yenamandra
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-03-20 00:00:00.000000000 Z
+date: 2016-03-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -96,10 +96,13 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- benchmarks/new_seed.md
 - benchmarks/new_seed_bench.rb
+- benchmarks/raw_seed.md
 - benchmarks/raw_seed_bench.rb
 - bin/console
 - bin/setup
+- ext/pcg_random/depend
 - ext/pcg_random/entropy.c
 - ext/pcg_random/entropy.h
 - ext/pcg_random/extconf.rb
@@ -108,8 +111,6 @@ files:
 - ext/pcg_random/pcg_seed.c
 - ext/pcg_random/pcg_seed.h
 - ext/pcg_random/pcg_spinlock.h
-- ext/pcg_random/rb_constants.c
-- ext/pcg_random/rb_constants.h
 - lib/pcg_random.rb
 - lib/pcg_random/version.rb
 - pcg_random.gemspec

data/ext/pcg_random/rb_constants.c

@@ -1,26 +0,0 @@
-#include <ruby.h>
-#include "rb_constants.h"
-
-VALUE pcg_rb_zero,
-      pcg_rb_one,
-      pcg_rb_big_zero,
-      pcg_rb_big_one;
-
-
-ID  pcg_rb_plus,
-    pcg_rb_mul;
-
-void
-pcg_init_rb_constants(void)
-{
-    // Commonly used ruby objects
-    pcg_rb_zero = INT2FIX(0);
-    pcg_rb_one  = INT2FIX(1);
-    
-    pcg_rb_big_zero = rb_uint2big(0);
-    pcg_rb_big_one  = rb_uint2big(1);
-    
-    // Commonly called functions
-    pcg_rb_plus = rb_intern("+");
-    pcg_rb_mul  = rb_intern("*");
-}

data/ext/pcg_random/rb_constants.h

@@ -1,16 +0,0 @@
-#ifndef PCG_RB_CONSTANTS_H
-#define PCG_RB_CONSTANTS_H 1
-
-#include <ruby.h>
-
-extern VALUE pcg_rb_zero,
-             pcg_rb_one,
-             pcg_rb_big_zero,
-             pcg_rb_big_one;
-             
-extern ID pcg_rb_plus, 
-          pcg_rb_mul;
-
-void pcg_init_rb_constants(void);
-
-#endif /* PCG_RB_CONSTANTS_H */