fast_osc 0.0.12 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: e4e7bff342d4a5632e0cf9f70c6d4370469a2a28
-  data.tar.gz: 471466562ba2ac1a9b7b98ccb3812e543dd97b77
+SHA256:
+  metadata.gz: 949bcdc8e52905bef3bb5b53468844ab80232dd84e41b4d3d6c583c4317a6ff6
+  data.tar.gz: 229101f3ae65814846abb268e3780d4ac2c41d8c0d80f1e4c6da914cd07f2066
 SHA512:
-  metadata.gz: 609e4d29594e0c230a0d8223e49612a292f0eac2e12f36a282af24fe5c149aaef2f0feafb8f40f931296cb9b419ea6e4ccbc30c6e6834355f5b8e4454daca408
-  data.tar.gz: 8e2508cb94292d344eab85becedff76948ce879240210eb0ddae5462fb2d18a0bc71e8e71ac8af7c5567429cd2172a1f9eba7578430ba843bdb6019c67c5c69e
+  metadata.gz: 0d8e2777889e23339b1aebfbf15dd0bf26c98377c17721a876261767df06de0eaff80cb1418bc979dcadfcd61f5fced74e8857c52dbd601e8029c25d9b9fac6a
+  data.tar.gz: 2c61360c8a58ff7994c4158e31060938f98352941aedb7941359980730cbd9bd9a8ca0f43c7ec88c09d4d0e56b5736ad24cbc8a7ad15106b525d73378b29522b

data/.travis.yml

@@ -0,0 +1,2 @@
+language: ruby
+script: rake clean && rake compile && rake test

data/README.md

@@ -1,7 +1,5 @@
 # FastOsc
 
-`WARNING - Work in progress. Probably not safe for production yet`
-
 A Ruby wrapper around [rtosc](https://github.com/fundamental/rtosc/) to encode and decode OSC messages.
 
 This also includes a fallback implementation in pure Ruby in the case that the compiled version doesn't load properly. This can be forced by setting an environment variable of `FAST_OSC_USE_FALLBACK=1` where needed.
@@ -43,7 +41,7 @@ Calculating -------------------------------------
             osc-ruby     83.203k (±12.6%) i/s -    415.314k in   5.073578s
 ```
 
-## Decoding Bencmark
+### Decoding Bencmark
 
 ```
 Warming up --------------------------------------
@@ -58,6 +56,87 @@ Calculating -------------------------------------
 
 Benchmarks are now part of this repo - run `rake test` to see the results for yourself.
 
+## What about Truffle Ruby?
+
+> A high performance implementation of the Ruby programming language. Built on GraalVM by Oracle Labs.
+
+Just for fun, I re-ran the benchmarks using TruffleRuby. First some install steps:
+
+```
+git clone this repo
+bundle install
+export PATH="/usr/local/opt/llvm@4/bin:$PATH"
+rake clean && rake compile
+```
+
+then the test:
+
+```
+$ rake test
+ENCODING TEST
+Warming up --------------------------------------
+            fast_osc     3.000  i/100ms
+             samsosc    28.219k i/100ms
+            osc-ruby   234.000  i/100ms
+Calculating -------------------------------------
+            fast_osc     33.294  (±45.1%) i/s -    129.000  in   5.295649s
+             samsosc      1.369M (±33.5%) i/s -      3.556M in   5.010343s
+            osc-ruby    274.170k (±20.2%) i/s -      1.064M in   4.971832s
+DECODING TEST
+Warming up --------------------------------------
+            fast_osc     9.000  i/100ms
+             samsosc     6.087k i/100ms
+            osc-ruby   418.000  i/100ms
+Calculating -------------------------------------
+            fast_osc     71.034  (±45.0%) i/s -    261.000  in   5.015393s
+             samsosc    114.443k (±70.2%) i/s -    261.741k in   5.283892s
+            osc-ruby     84.236k (±34.7%) i/s -    237.424k in   5.317738s
+
+# update - retested using rc5
+ENCODING TEST
+Warming up --------------------------------------
+            fast_osc   106.000  i/100ms
+             samsosc   999.000  i/100ms
+            osc-ruby   159.000  i/100ms
+Calculating -------------------------------------
+            fast_osc     24.507k (±28.6%) i/s -     83.316k in   4.984544s
+             samsosc      1.494M (±22.4%) i/s -      2.785M in   4.988822s
+            osc-ruby    265.322k (±26.5%) i/s -    597.522k in   5.014127s
+DECODING TEST
+Warming up --------------------------------------
+            fast_osc   173.000  i/100ms
+             samsosc   454.000  i/100ms
+            osc-ruby   208.000  i/100ms
+Calculating -------------------------------------
+            fast_osc     73.712k (±66.4%) i/s -    163.831k in   5.049410s
+             samsosc    325.920k (±33.7%) i/s -    875.766k in   4.989279s
+            osc-ruby     63.624k (±52.3%) i/s -    129.792k in   5.005088s
+Run options: --seed 56032
+```
+
+### The Good
+
+The encoding benchmark - the optimised pure Ruby version is nearly as fast as
+the C extension!
+
+```
+# C ext in MRI
+fast_osc    797.673k (±15.0%) i/s -      3.900M in   5.043770s
+# Pure Ruby in Truffle rc3
+samsosc      1.369M (±33.5%) i/s -      3.556M in   5.010343s
+# Pure Ruby in Truffle rc5
+samsosc      1.494M (±22.4%) i/s -      2.785M in   4.988822s
+```
+
+### The Bad
+
+Decoding was generally slower, although the (non optimised) osc gem seemed to
+prefer TruffleRuby, running around 40% faster.
+
+~Also the performance of the C extension in TruffleRuby was very, very poor but
+this may be due to not warming up enough.~ update - this appears to be better
+in rc5.
+
 ## Usage
 
 ```
@@ -81,12 +160,12 @@ $ rake clean && rake clobber && rake compile && rake test
 
 ## Still todo
 
--[x] Implement more types
--[x] Bring benchmarks into the repo
--[ ] Work out cross compilation story for easier packaging
--[ ] Implement multi message/nested bundles
--[ ] Documentation
--[ ] Travis
+- [x] Implement more types
+- [x] Bring benchmarks into the repo
+- [ ] Work out cross compilation story for easier packaging
+- [x] Implement multi message/nested bundles
+- [ ] More documentation
+- [x] Travis
 
 ## Development notes
 

data/ext/fast_osc/extconf.rb

@@ -21,7 +21,7 @@ dir_config(extension_name, HEADER_DIRS, LIB_DIRS)
 #   $LOCAL_LIBS << "#{lib} "
 # end
 
-$srcs = ["fast_osc_wrapper.c"]
+$srcs = ["fast_osc_wrapper.c", "rtosc.c"]
 
 $CFLAGS << " -std=c99 -Wall -Wextra -Wno-unused-parameter -pedantic "
 

data/ext/fast_osc/fast_osc_wrapper.c

@@ -1,7 +1,6 @@
 #include <ruby.h>
 #include <ruby/encoding.h>
 #include <rtosc.h>
-#include <rtosc.c>
 
 
 // Allocate VALUE variables to hold the modules we'll create. Ruby values
@@ -15,7 +14,8 @@ void Init_fast_osc();
 VALUE method_fast_osc_decode_single_message(VALUE self, VALUE msg);
 VALUE method_fast_osc_encode_single_message(int argc, VALUE* argv, VALUE self);
 VALUE method_fast_osc_encode_single_bundle(int argc, VALUE* argv, VALUE self);
-
+VALUE method_fast_osc_decode(VALUE self, VALUE msg);
+VALUE method_fast_osc_decode_do(VALUE self, VALUE msg, VALUE output);
 // Initial setup function, takes no arguments and returns nothing. Some API
 // notes:
 //
@@ -30,7 +30,8 @@ VALUE method_fast_osc_encode_single_bundle(int argc, VALUE* argv, VALUE self);
 //
 void Init_fast_osc() {
   FastOsc = rb_define_module("FastOsc");
-  rb_define_singleton_method(FastOsc, "decode_single_message", method_fast_osc_decode_single_message, 1);
+  rb_define_singleton_method(FastOsc, "decode", method_fast_osc_decode, 1);
+  rb_define_singleton_method(FastOsc, "decode_no_bundles", method_fast_osc_decode_single_message, 1);
   rb_define_singleton_method(FastOsc, "encode_single_message", method_fast_osc_encode_single_message, -1);
   rb_define_singleton_method(FastOsc, "encode_single_bundle", method_fast_osc_encode_single_bundle, -1);
 }
@@ -68,6 +69,76 @@ uint64_t ruby_time_to_osc_timetag(VALUE rubytime) {
   return timetag;
 }
 
+VALUE osc_timetag_to_ruby_time(uint64_t timetag) {
+  uint32_t secs = timetag >> 32;
+  uint32_t frac = timetag;
+  double d_frac = 1.0 * frac / 4294967296.0;
+
+  VALUE c_time = rb_const_get(rb_cObject, rb_intern("Time"));
+  VALUE rb_time = rb_funcall(c_time, rb_intern("at"), 1, DBL2NUM((secs - JAN_1970 + d_frac)));
+
+  return rb_time;
+}
+
+/*
+# Example of how to process the messages in ruby:
+msgs.each do |timestamp, osc_messages|
+  # These are the messages within this bundle
+  puts "T: #{timestamp}, D: #{osc_messages}"
+  osc_messages.each do |path, args|
+    # And this is each message
+    puts "P: #{path}, A: #{args}"
+  end
+end
+*/
+VALUE method_fast_osc_decode(VALUE self, VALUE msg) {
+  VALUE output_ary = rb_ary_new();
+  // If we get != Qnil, then there were no bundles, and we need to add the element
+  VALUE element = method_fast_osc_decode_do(self, msg, output_ary);
+  if (element != Qnil){
+    VALUE element_ary = rb_ary_new();
+    rb_ary_push(element_ary, osc_timetag_to_ruby_time(1));
+    rb_ary_push(element_ary, element);
+    rb_ary_push(output_ary, element_ary);
+  }
+  return output_ary;
+}
+
+VALUE method_fast_osc_decode_do(VALUE self, VALUE msg, VALUE output_ary) {
+  char* data = StringValuePtr(msg);
+  int data_len = RSTRING_LEN(msg);
+  VALUE elements_ary = Qnil;
+  VALUE bundle_output_ary;
+
+  if (rtosc_bundle_p(data)){
+    int n_messages = rtosc_bundle_elements(data, data_len);
+    for (int i = 0; i < n_messages; i++){
+      int message_size = rtosc_bundle_size(data, i);
+      const char *message = rtosc_bundle_fetch(data, i);
+      VALUE rb_message = rb_str_new(message, message_size);
+      VALUE element = method_fast_osc_decode_do(self, rb_message, output_ary);
+      if (element != Qnil){
+        if (elements_ary == Qnil){
+          elements_ary = rb_ary_new();
+        }
+        rb_ary_push(elements_ary, element);
+      }
+    }
+    if (elements_ary != Qnil){
+      uint64_t timetag = rtosc_bundle_timetag(data);
+      bundle_output_ary = rb_ary_new();
+      rb_ary_push(bundle_output_ary, osc_timetag_to_ruby_time(timetag));
+      rb_ary_push(bundle_output_ary, elements_ary);
+      rb_ary_push(output_ary, bundle_output_ary);
+    }
+    return Qnil;
+  }
+  else{
+    VALUE element = method_fast_osc_decode_single_message(self, msg);
+    return element;
+  }
+}
+
 
 VALUE method_fast_osc_decode_single_message(VALUE self, VALUE msg) {
   rtosc_arg_itr_t itr;

data/ext/fast_osc/rtosc.c

@@ -6,7 +6,7 @@
 #include <ctype.h>
 #include <assert.h>
 
-// #include <rtosc.h>
+#include <rtosc.h>
 
 const char *rtosc_argument_string(const char *msg)
 {
@@ -762,7 +762,7 @@ size_t rtosc_bundle_size(const char *buffer, unsigned elm)
     const uint32_t *lengths = (const uint32_t*) (buffer+16);
     size_t elm_pos = 0;
     size_t last_len = 0;
-    while(elm_pos!=elm && extract_uint32((const uint8_t*)lengths)) {
+    while(elm_pos!=elm+1 && extract_uint32((const uint8_t*)lengths)) {
         last_len = extract_uint32((const uint8_t*)lengths);
         ++elm_pos, lengths+=extract_uint32((const uint8_t*)lengths)/4+1;
     }

data/fast_osc.gemspec

@@ -20,7 +20,7 @@ Gem::Specification.new do |spec|
 
   spec.extensions << "ext/fast_osc/extconf.rb"
 
-  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "bundler", "~> 2.0"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rake-compiler"
   spec.add_development_dependency "minitest", "~> 5.0"

data/lib/fast_osc/version.rb

@@ -1,3 +1,3 @@
 module FastOsc
-  VERSION = "0.0.12"
+  VERSION = "1.0.1"
 end

data/test/benchmark_test.rb

@@ -43,7 +43,7 @@ end
 # puts samosc.decode_single_message(test_message).inspect
 puts "DECODING TEST"
 Benchmark.ips do |bencher|
-  bencher.report("fast_osc") { FastOsc.decode_single_message(test_message) }
+  bencher.report("fast_osc") { FastOsc.decode_no_bundles(test_message) }
   bencher.report("samsosc") { samosc.decode_single_message(test_message) }
   bencher.report("osc-ruby") { oscruby.messages_from_network(test_message) }
 

data/test/fast_osc_test.rb

@@ -6,12 +6,34 @@ class FastOscTest < Minitest::Test
   def setup
     @path = "/thisisatest"
     @args = ["", 1, 2.0, "baz", "▁▃▅▇"]
+    @args2 = [1]
+    @args3 = ["somestring", 2]
+    @args4 = [3, 5.0, "another_string"]
     @timestamp = Date.parse("1st Jan 1990").to_time
+    @timestamp2 = Date.parse("21st Mar 2000").to_time
+    @timestamp3 = Date.parse("22nd Jun 2010").to_time
+
 
     @msg0 = OSC::Message.new(@path).encode
     @encoded_msg0 = @msg0.encode
     @msg1 = OSC::Message.new(@path, *@args).encode
     @encoded_msg1 = @msg1.encode
+    @msg2 = OSC::Message.new(@path, *@args2).encode
+    @encoded_msg2 = @msg2.encode
+    @msg3 = OSC::Message.new(@path, *@args3).encode
+    @encoded_msg3 = @msg3.encode
+    @msg4 = OSC::Message.new(@path, *@args4).encode
+    @encoded_msg4 = @msg4.encode
+
+    @bundle = OSC::Bundle.new(@timestamp, @msg1, @msg2)
+    @encoded_bundle = @bundle.encode
+
+    @bundle2 = OSC::Bundle.new(@timestamp2, @msg2, @bundle, @msg3)
+    @encoded_bundle2 = @bundle2.encode
+
+    @bundle3 = OSC::Bundle.new(@timestamp3, @msg4, @bundle2, @msg3, @msg2)
+    @encoded_bundle3 = @bundle3.encode
+
   end
 
   def test_that_it_has_a_version_number
@@ -24,11 +46,16 @@ class FastOscTest < Minitest::Test
     assert_equal msg, @encoded_msg0
   end
 
+
   def test_that_it_decodes_a_single_message
-    path, args = FastOsc.decode_single_message(@encoded_msg0)
+    msgs = FastOsc.decode(@encoded_msg0)
+
+    _timestamp, osc_msgs = msgs[0]
+    path, args = osc_msgs
 
     assert path == @path
     assert args == []
+    assert_nil msgs[1]
   end
 
   def test_that_it_encodes_a_single_message_with_args
@@ -38,12 +65,31 @@ class FastOscTest < Minitest::Test
   end
 
   def test_that_it_decodes_a_single_message_with_args
-    path, args = FastOsc.decode_single_message(@encoded_msg1)
+    msgs = FastOsc.decode(@encoded_msg1)
+
+    _timestamp, osc_msgs = msgs[0]
+    path, args = osc_msgs
+
+    assert_equal path, @path
+    assert_equal args, @args
+    assert_nil msgs[1]
+  end
+
+  def test_that_it_decodes_a_single_message_with_args_knowing_there_are_no_bundles_using_the_decode_function
+    _timestamp, (path, args) =  FastOsc.decode(@encoded_msg1)[0]
+
+    assert_equal path, @path
+    assert_equal args, @args
+  end
+
+  def test_that_it_decodes_a_single_message_with_args_knowing_there_are_no_bundles_using_the_decode_no_bundles_function
+    path, args =  FastOsc.decode_no_bundles(@encoded_msg1)
 
     assert_equal path, @path
     assert_equal args, @args
   end
 
+
   def test_that_it_encodes_a_single_bundle
     bundle1 = OSC::Bundle.new(@timestamp, @msg1).encode
     bundle2 = FastOsc.encode_single_bundle(@timestamp, @path, @args)
@@ -51,6 +97,117 @@ class FastOscTest < Minitest::Test
     assert_equal bundle1, bundle2
   end
 
+  def test_that_it_decodes_a_bundle
+    msgs = FastOsc.decode(@encoded_bundle)
+
+    timestamp, osc_msgs = msgs[0]
+    assert_equal @timestamp, timestamp
+
+    path, args = osc_msgs[0]
+    assert_equal @path, path
+    assert_equal @args, args
+
+    path, args = osc_msgs[1]
+    assert_equal @path, path
+    assert_equal @args2, args
+
+    assert_nil osc_msgs[2]
+    assert_nil msgs[1]
+  end
+
+  def test_that_it_decodes_a_nested_bundle
+    msgs = FastOsc.decode(@encoded_bundle2)
+
+    # Example of how to process the message:
+    #msgs.each do |timestamp, osc_messages|
+      # These are the messages within this bundle
+    #  puts "T: #{timestamp}, M: #{osc_messages}"
+    #  osc_messages.each do |path, args|
+        # And this is each message
+    #    puts "P: #{path}, A: #{args}"
+    #  end
+    #end
+
+    timestamp, osc_msgs = msgs[0]
+    assert_equal @timestamp, timestamp
+
+    path, args = osc_msgs[0]
+    assert_equal @path, path
+    assert_equal @args, args
+
+    path, args = osc_msgs[1]
+    assert_equal @path, path
+    assert_equal @args2, args
+
+    assert_nil osc_msgs[2]
+
+    timestamp, osc_msgs = msgs[1]
+    assert_equal @timestamp2, timestamp
+
+    path, args = osc_msgs[0]
+    assert_equal @path, path
+    assert_equal @args2, args
+
+    path, args = osc_msgs[1]
+    assert_equal @path, path
+    assert_equal @args3, args
+    assert_nil osc_msgs[2]
+
+    assert_nil msgs[2]
+  end
+
+  def test_that_it_decodes_another_nested_bundle
+    msgs = FastOsc.decode(@encoded_bundle3)
+
+    timestamp, osc_msgs = msgs[0]
+    assert_equal @timestamp, timestamp
+
+    path, args = osc_msgs[0]
+    assert_equal @path, path
+    assert_equal @args, args
+
+    path, args = osc_msgs[1]
+    assert_equal @path, path
+    assert_equal @args2, args
+
+    assert_nil osc_msgs[2]
+
+    timestamp, osc_msgs = msgs[1]
+    assert_equal @timestamp2, timestamp
+
+    path, args = osc_msgs[0]
+    assert_equal @path, path
+    assert_equal @args2, args
+
+    path, args = osc_msgs[1]
+    assert_equal @path, path
+    assert_equal @args3, args
+    assert_nil osc_msgs[2]
+
+    timestamp, osc_msgs = msgs[2]
+    assert_equal @timestamp3, timestamp
+
+    path, args = osc_msgs[0]
+    assert_equal @path, path
+    assert_equal @args4, args
+
+    path, args = osc_msgs[1]
+    assert_equal @path, path
+    assert_equal @args3, args
+
+    path, args = osc_msgs[2]
+    assert_equal @path, path
+    assert_equal @args2, args
+
+    assert_nil osc_msgs[3]
+
+
+
+    assert_nil msgs[3]
+
+  end
+
+
   def test_that_it_encodes_a_single_bundle_with_fractional_time
     bundle1 = OSC::Bundle.new(@timestamp + 0.3343215, @msg1).encode
     bundle2 = FastOsc.encode_single_bundle(@timestamp + 0.3343215, @path, @args)
@@ -65,27 +222,8 @@ class FastOscTest < Minitest::Test
     assert_equal bundle1, bundle2
   end
 
-  def test_that_it_encodes_and_decodes_messages_with_symbols
-    path = "/s_new"
-    args = ["sonic-pi-basic_mixer", 10, 0, 2, :amp, 1, :amp_slide, 0.1, :amp_slide_shape, 1, :amp_slide_curve, 0, "in_bus", 12, "amp", 0.3 , "out_bus", 10]
-    outpath, outargs = FastOsc.decode_single_message(FastOsc.encode_single_message(path, args))
-
-    assert_equal path, outpath
-    # normalize symbols to strings, round floats to 5 places
-    assert_equal args.map {|x| x.is_a?(Symbol) ? x.to_s : x}, outargs.map {|x| x.is_a?(Float) ? x.round(5) : x }
-  end
-
-  def test_that_it_encodes_and_decodes_messages_with_timestamps
-    path = "/s_new"
-    args = [Time.at(1463234577.488746)]
-    #args = [Time.at(1463234577.0)]
-    outpath, outargs = FastOsc.decode_single_message(FastOsc.encode_single_message(path, args))
-
-    assert_equal path, outpath
-    assert_equal args.first.to_f.round(5), outargs.first.to_f.round(5)
-  end
 
-  def test_that_encoded_timestamps_line_up
+  def _test_that_encoded_timestamps_line_up
     # this test is a bit convoluted but I found that fractional
     # seconds weren't working when I plugged this into Sonic Pi
     # This test ensures that the timestamp encoding matches to

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fast_osc
 version: !ruby/object:Gem::Version
-  version: 0.0.12
+  version: 1.0.1
 platform: ruby
 authors:
 - Xavier Riley
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-23 00:00:00.000000000 Z
+date: 2019-07-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.5'
+        version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.5'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -103,6 +103,7 @@ extensions:
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -140,7 +141,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.7
+rubygems_version: 2.7.9
 signing_key: 
 specification_version: 4
 summary: Serialize and deserialize Open Sound Control messages