therubyracer-st 0.11.0beta5-x86-mingw32

data/Rakefile

@@ -0,0 +1,58 @@
+#!/usr/bin/env rake
+require 'bundler/setup'
+require "bundler/gem_tasks"
+
+task :clean do
+  sh "rm -rf lib/v8/init.bundle lib/v8/init.so"
+  sh "rm -rf pkg"
+end
+
+GEMSPEC = eval(File.read("therubyracer.gemspec"))
+
+require File.expand_path('../lib/v8/helper', __FILE__)
+if V8::mingw?
+  GEMSPEC.files += ["vendor/v8.dll"]
+end
+
+require "rake/extensiontask"
+Rake::ExtensionTask.new("init", GEMSPEC) do |ext|
+  ext.ext_dir = "ext/v8"
+  ext.lib_dir = "lib/v8"
+  ext.source_pattern = "*.{cc,h}"
+end
+
+if V8::mingw?
+  task "v8:copy" do
+    abort "unable to find v8.dll" unless V8::v8_path
+    rm_rf "vendor"
+    mkdir "vendor"
+    cp File.join(V8::v8_path, "v8.dll"), "vendor"
+  end
+  [:compile, :native].each do |task|
+    Rake::Task[task].prerequisites.unshift "v8:copy"
+  end
+end
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |task|
+  task.rspec_opts = '--tag ~memory --tag ~threads'
+end
+
+task :sanity => [:clean, :compile] do
+  sh %q{ruby -Ilib -e "require 'v8'"}
+end
+
+NativeGem = "therubyracer-#{V8::VERSION}-#{Gem::Platform.new(RUBY_PLATFORM)}.gem"
+
+task :gem # dummy task
+
+desc "Build #{NativeGem} into the pkg directory"
+task "build:native" => [:native, :gem]
+
+desc "Build and install #{NativeGem} into system gems"
+task "install:native" => "build:native" do
+  sh "gem install pkg/#{NativeGem}"
+end
+
+task :default => :spec
+

data/benchmarks.rb

@@ -0,0 +1,217 @@
+require 'bundler/setup'
+require 'v8'
+require 'benchmark'
+require 'optparse'
+
+OPTIONS = {
+  :times => 5,
+  :mode => :object,
+  :objects => 500
+}
+
+parser = OptionParser.new do |opts|
+  opts.on("-t", "--times [T]", Integer, "run benchmark N times") do |t|
+    OPTIONS[:times] = t
+  end
+
+  opts.on("-m", "--mode [MODE]", [:object, :function, :eval], "select the type of object access to stress test") do |mode|
+    mode = mode.to_sym
+    raise "unsupported mode #{mode}" unless [:object,:function,:eval].include?(mode)
+    OPTIONS[:mode] = mode
+  end
+
+  opts.on("-o", "--objects [N]", Integer, "create N objects for each iteration") do |n|
+    OPTIONS[:objects] = n
+  end
+  opts
+end
+
+parser.parse! ARGV
+
+MODE = OPTIONS[:mode]
+TIMES = OPTIONS[:times]
+OBJECTS = OPTIONS[:objects]
+
+puts "using #{OPTIONS[:mode]}"
+if MODE==:object
+    def get(i)
+      @cxt["test"]["objects"][i]
+    end
+elsif  MODE==:function
+    def get(i)
+      @cxt["test"].getObject(i)
+    end
+elsif  MODE==:eval
+    def get(i)
+      @cxt.eval "test.getObject(#{i})"
+    end
+end
+
+js= <<JS
+
+function createTest()
+{
+    var test = {};
+    test.objects = [];
+    test.seed = 49734321;
+    test.summ;
+
+    test.random = function()
+    {
+        // Robert Jenkins' 32 bit integer hash function.
+        test.seed = ((test.seed + 0x7ed55d16) + (test.seed << 12))  & 0xffffffff;
+        test.seed = ((test.seed ^ 0xc761c23c) ^ (test.seed >>> 19)) & 0xffffffff;
+        test.seed = ((test.seed + 0x165667b1) + (test.seed << 5))   & 0xffffffff;
+        test.seed = ((test.seed + 0xd3a2646c) ^ (test.seed << 9))   & 0xffffffff;
+        test.seed = ((test.seed + 0xfd7046c5) + (test.seed << 3))   & 0xffffffff;
+        test.seed = ((test.seed ^ 0xb55a4f09) ^ (test.seed >>> 16)) & 0xffffffff;
+        return (test.seed & 0xfffffff) / 0x10000000;
+    };
+
+    test.init = function()
+    {
+        test.objects = [];
+        for(var i=0; i<#{OBJECTS}; i++)
+        {
+            var hash = {};
+            for(var j=0; j<10; j++)
+            {
+                var isString = test.random();
+                var key = "str" + test.random();
+                var value;
+                if(isString < 0.5)
+                    value = "str" + test.random();
+                else
+                    value = test.random();
+                hash[key] = value;
+            }
+            test.objects[i] = hash;
+        }
+        return test.objects.length;
+    }
+
+    test.findSum = function()
+    {
+        test.summ = 0;
+        var length = test.objects.length;
+        for(var i=0; i<length; i++)
+        {
+            var hash = test.objects[i];
+            for (var k in hash)
+            {
+                if (hash.hasOwnProperty(k) && (typeof(hash[k]) == "number"))
+                {
+                    test.summ += hash[k];
+                }
+            }
+        }
+        return test.summ;
+    };
+
+    test.finalCheck = function()
+    {
+        var summ = 0;
+        var length = test.objects.length;
+        for(var i=0; i<length; i++)
+        {
+            var hash = test.objects[i];
+            for (var k in hash)
+            {
+                if (hash.hasOwnProperty(k) && (typeof(hash[k]) == "number"))
+                {
+                    summ += hash[k];
+                }
+            }
+        }
+        return summ ;
+    };
+
+    test.getObject = function(index)
+    {
+        if(!test.objects[index]) return {};
+        return test.objects[index];
+    }
+
+    test.setObject = function(index, object)
+    {
+        test.objects[index] = object;
+    }
+
+    return test;
+}
+
+JS
+
+
+
+
+
+def profile
+ Benchmark.realtime do
+    yield
+   end
+end
+
+def get_res result
+  result.to_f
+end
+
+
+
+
+
+puts "init js context..."
+cxt = V8::Context.new
+@cxt=cxt
+cxt.eval(js)
+
+cxt.eval('var test = createTest()')
+
+puts "run init test"
+result =profile do
+  TIMES.times do
+    cxt['test'].init()
+  end
+end
+
+puts "init time: #{get_res(result) / TIMES} sec."
+sum1=sum2=0
+puts "run findSum test"
+
+result =profile do
+  TIMES.times do
+      sum1= cxt['test'].findSum
+  end
+end
+
+puts "findSum time: #{get_res(result) / TIMES} sec."
+
+
+puts "run Objects inversion in ruby test"
+result =profile do
+  TIMES.times do |j|
+    puts j
+    for i in 0..(OBJECTS-1) do
+      obj = get(i)
+      obj.each do |key, value|
+        if value.instance_of? Float
+          obj[key] = value * (-1)
+        end
+      end
+    end
+  end
+end
+
+puts "Objects time: #{get_res(result) / TIMES} sec."
+
+puts "run finalCheck test"
+
+
+result =profile do
+  TIMES.times do
+    sum2= cxt['test'].findSum
+  end
+end
+
+puts "final check time: #{get_res(result) / TIMES} sec."
+puts "#{sum1==sum2*(TIMES%2==0?1:-1) ? 'TEST PASS': 'TEST FAIL'}:  Sum before inversions: #{sum1} / Sum after inversions: #{sum2}"

data/ext/v8/accessor.cc

@@ -0,0 +1,181 @@
+#include "rr.h"
+
+namespace rr {
+
+  VALUE Accessor::Info::Class;
+
+  void Accessor::Init() {
+    ClassBuilder("AccessorInfo").
+      defineMethod("This", &Info::This).
+      defineMethod("Holder", &Info::Holder).
+      defineMethod("Data", &Info::Data).
+      store(&Info::Class);
+  }
+
+  Accessor::Accessor(VALUE getter, VALUE setter, VALUE data_) : get(getter), set(setter), data(data_) {}
+
+  Accessor::Accessor(VALUE get, VALUE set, VALUE query, VALUE deleter, VALUE enumerator, VALUE data) {
+    this->get = get;
+    this->set = set;
+    this->query = query;
+    this->deleter = deleter;
+    this->enumerator = enumerator;
+    this->data = data;
+  }
+
+  Accessor::Accessor(v8::Handle<v8::Value> value) {
+    v8::Local<v8::Object> wrapper = value->ToObject();
+    this->get = unwrap(wrapper, 0);
+    this->set = unwrap(wrapper, 1);
+    this->query = unwrap(wrapper, 2);
+    this->deleter = unwrap(wrapper, 3);
+    this->enumerator = unwrap(wrapper, 4);
+    v8::Handle<v8::Value> data = wrapper->Get(5);
+    if (!data.IsEmpty()) {
+      this->data = Value(data);
+    }
+  }
+
+  Accessor::operator v8::Handle<v8::Value>() {
+    v8::Local<v8::Object> wrapper = v8::Object::New();
+    wrap(wrapper, 0, this->get);
+    wrap(wrapper, 1, this->set);
+    wrap(wrapper, 2, this->query);
+    wrap(wrapper, 3, this->deleter);
+    wrap(wrapper, 4, this->enumerator);
+    if (RTEST(this->data)) {
+      wrapper->Set(5, Value(this->data));
+    }
+    return wrapper;
+  }
+
+  void Accessor::wrap(v8::Handle<v8::Object> wrapper, int index, VALUE value) {
+    if (RTEST(value)) {
+      wrapper->Set(index, External::wrap(value));
+    }
+  }
+
+  VALUE Accessor::unwrap(v8::Handle<v8::Object> wrapper, int index) {
+    v8::Handle<v8::Value> value = wrapper->Get(index);
+    if (value.IsEmpty()) {
+      return Qnil;
+    } else {
+      v8::Handle<v8::External> external(v8::External::Cast(*value));
+      return External::unwrap(external);
+    }
+  }
+
+
+  VALUE Accessor::Info::This(VALUE self) {
+    return Object(Info(self)->This());
+  }
+
+  VALUE Accessor::Info::Holder(VALUE self) {
+    return Object(Info(self)->Holder());
+  }
+
+  VALUE Accessor::Info::Data(VALUE self) {
+    return Accessor(Info(self)->Data()).data;
+  }
+
+  v8::Handle<v8::Value> Accessor::AccessorGetter(v8::Local<v8::String> property, const v8::AccessorInfo& info) {
+    return Info(info).get(property);
+  }
+
+  void Accessor::AccessorSetter(v8::Local<v8::String> property, v8::Local<v8::Value> value, const v8::AccessorInfo& info) {
+    Info(info).set(property, value);
+  }
+  v8::Handle<v8::Value> Accessor::NamedPropertyGetter(v8::Local<v8::String> property, const v8::AccessorInfo& info) {
+    return Info(info).get(property);
+  }
+  v8::Handle<v8::Value> Accessor::NamedPropertySetter(v8::Local<v8::String> property, v8::Local<v8::Value> value, const v8::AccessorInfo& info) {
+    return Info(info).set(property, value);
+  }
+  v8::Handle<v8::Integer> Accessor::NamedPropertyQuery(v8::Local<v8::String> property, const v8::AccessorInfo& info) {
+    return Info(info).query(property);
+  }
+  v8::Handle<v8::Boolean> Accessor::NamedPropertyDeleter(v8::Local<v8::String> property, const v8::AccessorInfo& info) {
+    return Info(info).remove(property);
+  }
+  v8::Handle<v8::Array> Accessor::NamedPropertyEnumerator(const v8::AccessorInfo& info) {
+    return Info(info).enumerateNames();
+  }
+
+  v8::Handle<v8::Value> Accessor::IndexedPropertyGetter(uint32_t index, const v8::AccessorInfo& info) {
+    return Info(info).get(index);
+  }
+  v8::Handle<v8::Value> Accessor::IndexedPropertySetter(uint32_t index, v8::Local<v8::Value> value, const v8::AccessorInfo& info) {
+    return Info(info).set(index, value);
+  }
+  v8::Handle<v8::Integer> Accessor::IndexedPropertyQuery(uint32_t index, const v8::AccessorInfo& info) {
+    return Info(info).query(index);
+  }
+  v8::Handle<v8::Boolean> Accessor::IndexedPropertyDeleter(uint32_t index, const v8::AccessorInfo& info) {
+    return Info(info).remove(index);
+  }
+  v8::Handle<v8::Array> Accessor::IndexedPropertyEnumerator(const v8::AccessorInfo& info) {
+    return Info(info).enumerateIndices();
+  }
+
+  Accessor::Info::Info(const v8::AccessorInfo& info) {
+    this->info = &info;
+  }
+
+  Accessor::Info::Info(VALUE value) {
+    Data_Get_Struct(value, class v8::AccessorInfo, info);
+  }
+
+  v8::Handle<v8::Value> Accessor::Info::get(v8::Local<v8::String> property) {
+    Accessor accessor(info->Data());
+    return Value(rb_funcall(accessor.get, rb_intern("call"), 2, (VALUE)String(property), (VALUE)*this));
+  }
+
+  v8::Handle<v8::Value> Accessor::Info::set(v8::Local<v8::String> property, v8::Local<v8::Value> value) {
+    Accessor accessor(info->Data());
+    return Value(rb_funcall(accessor.set, rb_intern("call"), 3, (VALUE)String(property), (VALUE)Value(value), (VALUE)*this));
+  }
+
+  v8::Handle<v8::Integer> Accessor::Info::query(v8::Local<v8::String> property) {
+    Accessor accessor(info->Data());
+    return v8::Integer::New(NUM2INT(rb_funcall(accessor.query, rb_intern("call"), 2, (VALUE)String(property), (VALUE)*this)));
+  }
+
+  v8::Handle<v8::Boolean> Accessor::Info::remove(v8::Local<v8::String> property) {
+    Accessor accessor(info->Data());
+    return v8::Boolean::New(Bool(rb_funcall(accessor.deleter, rb_intern("call"), 2, (VALUE)String(property), (VALUE)*this)));
+  }
+
+  v8::Handle<v8::Array> Accessor::Info::enumerateNames() {
+    Accessor accessor(info->Data());
+    return Array(rb_funcall(accessor.enumerator, rb_intern("call"), 1, (VALUE)*this));
+  }
+
+  v8::Handle<v8::Value> Accessor::Info::get(uint32_t index) {
+    Accessor accessor(info->Data());
+    return Value(rb_funcall(accessor.get, rb_intern("call"), 2, UINT2NUM(index), (VALUE)*this));
+  }
+
+  v8::Handle<v8::Value> Accessor::Info::set(uint32_t index, v8::Local<v8::Value> value) {
+    Accessor accessor(info->Data());
+    return Value(rb_funcall(accessor.set, rb_intern("call"), 3, UINT2NUM(index), (VALUE)Value(value), (VALUE)*this));
+  }
+
+  v8::Handle<v8::Integer> Accessor::Info::query(uint32_t index) {
+    Accessor accessor(info->Data());
+    return v8::Integer::New(NUM2INT(rb_funcall(accessor.query, rb_intern("call"), 2, UINT2NUM(index), (VALUE)*this)));
+  }
+
+  v8::Handle<v8::Boolean> Accessor::Info::remove(uint32_t index) {
+    Accessor accessor(info->Data());
+    return v8::Boolean::New(Bool(rb_funcall(accessor.deleter, rb_intern("call"), 2, UINT2NUM(index), (VALUE)*this)));
+  }
+
+  v8::Handle<v8::Array> Accessor::Info::enumerateIndices() {
+    Accessor accessor(info->Data());
+    return Array(rb_funcall(accessor.enumerator, rb_intern("call"), 1, (VALUE)*this));
+  }
+
+  Accessor::Info::operator VALUE() {
+    return Data_Wrap_Struct(Class, 0, 0, (void*)this->info);
+  }
+}