delta/ruby.git/benchmark, branch ruby_2_2

merge revision(s) 50084: [Backport #10999]

2015-05-19T18:11:15+00:00

	* benchmark/bm_hash_aref_flo.rb: make more realistic data.
	  [ruby-core:68632] [[Bug #10999]


git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/branches/ruby_2_2@50547 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

merge revision(s) 49376,49387,49389: [Backport #10761]

2015-02-05T16:05:10+00:00

	* st.c (st_numhash): mix float value for flonum

	* hash.c (rb_any_hash): ditto

	* benchmark/bm_hash_aref_flo.rb: new benchmark

	* benchmark/bm_hash_ident_flo.rb: ditto
	  [Bug #10761]

	* benchmark/bm_marshal_dump_flo.rb: new benchmark for [Bug #10761]

	* marshal.c (w_object, marshal_dump): use indetity tables for
	  arbitrary VALUE keys, because of performance of FLONUM.
	  [Bug #10761]

	* marshal.c (obj_alloc_by_klass, marshal_load): ditto.


git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/branches/ruby_2_2@49513 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

struct: avoid all O(n) behavior on access

2014-12-09T15:43:49+00:00

This avoids O(n) on lookups with structs over 10 members.
This also avoids O(n) behavior on all assignments on Struct members.
Members 0..9 still use existing C methods to read in O(1) time

Benchmark results:

vm2_struct_big_aref_hi*	1.305
vm2_struct_big_aref_lo*	1.157
vm2_struct_big_aset*	3.306
vm2_struct_small_aref*	1.015
vm2_struct_small_aset*	3.273

Note: I chose use loading instructions from an array instead of writing
directly to linked-lists in compile.c for ease-of-maintainability.  We
may move the method definitions to prelude.rb-like files in the future.

I have also tested this patch with the following patch to disable
the C ref_func methods and ensured the test suite and rubyspec works

	--- a/struct.c
	+++ b/struct.c
	@@ -209,7 +209,7 @@ setup_struct(VALUE nstr, VALUE members)
		ID id = SYM2ID(ptr_members[i]);
		VALUE off = LONG2NUM(i);

	-	if (i < N_REF_FUNC) {
	+	if (0 && i < N_REF_FUNC) {
		    rb_define_method_id(nstr, id, ref_func[i], 0);
		}
		else {

* iseq.c (rb_method_for_self_aref, rb_method_for_self_aset):
  new methods to generate bytecode for struct.c
  [Feature #10575]
* struct.c (rb_struct_ref, rb_struct_set): remove
  (define_aref_method, define_aset_method): new functions
  (setup_struct): use new functions
* test/ruby/test_struct.rb: add test for struct >10 members
* benchmark/bm_vm2_struct_big_aref_hi.rb: new benchmark
* benchmark/bm_vm2_struct_big_aref_lo.rb: ditto
* benchmark/bm_vm2_struct_big_aset.rb: ditto
* benchmark/bm_vm2_struct_small_aref.rb: ditto
* benchmark/bm_vm2_struct_small_aset.rb: ditto

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@48748 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

benchmark/bm_hash_aref_sym*.rb: force static symbols

2014-10-09T03:44:12+00:00

Dynamic symbols hash more slowly because they need extra method
dispatch in rb_any_hash.  I am not sure if dynamic symbols are
a realistic use case as hash keys, so this commit only
restores performance when comparing against versions of Ruby
which lack dsyms.

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@47854 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

bm_app_aobench.rb: update links [ci skip]

2014-09-16T10:18:53+00:00

* benchmark/bm_app_aobench.rb: update outdated links to the
  original program.  [ruby-dev:48550] [Feature #10247]

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@47603 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

benchmark/bm_app_aobench.rb: spelling fix [ci skip]

2014-09-15T07:17:37+00:00

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@47593 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

proc.c (rb_proc_alloc): inline and move to vm.c

2014-09-12T20:57:45+00:00

* proc.c (rb_proc_alloc): inline and move to vm.c
  (rb_proc_wrap): new wrapper function used by rb_proc_alloc
  (proc_dup): simplify alloc + copy + wrap operation
  [ruby-core:64994]

* vm.c (rb_proc_alloc): new inline function
  (rb_vm_make_proc): call rb_proc_alloc

* vm_core.h: remove rb_proc_alloc, add rb_proc_wrap

* benchmark/bm_vm2_newlambda.rb: short test to show difference

First we allocate and populate an rb_proc_t struct inline to avoid
unnecessary zeroing of the large struct.  Inlining speeds up callers as
this takes many parameters to ensure correctness.  We then call the new
rb_proc_wrap function to create the object.

rb_proc_wrap - wraps a rb_proc_t pointer as a Ruby object, but
we only use it inside rb_proc_alloc.  We must call this before
the compiler may clobber VALUE parameters passed to rb_proc_alloc.

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@47562 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

* benchmark/bm_app_lc_fizzbuzz.rb: should skip output on benchmark.

2014-09-08T07:08:56+00:00

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@47450 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

* benchmark/bm_app_lc_fizzbuzz.rb: `answer.to_a' does not return

2014-09-08T07:08:00+00:00

  a string, but an array.



git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@47449 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

* benchmark/bm_app_lc_fizzbuzz.rb: added.

2014-09-08T04:22:58+00:00

  This program is described closely in "Understanding Computation"
  chapter 6 by Tom Stuart. 
  Japanese translation will be published soon.
  



git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@47447 b2dd03c8-39d4-4d8f-98ff-823fe69b080e