mruby_tools 0.0.3.1 → 0.0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9d06a51f1ed9667b7b39c12bcb3173f4b064d6ad
-  data.tar.gz: e63a21a002b71f1aef930fb5f91950e90757e7c3
+  metadata.gz: 74d761a22e0d9e61ab9da0ea9204690c938b45f4
+  data.tar.gz: 6f4a0f440ce7638f058b4b7631b22c6d8ceb714e
 SHA512:
-  metadata.gz: 566ad106b83ae4838f08d0233f485b910e9f86d484e819c72034b4b9fb36422db9e490bcfc9f0d24add9e0f021d244400b4704644afc38bf508c90f7dff4408f
-  data.tar.gz: 32b9ae7a7685e73e17b23fba501c8036ec04065c9ee46afc97f855fbd6fc2b6cfcf2da4c29df9e685760e27cb0024d08cee470dee46be9aaf099949e1a2a4ad5
+  metadata.gz: 4a90438bfd7b6edd9a91eb87e02be7a6206cd7476a4343de5998a8896578e0fafff3f8f5a5a97efdbf8ff1d8e98c5f4b23da77f5cc78318ca32737c17c93b288
+  data.tar.gz: 8b0e1c387bf140520b1919361aa2d6a753f2e21f4b09188c951d40186bd525a767603ae0c37d649b6e5e7243ae9c40276e53aba2c74e34d682cf6feeb3e4683b

data/README.md

@@ -13,6 +13,15 @@ with **mruby**.
 executable using mruby.  The .rb files must be
 [mruby-compatible](https://github.com/mruby/mruby/blob/master/doc/limitations.md) (roughly equivalent to MRI v1.9).
 
+Two primary modes of operation are supported:
+
+1. ruby code is injected into a C wrapper which is then compiled.  The ruby
+code is **interpreted** every time the resulting binary is executed.
+
+2. ruby code is first interpreted into **bytecode**, and the bytecode
+is injected into a C wrapper which is then compiled.  This means a faster
+runtime as the code interpretation is not performed at runtime.
+
 ## Install
 
 ### `git clone`
@@ -67,16 +76,24 @@ Prerequisites:
 gem install mruby_tools
 ```
 
-Now, `mrbt` may be used.  It will need to know where to find the mruby_dir,
-so specify it with the `-m` flag or `MRUBY_DIR` environment variable.
+Now, `mrbt` may be used.  We set the `MRUBY_DIR` environment variable:
 
 ```shell
-export MRUBY_DIR=~/src/mruby-1.3.0    # or wherever
+export MRUBY_DIR=~/src/mruby-1.3.0    # or wherever it lives
 mrbt file1.rb file2.rb                # etc.
 ```
 
 ## Usage
 
+```
+  USAGE: mrbt file1.rb file2.rb ...
+OPTIONS: -o outfile     (provide a name for the standalone executable)
+         -c generated.c (leave the specified C file on the filesystem)
+         -m mruby_dir   (provide the dir for mruby src)
+         -b             (pregenerate ruby bytecode for faster execution)
+         -v             (verbose)
+```
+
 With no additional options, `mrbt` will inject the contents of file1.rb and
 file2.rb into C strings, to be loaded with mrb_load_nstring(), written to a
 Tempfile.  `mrbt` then compiles the generated .c file using GCC and writes
@@ -97,25 +114,12 @@ rake mrbt -- examples/hello_world.rb examples/goodbye_world.rb -o adios
 
 Other useful rake tasks:
 
-* hello world - compiles and runs `examples/hello_world.rb`
-* timed_simplex - compiles and runs several files that work together
+* hello world     - compiles and runs `examples/hello_world.rb`
+* timed_simplex   - compiles and runs several files that work together
 * raise_exception - compiles and runs `examples/raise.rb`
 * examples - runs hello_world and timed_simplex
-* verbose - add verbose output, e.g. `rake verbose hello_world`
-
-### With *rubygems*
-
-```shell
-mrbt -h
-```
-
-```
-  USAGE: mrbt file1.rb file2.rb ...
-OPTIONS: -o outfile     (provide a name for the standalone executable)
-         -c generated.c (leave the specified C file on the filesystem)
-         -m mruby_dir   (provide the dir for mruby src)
-         -v             (verbose)
-```
+* verbose  - add verbose output, e.g. `rake verbose hello_world`
+* bytecode - enable bytecode generation at compile time
 
 ## Examples
 
@@ -162,7 +166,7 @@ rake verbose hello_world
 ```
 
 ```
-/home/vagrant/.rubies/ruby-2.4.0/bin/ruby -Ilib bin/mrbt examples/hello_world.rb -o examples/hello_world -v
+/home/vagrant/.rubies/ruby-2.4.0/bin/ruby -Ilib bin/mrbt -v examples/hello_world.rb -o examples/hello_world
 #include <stdlib.h>
 #include <mruby.h>
 #include <mruby/compile.h>
@@ -198,21 +202,21 @@ main(void)
   return 0;
 }
 
-generated /tmp/mrbt-20171117-24568-no7ee3.c
+generated /tmp/mrbt-20171122-20650-4pi6tt.c
 compiling...
 created binary executable: examples/hello_world
 
 file examples/hello_world
-examples/hello_world: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=2114ab60983156c92a5a74b88895f9c43a4bb086, not stripped
+examples/hello_world: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=e9fb81e70686e761cf49202efc4f3e733d7aab17, not stripped
 
 stat examples/hello_world
   File: ‘examples/hello_world’
-    Size: 1559056         Blocks: 3048       IO Block: 4096   regular file
-Device: 801h/2049d      Inode: 388049      Links: 1
+  Size: 1631784         Blocks: 3192       IO Block: 4096   regular file
+Device: 801h/2049d      Inode: 388542      Links: 1
 Access: (0755/-rwxr-xr-x)  Uid: ( 1000/ vagrant)   Gid: ( 1000/ vagrant)
-Access: 2017-11-17 18:48:25.713629203 +0000
-Modify: 2017-11-17 18:48:25.709629203 +0000
-Change: 2017-11-17 18:48:25.709629203 +0000
+Access: 2017-11-22 23:42:12.202875568 +0000
+Modify: 2017-11-22 23:42:12.190881566 +0000
+Change: 2017-11-22 23:42:12.190881566 +0000
  Birth: -
 
 examples/hello_world
@@ -224,3 +228,82 @@ This proceeds exactly as before but with additional output:
 * Show the generated C code
 * Note the temporary file containing the C code
 * Call `file` and `stat` on the output executable
+
+### Verbose Bytecode Hello World
+
+```shell
+mrbt -v examples/hello_world.rb -b
+
+# or
+rake mrbt -- -b examples/hello_world.rb -v
+
+# or even
+rake verbose bytecode hello_world
+```
+
+```
+/home/vagrant/.rubies/ruby-2.4.0/bin/ruby -Ilib bin/mrbt -b -v examples/hello_world.rb -o examples/hello_world
+creating bytecode.mrb...
+#include <stdlib.h>
+#include <stdint.h>
+#include <mruby.h>
+#include <mruby/string.h>
+#include <mruby/irep.h>
+
+const uint8_t
+#if defined __GNUC__
+__attribute__((aligned(4)))
+#elif defined _MSC_VER
+__declspec(align(4))
+#endif
+/* bytecode.mrb */
+test_symbol[] = {
+0x52,0x49,0x54,0x45,0x30,0x30,0x30,0x34,0x22,0x80,0x00,0x00,0x00,0x65,0x4d,0x41,0x54,0x5a,0x30,0x30,0x30,0x30,0x49,0x52,0x45,0x50,0x00,0x00,0x00,0x47,0x30,0x30,0x30,0x30,0x00,0x00,0x00,0x3f,0x00,0x01,0x00,0x04,0x00,0x00,0x00,0x00,0x00,0x04,0x00,0x80,0x00,0x06,0x01,0x00,0x00,0x84,0x00,0x80,0x00,0xa0,0x00,0x00,0x00,0x4a,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x00,0x04,0x70,0x75,0x74,0x73,0x00,0x00,0x0b,0x68,0x65,0x6c,0x6c,0x6f,0x5f,0x77,0x6f,0x72,0x6c,0x64,0x00,0x45,0x4e,0x44,0x00,0x00,0x00,0x00,0x08,
+};
+
+void check_exc(mrb_state *mrb) {
+  if (mrb->exc) {
+    mrb_value exc = mrb_obj_value(mrb->exc);
+    mrb_value exc_msg = mrb_funcall(mrb, exc, "to_s", 0);
+    fprintf(stderr, "ERROR %s: %s\n",
+            mrb_obj_classname(mrb, exc),
+            mrb_str_to_cstr(mrb, exc_msg));
+    /* mrb_print_backtrace(mrb);   # empty */
+    exit(1);
+  }
+}
+
+int
+main(void)
+{
+  mrb_state *mrb = mrb_open();
+  if (!mrb) {
+    printf("mrb problem");
+    exit(1);
+  }
+  mrb_load_irep(mrb, test_symbol);
+  check_exc(mrb);
+  mrb_close(mrb);
+  return 0;
+}
+
+generated /tmp/mrbt-20171122-25456-azsw3n.c
+compiling...
+created binary executable: examples/hello_world
+
+file examples/hello_world
+examples/hello_world: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=61e903e56a9e5d1159cb5a5ea4a669b05b493f44, not stripped
+
+stat examples/hello_world
+  File: ‘examples/hello_world’
+  Size: 1324616   	Blocks: 2592       IO Block: 4096   regular file
+Device: 801h/2049d	Inode: 388542      Links: 1
+Access: (0755/-rwxr-xr-x)  Uid: ( 1000/ vagrant)   Gid: ( 1000/ vagrant)
+Access: 2017-11-22 23:46:09.540147567 +0000
+Modify: 2017-11-22 23:46:09.536149567 +0000
+Change: 2017-11-22 23:46:09.536149567 +0000
+ Birth: -
+
+examples/hello_world
+hello_world
+```

data/Rakefile

@@ -37,8 +37,15 @@ task :verbose do
   @verbose = true
 end
 
+@bytecode = false
+
+task :bytecode do
+  @bytecode = true
+end
+
 def mrbt *args
   args.unshift('-v') if @verbose and !args.include?('-v')
+  args.unshift('-b') if @bytecode and !args.include?('-b')
   ruby '-Ilib', 'bin/mrbt', *args
 end
 

data/VERSION

@@ -1 +1 @@
-0.0.3.1
+0.0.4.1

data/bin/mrbt

@@ -1,6 +1,5 @@
 #!/usr/bin/env ruby
 
-require 'tempfile'
 require 'mruby_tools'
 
 # args like: file1.rb file2.rb -o outfile
@@ -9,18 +8,35 @@ require 'mruby_tools'
 opts = MRubyTools::CLI.args(ARGV)
 MRubyTools::CLI.usage if opts[:help]
 
+FAIL_MRUBY_NOT_FOUND = 1
+FAIL_MRBC_BYTECODE = 1
+FAIL_GCC = 1
+
+
 mrb = MRubyTools.new(opts[:mruby_dir]) # nil is fine
 begin
   mrb.validate!
 rescue MRubyTools::MRubyNotFound => e
   warn "#{e.class}: can't find #{e}"
-  exit 1
+  exit FAIL_MRUBY_NOT_FOUND
 end
 
 rb_files = opts.fetch(:rb_files)
 MRubyTools::CLI.usage("no .rb files provided") if rb_files.empty?
 
-c_code = MRubyTools::C.wrapper(rb_files)
+# inject a string vs create and inject bytecode
+if opts[:bytecode]
+  bc_file = 'bytecode.mrb'
+  puts "creating #{bc_file}..."
+  if mrb.mrbc rb_files, bc_file
+    c_code = MRubyTools::C.bytecode_wrapper(bc_file)
+  else
+    warn "FATAL: mrbc bytecode generation failed"
+    exit FAIL_MRBC_BYTECODE
+  end
+else
+  c_code = MRubyTools::C.wrapper(rb_files)
+end
 puts c_code + "\n" if opts[:verbose]
 
 c_file = opts.fetch(:c_file)
@@ -34,5 +50,5 @@ if mrb.compile(c_file.path, out_file)
   puts "created binary executable: #{out_file}"
 else
   warn "FATAL: compile failed"
-  exit 1
+  exit FAIL_GCC
 end

data/lib/mruby_tools.rb

@@ -9,12 +9,13 @@ class MRubyTools
     ENV['MRUBY_DIR'] || MRUBY_DIR
   end
 
-  attr_accessor :mruby_dir, :inc_path, :ar_path
+  attr_accessor :mruby_dir, :inc_path, :ar_path, :bin_path
 
   def initialize(mruby_dir = nil)
     @mruby_dir = mruby_dir || self.class.mruby_dir
     @inc_path = File.join(@mruby_dir, 'include')
     @ar_path = File.join(@mruby_dir, 'build', 'host', 'lib', 'libmruby.a')
+    @bin_path = File.join(@mruby_dir, 'bin')
   end
 
   def src?
@@ -28,6 +29,7 @@ class MRubyTools
   def validate!
     raise(MRubyNotFound, @inc_path) unless File.directory? @inc_path
     raise(MRubyNotFound, @ar_path) unless File.readable? @ar_path
+    raise(MRubyNotFound, @bin_path) unless File.directory? @bin_path
     self
   end
 
@@ -39,7 +41,80 @@ class MRubyTools
     system('gcc', *self.gcc_args(c_file, out_file))
   end
 
+  # interpret several rb_files into a binary out_file contaning bytecode
+  def mrbc(rb_files, out_file)
+    system(File.join(@bin_path, 'mrbc'), '-o', out_file, *rb_files)
+  end
+
   module C
+    def self.slurp_mrb(bc_file, indent: '  ')
+      test_symbol = File.read(bc_file).each_byte.reduce('') { |memo, b|
+        memo + format("0x%0.2x,", b.ord)
+      }
+      ["/* #{bc_file} */",
+       "test_symbol[] = {",
+       test_symbol,
+       "};",
+      ].map { |s| indent + s }.join("\n")
+    end
+
+    def self.slurp_rb(rb_filename, indent: '  ')
+      c_str = File.read(rb_filename)
+      size = c_str.size
+      c_str = c_str.gsub("\n", '\n').gsub('"', '\"')
+      [ "/* #{rb_filename} */",
+        'mrb_load_nstring(mrb, "' + c_str + '", ' + "#{size});",
+        "check_exc(mrb, \"#{rb_filename}\");",
+      ].map { |s| indent + s }.join("\n")
+    end
+
+    def self.bytecode_wrapper(bc_file)
+      c_code = <<'EOF'
+#include <stdlib.h>
+#include <stdint.h>
+#include <mruby.h>
+#include <mruby/string.h>
+#include <mruby/irep.h>
+
+const uint8_t
+#if defined __GNUC__
+__attribute__((aligned(4)))
+#elif defined _MSC_VER
+__declspec(align(4))
+#endif
+EOF
+      c_code += slurp_mrb(bc_file, indent: '') + "\n\n"
+
+      c_code += <<'EOF'
+void check_exc(mrb_state *mrb) {
+  if (mrb->exc) {
+    mrb_value exc = mrb_obj_value(mrb->exc);
+    mrb_value exc_msg = mrb_funcall(mrb, exc, "to_s", 0);
+    fprintf(stderr, "ERROR %s: %s\n",
+            mrb_obj_classname(mrb, exc),
+            mrb_str_to_cstr(mrb, exc_msg));
+    /* mrb_print_backtrace(mrb);   # empty */
+    exit(1);
+  }
+}
+
+int
+main(void)
+{
+  mrb_state *mrb = mrb_open();
+  if (!mrb) {
+    printf("mrb problem");
+    exit(1);
+  }
+  mrb_load_irep(mrb, test_symbol);
+  check_exc(mrb);
+  mrb_close(mrb);
+  return 0;
+}
+EOF
+      c_code
+    end
+
     def self.wrapper(rb_files)
       c_code = <<'EOF'
 #include <stdlib.h>
@@ -80,29 +155,22 @@ EOF
 EOF
       c_code
     end
-
-    def self.slurp_rb(rb_filename, indent: '  ')
-      c_str = File.read(rb_filename)
-      size = c_str.size
-      c_str = c_str.gsub("\n", '\n').gsub('"', '\"')
-      [ "/* #{rb_filename} */",
-        'mrb_load_nstring(mrb, "' + c_str + '", ' + "#{size});",
-        "check_exc(mrb, \"#{rb_filename}\");",
-      ].map { |s| indent + s }.join("\n")
-    end
   end
 
   module CLI
+    USAGE_EXIT = 1
+
     def self.usage(msg = nil)
       puts <<EOF
   USAGE: mrbt file1.rb file2.rb ...
 OPTIONS: -o outfile     (provide a name for the standalone executable)
          -c generated.c (leave the specified C file on the filesystem)
          -m mruby_dir   (provide the dir for mruby src)
+         -b             (pregenerate ruby bytecode for faster execution)
          -v             (verbose)
 EOF
       warn "  ERROR: #{msg}" if msg
-      exit(msg ? 1 : 0)
+      exit(msg ? USAGE_EXIT : 0)
     end
 
     def self.args(argv = ARGV)
@@ -112,6 +180,7 @@ EOF
       mruby_dir = nil
       verbose = false
       help = false
+      bytecode = false
 
       while !argv.empty?
         arg = argv.shift
@@ -128,19 +197,23 @@ EOF
         elsif arg == '-m'
           mruby_dir = argv.shift
           raise "no mruby_dir provided with -m" unless mruby_dir
+        elsif arg == '-b'
+          bytecode = true
         else
-          rb_files << arg
+          rb_files << arg unless arg == '--'
         end
       end
 
       c_file ||= Tempfile.new(['mrbt-', '.c'])
+      out_file ||= 'outfile'
 
       { verbose: verbose,
         help: help,
         c_file: c_file,
-        out_file: out_file || 'outfile',
+        out_file: out_file,
         rb_files: rb_files,
-        mruby_dir: mruby_dir }
+        mruby_dir: mruby_dir,
+        bytecode: bytecode }
     end
   end
 end

data/test/mruby_tools.rb

@@ -18,9 +18,11 @@ describe MRubyTools do
         obj.mruby_dir.must_be_kind_of String
         obj.inc_path.must_be_kind_of String
         obj.ar_path.must_be_kind_of String
+        obj.bin_path.must_be_kind_of String
       }
       @valid.inc_path.must_match %r{include}
       @valid.ar_path.must_match %r{libmruby.a}
+      @valid.bin_path.must_match %r{bin}
     end
   end
 
@@ -29,8 +31,19 @@ describe MRubyTools do
       str = MRubyTools::C.slurp_rb(__FILE__)
       str.must_be_kind_of String
       str.wont_be_empty
-      str.must_match(/mrb_load_n?string\(/)
-      str.must_match(/exc/)
+      str.must_match %r{mrb_load_n?string\(}
+      str.must_match %r{exc}
+    end
+  end
+
+  describe "C.slurp_mrb" do
+    it "must inject the contents of a bytecode file into test_symbol[]" do
+      # bytecode is pure binary -- it doesn't matter what file we provide
+      str = MRubyTools::C.slurp_mrb(__FILE__)
+      str.must_be_kind_of String
+      str.wont_be_empty
+      str.must_match %r{test_symbol}
+      str.must_match %r{0x\d\d,}
     end
   end
 
@@ -40,15 +53,28 @@ describe MRubyTools do
         str = MRubyTools::C.wrapper(rb_files)
         str.must_be_kind_of String
         str.wont_be_empty
-        str.must_match(/main\(void\)/)
-        str.must_match(/return/)
-        str.must_match(/exit/)
-        str.must_match(/mruby/)
-        str.must_match(/mrb/)
+        str.must_match %r{main\(void\)}
+        str.must_match %r{return}
+        str.must_match %r{exit}
+        str.must_match %r{mruby}
+        str.must_match %r{mrb}
       }
     end
   end
 
+  describe "C.bytecode_wrapper" do
+    it "must return a string of mruby C code" do
+      str = MRubyTools::C.bytecode_wrapper(__FILE__)
+      str.must_be_kind_of String
+      str.wont_be_empty
+      str.must_match %r{main\(void\)}
+      str.must_match %r{return}
+      str.must_match %r{exit}
+      str.must_match %r{mruby}
+      str.must_match %r{mrb}
+    end
+  end
+
   describe "CLI.args" do
     it "must provide a hash with expected keys" do
       h = MRubyTools::CLI.args([])

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mruby_tools
 version: !ruby/object:Gem::Version
-  version: 0.0.3.1
+  version: 0.0.4.1
 platform: ruby
 authors:
 - Rick Hull
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-11-22 00:00:00.000000000 Z
+date: 2017-11-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake