pcg_random 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 80bdb7b230ebe145ca36718ca2b5ce75927611d3
-  data.tar.gz: f54e765d9d10ce35f10ad63f1cbaa0e8f120fc80
+  metadata.gz: e9d916ffcf05c6305989a4a440ad40a7b3b6143e
+  data.tar.gz: 8db0e0f2fb5feee3390d0503c56f60ad0c33ce22
 SHA512:
-  metadata.gz: daf8fdc612fdfb584896480a5ccb5f416cad2b235bbd8f46155c568dcee6b35c911a13eb7fc1af6a7ae5be2b3bd448cbe9f99506b06a17fa05403f5baa4ebc02
-  data.tar.gz: 84057b096b179ffe467e470ba42ac35f84c626edf6c006f108aa9643f0e7b1e525d807a29683774be6e887844205499c7dab06aed3140c5e9f56477ebccbbff9
+  metadata.gz: 8074251b1e55a97ede7e8d34e815067f5032908c809d6cf26c578a9c55abb4974bf1d071796396d4ef430cd02802c89763d1dd289a9dbe6945bcc373decb2672
+  data.tar.gz: 8a0d123279a6973c28b4a10f33f42f58deac929fa37d1931067e20c34cd7b2b510ad16755d3b2cf3a8ebad8e0bc8c638de1aa83eb9f4529268c113e37db951e4

data/.gitignore

@@ -19,7 +19,7 @@
 *.log
 
 # Github commit messages
-.gitmsg
+gitmsg.md
 
 # Benchmark code till I find an alternative way that doesn't piss off
 # rake-compiler

data/Rakefile

@@ -13,8 +13,4 @@ end
 
 task :cc => [:clean, :compile]
 
-task :default => [:clobber, :compile, :spec]
-
-task :bench do
-  PCGBench.press
-end
+task :default => [:clobber, :compile, :spec]

data/benchmarks/new_seed_bench.rb

@@ -0,0 +1,39 @@
+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 "Benchmark of Random.new_seed vs PCGRandom.new_seed"
+puts "=================================================="
+puts ""
+puts "Benchmark created around: #{Time.now}"
+puts ""
+puts "Running for: #{Iterations} iterations"
+puts ""
+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

data/benchmarks/raw_seed_bench.rb

@@ -0,0 +1,40 @@
+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 "Benchmark of Random.raw_seed(#{SeedSize}) vs PCGRandom.raw_seed(#{SeedSize})"
+puts "=================================================="
+puts ""
+puts "Benchmark created around: #{Time.now}"
+puts ""
+puts "Running for: #{Iterations} iterations"
+puts ""
+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

data/ext/pcg_random/entropy.c

@@ -61,17 +61,21 @@
 
 #if HAVE_DEV_RANDOM 
 /* entropy_getbytes(dest, size):
- *     Use /dev/random to get some external entropy for seeding purposes.
+ *     Use /dev/urandom to get some external entropy for seeding purposes.
  *
  * Note:
- *     If reading /dev/random fails (which ought to never happen), it returns
+ *     If reading /dev/urandom fails (which ought to never happen), it returns
  *     false, otherwise it returns true.  If it fails, you could instead call
  *     fallback_entropy_getbytes which always succeeds.
+ * Note2:
+ *     This version is an edited copy of the original entropy.c used in pcg-c
+ *     It uses /dev/urandom instead of /dev/random 
+ *     (Read: http://www.2uo.de/myths-about-urandom/)
  */
 
 bool entropy_getbytes(void* dest, size_t size)
 {
-    int fd = open("/dev/random", O_RDONLY);
+    int fd = open("/dev/urandom", O_RDONLY);
     if (fd < 0)
         return false;
     int sz = read(fd, dest, size);
@@ -88,7 +92,7 @@ bool entropy_getbytes(void* dest, size_t size)
 #endif
 
 /* fallback_entropy_getbytes(dest, size):
- *     Works like the /dev/random version above, but avoids using /dev/random.
+ *     Works like the /dev/urandom version above, but avoids using /dev/random.
  *     Instead, it uses a private RNG (so that repeated calls will return
  *     different seeds).  Makes no attempt at cryptographic security.
  */

data/ext/pcg_random/pcg_seed.c

@@ -1,6 +1,7 @@
 #include <ruby.h>
 #include <pcg_variants.h>
 #include <stdbool.h>
+#include <stdint.h>
 
 #include "entropy.h"
 #include "rb_constants.h"
@@ -8,15 +9,14 @@
 
 static VALUE pcg_new_seed_bytestr(unsigned long seed_size);
 static VALUE pcg_raw_seed_bytestr(size_t size);
-static VALUE pcg_rb_unpack_str_uint(VALUE str);
 
 /*
- * Returns a n-bit integer that stores the seed value used to seed the 
+ * Returns a n-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 = 128 bits
+ *  Defaults to 16 Bytes (uint8_t) = 128 bits
  *
  * @raise ArgumentError if size is not even
  */ 
@@ -28,7 +28,7 @@ pcg_func_new_seed(int argc, VALUE *argv, VALUE self)
     
     if(argc == 0)
     {
-        return pcg_new_seed_bytestr(2 * sizeof(uint64_t));
+        return pcg_new_seed_bytestr(16 * sizeof(uint8_t));
     }
     
     rb_scan_args(argc, argv, "01", &seed_size);
@@ -40,7 +40,7 @@ pcg_func_new_seed(int argc, VALUE *argv, VALUE self)
     {
         rb_raise(rb_eArgError, "Seed size must be even! Found %lu", n);
     }
-    return pcg_new_seed_bytestr(n * sizeof(char));
+    return pcg_new_seed_bytestr(n * sizeof(uint8_t));
 }
 
 /*
@@ -67,37 +67,12 @@ bool
 pcg_func_entropy_getbytes(void *dest, size_t size)
 {
     // Get random bytes from /dev/random or a fallback source
-    return entropy_getbytes(dest, size);
-}
-
-/*
- * Internal - Unpacks a string `str` wuth String#unpack
- */
-static VALUE
-pcg_rb_unpack_str_uint(VALUE str)
-{
-    VALUE ary, result, current, base;
-    unsigned long len;
-    
-    // This would be an array of 8 bit fixnums, effectively representing it in
-    // base-256
-    ary = rb_funcall(str, rb_intern("unpack"), 1, rb_str_new2("C*\0"));
-    len = RARRAY_LEN(ary);
-    
-    base = INT2FIX(256);
-    result = pcg_rb_zero;
-    
-    // First entry in array corresponds to highest significance
-    for(int i = 0; i < len; ++i)
+    if(!entropy_getbytes(dest, size))
     {
-        current = rb_ary_entry(ary, i);
-        // Maybe optimize the below code based on on TYPE(result) later ?
-        // Currently this doesnt utilize the C-API a effectively
-        result = rb_funcall(result, pcg_rb_plus, 1, current);
-        result = rb_funcall(result, pcg_rb_mul, 1 , base);
+        fallback_entropy_getbytes(dest, size);
+        return true;
     }
-    
-    return result;
+    return true;
 }
 
 /*
@@ -107,9 +82,13 @@ pcg_rb_unpack_str_uint(VALUE str)
 static VALUE
 pcg_raw_seed_bytestr(size_t size)
 {
-    char *bytestr = (char *) malloc(size + 1);
     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);
     
@@ -127,8 +106,35 @@ pcg_raw_seed_bytestr(size_t size)
 static VALUE
 pcg_new_seed_bytestr(unsigned long seed_size)
 {
-    VALUE seed_bytes_str;
-    seed_bytes_str = pcg_raw_seed_bytestr(seed_size);
-    return pcg_rb_unpack_str_uint(seed_bytes_str);
+    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)
+    {
+        rb_raise(rb_eNoMemError, "Could not malloc enough memory!");
+    }
+    
+    memset(bytes, 0, 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;
 }
-

data/lib/pcg_random/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pcg_random
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Vaibhav Yenamandra
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-03-19 00:00:00.000000000 Z
+date: 2016-03-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -96,6 +96,8 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- benchmarks/new_seed_bench.rb
+- benchmarks/raw_seed_bench.rb
 - bin/console
 - bin/setup
 - ext/pcg_random/entropy.c