ruote 0.9.18

data/test/bm/bm_1_xml_vs_prog.rb

@@ -0,0 +1,56 @@
+
+#
+# a bit of benchmark
+#
+# Thu Nov  8 21:48:20 JST 2007
+#
+
+require 'benchmark'
+
+require 'openwfe/def'
+#require 'openwfe/engine/engine'
+require 'openwfe/engine/file_persisted_engine'
+
+
+class ProgDef < OpenWFE::ProcessDefinition
+    sequence do
+        toto
+        toto
+        toto
+        toto
+        toto
+    end
+end
+
+xml = <<END
+<process-definition name="x" revision="y">
+    <sequence>
+        <toto/>
+        <toto/>
+        <toto/>
+        <toto/>
+        <toto/>
+    </sequence>
+</process-definition>
+END
+
+#$engine = OpenWFE::Engine.new
+$engine = OpenWFE::FilePersistedEngine.new
+
+$engine.register_participant "toto" do |workitem|
+    # do nothing
+end
+
+N = 500
+
+def test (proc_def)
+    N.times do 
+        fei = $engine.launch proc_def
+        $engine.wait_for fei
+    end
+end
+
+Benchmark.bm do |x|
+    x.report("prog :") { test ProgDef }
+    x.report("xml :") { test xml.strip }
+end

data/test/bm/bm_2_step.rb

@@ -0,0 +1,109 @@
+
+#
+# Benchmarking / testing Ruote
+#
+# John Mettraux at openwfe.org
+#
+# Tue May 13 15:03:41 JST 2008
+#
+
+require 'rubygems'
+
+require 'openwfe/def'
+
+require 'flowtestbase'
+
+
+class FlowTestRecursion < Test::Unit::TestCase
+    include FlowTestBase
+
+    #def teardown
+    #end
+
+    #def setup
+    #end
+
+    #
+    # test 0
+    #
+
+    #N = 500
+    N = 100
+
+    #
+    # Test0, N=100
+    #
+    # Tue May 13 17:24:53 JST 2008
+    #
+    # without substitution :
+    # q : 2.72s
+    # p : 752s
+    #
+    # with substitution :
+    # q : 2.67s
+    # p : 715s
+    # (c : 10s)
+    #
+    # => :(
+    #
+    # with substitution : stack grows to 515 exps
+    # without : stack grows to 615 exps
+    #
+
+    #
+    # chaining N steps
+    #
+    # (took 39 seconds the first time for N = 500)
+    #
+    class Test0 < OpenWFE::ProcessDefinition
+
+        step0
+
+        (0..N).each do |i|
+            define "stage#{i}" do
+                sequence do
+                    _print "stage#{i}"
+                    set :f => 'outcome', :val => "step#{i+1}"
+                    #_print "${r:fexp.get_expression_storage.size}" if i == N
+                end
+            end
+            define "step#{i}" do
+                step "stage#{i}"
+            end
+        end
+
+        define "step#{N+1}" do
+            _print "over."
+        end
+    end
+
+    #
+    # testing against a sequence of N subprocess calls
+    #
+    # (took 6 seconds the first time for N = 500)
+    # (just chaining N 'print "stage#{i}"' takes 0.7 second)
+    #
+    class Test0b < OpenWFE::ProcessDefinition
+        sequence do
+            (0..N).each do |i|
+                subprocess :ref => "stage#{i}"
+            end
+            _print "over."
+        end
+        (0..N).each do |i|
+            define "stage#{i}" do
+                sequence do
+                    _print "stage#{i}"
+                end
+            end
+        end
+    end
+
+    def test_0
+
+        dotest Test0, (0..N).collect { |i| "stage#{i}" }.join("\n") + "\nover."
+        #dotest Test0b, (0..N).collect { |i| "stage#{i}" }.join("\n") + "\nover."
+    end
+
+end
+

data/test/bm/ft_0f_5ms.rb

@@ -0,0 +1,35 @@
+
+#
+# Testing OpenWFE
+#
+# John Mettraux at openwfe.org
+#
+# Wed Apr 16 15:33:59 JST 2008
+#
+
+require 'flowtestbase'
+
+
+class FlowTest0b < Test::Unit::TestCase
+    include FlowTestBase
+
+    #def setup
+    #end
+
+    #def teardown
+    #end
+
+    class Test5ms < OpenWFE::ProcessDefinition
+        concurrence do
+            _print "a"
+            _print "b"
+        end
+    end
+
+    def test_0
+
+        dotest Test5ms, "a\nb"
+    end
+
+end
+

data/test/bm/ft_26_load.rb

@@ -0,0 +1,210 @@
+
+#
+# Testing OpenWFE
+#
+# John Mettraux at openwfe.org
+#
+# Tue Jan  2 13:14:37 JST 2007
+#
+
+require 'flowtestbase'
+require 'openwfe/def'
+
+include OpenWFE
+
+
+class FlowTest26c < Test::Unit::TestCase
+    include FlowTestBase
+
+    #def setup
+    #end
+
+    #def teardown
+    #end
+
+    #
+    # Test 0
+    #
+
+    class TestDefinition0 < ProcessDefinition
+        process_definition :name => "test0", :revision => "0" do
+            sequence do
+                count
+                count
+            end
+        end
+    end
+    #class TestDefinition0 < ProcessDefinition
+    #    count
+    #end
+
+    #def xxxx_load_0
+    def test_load_0
+
+        map = {}
+
+        @engine.register_participant("count") do |workitem|
+            count = map[workitem.flow_id]
+            count = unless count
+                1
+            else
+                count + 1
+            end
+            map[workitem.flow_id] = count
+        end
+
+        n = 1000
+
+        n.times do |i|
+            li = LaunchItem.new(TestDefinition0)
+            li.flow_id = i
+            @engine.launch(li)
+        end
+
+        #while @engine.get_expression_storage.size > 1
+        #    sleep 0.001
+        #end
+        @engine.join_until_idle
+
+        good = true
+
+        n.times do |i|
+            c = map[i]
+            if c == 2
+            #if c == 1
+                print "."
+            else
+                print c
+                good = false
+            end
+        end
+
+        #puts "\n__good ? #{good}"
+        assert good, "missing count"
+
+        #     100 in    1s (in memory engine)
+        #   1'000 in   14s (in memory engine)
+        #  10'000 in  143s (in memory engine)
+        #   1'000 in   31s (cache engine)
+        #  10'000 in  321s (cache engine)
+        #   1'000 in  113s (persistence only engine)
+        #  10'000 in 1173s (persistence only engine)
+        #
+        #
+        # ruby 1.8.5 (2006-12-25 patchlevel 12) [i686-darwin8.8.3]
+        #
+        # Machine Name:             Mac
+        # Machine Model:            MacBook2,1
+        # Processor Name:           Intel Core 2 Duo
+        # Processor Speed:          2 GHz
+        # Number Of Processors:     1
+        # Total Number Of Cores:    2
+        # L2 Cache (per processor): 4 MB
+        # Memory:                   2 GB
+        # Bus Speed:                667 MHz
+
+        # Thu Sep 13 15:38:46 JST 2007
+        #
+        #     100 in    3s (in memory engine)
+        #   1'000 in   85s (in memory engine)
+        #  10'000 in     s (in memory engine)
+    end
+
+
+    #
+    # TEST 1
+    #
+
+    def xxxx_load_1
+    #def test_load_1
+
+        map = {}
+
+        @engine.register_participant("count") do |workitem|
+            count = map[workitem.flow_id]
+            count = unless count
+                1
+            else
+                count + 1
+            end
+            map[workitem.flow_id] = count
+            #puts "(#{workitem.flow_id} => #{map[workitem.flow_id]})"
+        end
+
+        n = 10000
+
+        n.times do |i|
+
+            #t = Thread.new do
+            #    begin
+            #        li = LaunchItem.new(TestDefinition0)
+            #        li.flow_id = i
+            #        @engine.launch(li)
+            #        #print "."
+            #    rescue Exception => e
+            #        print "e"
+            #        @engine.lwarn do 
+            #            "ft_26_test_1 exception...\n" + 
+            #            OpenWFE::exception_to_s(e)
+            #        end
+            #    end
+            #end
+
+            li = LaunchItem.new(TestDefinition0)
+            li.flow_id = i
+
+            fei, t = @engine.launch(li, true)
+                #
+                # async : true
+
+            t.join if i == n-1
+        end
+
+        sleep(1)
+        puts
+
+        good = true
+
+        n.times do |i|
+
+            c = map[i]
+
+            if c == 2
+                print "."
+            elsif c == nil
+                print "x"
+                good = false
+            else
+                print c
+                good = false
+            end
+        end
+
+        #puts "\n__good ? #{good}"
+
+        assert good, "missing count"
+
+        #     100 in    3s (in memory engine)
+        #   1'000 in   85s (in memory engine)
+        #  10'000 in     s (in memory engine)
+        #   1'000 in  551s (cache engine)
+        #  10'000 in     s (cache engine)
+        #   1'000 in     s (persistence only engine)
+        #  10'000 in     s (persistence only engine)
+        #
+        #
+        # ruby 1.8.5 (2006-12-25 patchlevel 12) [i686-darwin8.8.3]
+        #
+        # Machine Name:             Mac
+        # Machine Model:            MacBook2,1
+        # Processor Name:           Intel Core 2 Duo
+        # Processor Speed:          2 GHz
+        # Number Of Processors:     1
+        # Total Number Of Cores:    2
+        # L2 Cache (per processor): 4 MB
+        # Memory:                   2 GB
+        # Bus Speed:                667 MHz
+    end
+
+end
+

data/test/bm/ft_26b_load.rb

@@ -0,0 +1,86 @@
+
+#
+# Testing OpenWFE
+#
+# John Mettraux at openwfe.org
+#
+# Tue Jan  2 13:14:37 JST 2007
+#
+
+#require 'profile'
+
+require 'flowtestbase'
+require 'openwfe/def'
+
+include OpenWFE
+
+
+class FlowTest26b < Test::Unit::TestCase
+    include FlowTestBase
+
+    #def setup
+    #end
+
+    #def teardown
+    #end
+
+    #
+    # Test 0
+    #
+
+    class TestDefinition0 < ProcessDefinition
+        count
+    end
+
+    #def xxxx_load_0
+    def test_load_0
+
+        #require 'openwfe/expool/journal'
+        #@engine.application_context[:keep_journals] = true
+        #@engine.init_service("journal", Journal)
+
+        $count = 0
+
+        @engine.register_participant("count") do |workitem|
+            $count += 1
+            #puts "count is #{$count}"
+        end
+        
+
+        n = 1000
+        n.times do |i|
+            @engine.launch(LaunchItem.new(TestDefinition0))
+        end
+        
+        puts "launched #{n} items"
+
+        #n.times do |i|
+        #    Thread.new do
+        #        @engine.launch(LaunchItem.new(TestDefinition0))
+        #    end
+        #end
+
+        #5.times do 
+        #    Thread.new do
+        #        (n / 5).times do
+        #            @engine.launch(LaunchItem.new(TestDefinition0))
+        #        end
+        #    end
+        #end
+        #sleep 1
+
+        join_until_idle
+
+        assert_equal $count, n
+    end
+    
+    def join_until_idle ()
+        storage = @engine.get_expression_storage
+        while storage.size > 1
+            sleep 1
+            puts "storage.size:#{storage.size}"
+        end
+    end
+
+end
+