rbsim 0.0.3

data/tcpn/model/cpu.rb

@@ -0,0 +1,75 @@
+# model of CPU load by application logic
+# (TCPN implementation of event:cpu)
+page "cpu" do
+  cpu = timed_place 'CPU', node: :node
+  process = timed_place 'process', { cpu_event: [ :has_event?, :cpu ] }
+  working_cpu = timed_place 'working CPU'
+
+  # Processing data on CPU.
+  # args: { block: a Proc that will receive a cpu object as argument and returns computation time on this CPU }
+  class EventCPU
+    attr_reader :process, :cpu, :event, :delay
+    def initialize(binding)
+      @process = binding['process'].value
+      @cpu = binding['CPU'].value
+    end
+
+    def cpu_and_process_token(clock)
+      hsh = { cpu: @cpu, process: @process }
+      { ts: clock + delay, val: hsh }
+    end
+
+    private
+
+    def delay
+      event = @process.serve_system_event :cpu
+      event[:args][:block].call(@cpu).to_i
+    end
+  end
+
+  transition 'event::cpu' do
+    input process
+    input cpu
+
+
+    output working_cpu do |binding, clock|
+      EventCPU.new(binding).cpu_and_process_token clock
+    end
+
+    sentry do |marking_for, clock, result|
+      marking_for['process'].each(:cpu_event, true) do |process|
+        marking_for['CPU'].each(:node, process.value.node) do |cpu|
+          result << { 'process' => process, 'CPU' => cpu }
+        end
+      end
+    end
+=begin
+    guard do |binding, clock|
+      if binding[:process][:val].has_event?(:cpu) &&
+         (binding[:process][:val].node == binding[:cpu][:val].node)
+        true
+      else
+        false
+      end
+    end
+=end
+
+  end
+
+
+  transition 'event::cpu_finished' do
+    input working_cpu
+
+    output cpu do |binding, clock|
+      cpu = binding['working CPU'].value[:cpu]
+      { ts: clock, val: cpu }
+    end
+
+    output process do |binding, clock|
+      process = binding['working CPU'].value[:process]
+      { ts: clock, val: process }
+    end
+
+  end
+
+end

data/tcpn/model/map_data.rb

@@ -0,0 +1,42 @@
+# map data to proper destination nodes
+# before network transmission
+page 'map data' do
+
+  mapping = place 'mapping'
+  data_to_send = place 'data to send'
+  data_for_network = place 'data for network'
+
+  transition 'add dst node' do
+    input data_to_send
+    input mapping
+
+    output mapping do |binding, clock|
+      binding['mapping']
+    end
+
+    class TCPNMapDataDestination
+      class ProcessNotMappedToNode < RuntimeError
+      end
+
+      def initialize(binding)
+        @data = binding['data to send'].value
+        @dst = @data.dst
+        @mapping = binding['mapping'].value
+        @dst_node = @mapping[@dst]
+        if @dst_node.nil?
+          raise ProcessNotMappedToNode.new(@dst)
+        end
+        @data.dst_node = @dst_node
+      end
+
+      def data_token(clock)
+        { ts: clock, val: @data }
+      end
+    end
+
+    output data_for_network do |binding, clock|
+      TCPNMapDataDestination.new(binding).data_token(clock)
+    end
+  end
+end
+

data/tcpn/model/network.rb

@@ -0,0 +1,108 @@
+# network transmission model
+page 'network' do
+  data_with_route = place 'data with route'
+  net = timed_place 'net', { name: :name }
+  data_after_net = timed_place 'data after net', has_next_net: :has_next_net?
+  data_to_receive = place 'data to receive', process_name: :process_name
+
+  transition 'net' do
+    input data_with_route
+    input net
+
+    class TCPNNet
+      def initialize(binding)
+        @net = binding['net'].value
+        @data = binding['data with route'].value
+        # make it run random drop generator code to cache drop decision for the next time
+        @drop = @net.drop?
+      end
+
+      def net_token(clock)
+        { ts: clock + delay, val: @net }
+      end
+
+      def data_token(clock)
+        return nil if @drop
+        @data.route.next_net
+        { ts: clock + delay, val: @data }
+      end
+
+      def guard(clock)
+        @data.route.next_net == @net.name
+      end
+
+      private
+      def delay
+        (@data.size.to_f / @data.fragments) / @net.bw.to_f
+      end
+    end
+
+    output net do |binding, clock|
+      TCPNNet.new(binding).net_token(clock)
+    end
+
+    output data_after_net do |binding, clock|
+      TCPNNet.new(binding).data_token(clock)
+    end
+
+    sentry do |marking_for, clock, result|
+      marking_for['data with route'].each do |data|
+        next_net = data.value.route.next_net
+        marking_for['net'].each(:name, next_net) do |net|
+          result << { 'data with route' => data, 'net' => net }
+        end
+      end
+    end
+
+=begin
+    guard do |binding, clock|
+      TCPNNet.new(binding).guard(clock)
+    end
+=end
+  end
+
+  transition 'next net' do
+    input data_after_net
+    output data_with_route do |binding|
+      binding['data after net']
+    end
+
+    sentry do |marking_for, clock, result|
+      marking_for['data after net'].each(:has_next_net, true) do |data|
+        result << { 'data after net' => data }
+      end
+    end
+=begin
+    guard do |binding, clock|
+      data = binding['data after net'].val
+      data.route.has_next_net?
+    end
+=end
+  end
+
+  transition 'transmitted' do
+    input data_after_net
+    input data_to_receive
+
+    output data_to_receive do |binding, clock|
+      queue = binding['data to receive'].value
+      data = binding['data after net'].value
+      queue.put data
+      { ts: clock, val: queue }
+    end
+
+    sentry do |marking_for, clock, result|
+      marking_for['data after net'].each(:has_next_net, false) do |data|
+        marking_for['data to receive'].each(:process_name, data.value.dst) do |queue|
+          result << { 'data after net' => data, 'data to receive' =>  queue }
+        end
+      end
+    end
+=begin
+    guard do |binding, clock|
+      data = binding[:data][:val]
+      !data.route.has_next_net?
+    end
+=end
+  end
+end

data/tcpn/model/register_event.rb

@@ -0,0 +1,89 @@
+page "register event" do
+  process = timed_place 'process', { first_event: :first_event, id: :id }
+  event = timed_place 'event' #, { process_id: :process_id }
+
+  transition 'event::register_event' do
+    input process
+
+    class EventRegisterEvent
+      def initialize(binding)
+        @process = binding['process'].value
+      end
+
+      def process_token(clock)
+        @process.serve_system_event :register_event
+        { val: @process, ts: clock }
+      end
+
+      def event_token(clock)
+        @e = @process.serve_system_event :register_event
+        event = @e[:args][:event]
+        args = @e[:args][:event_args]
+        { val: RBSim::Tokens::EventToken.new(@process.id, event, args), ts: clock + @e[:args][:delay] }
+      end
+
+      def guard(clock)
+        @process.has_event? :register_event
+      end
+
+    end
+
+    output process do |binding, clock|
+      EventRegisterEvent.new(binding).process_token(clock)
+    end
+
+    output event do |binding, clock|
+      EventRegisterEvent.new(binding).event_token(clock)
+    end
+
+    sentry do |marking_for, clock, result|
+      marking_for['process'].each(:first_event, :register_event) do |process|
+        result << { 'process' => process }
+      end
+    end
+=begin
+    guard do |binding, clock|
+      EventRegisterEvent.new(binding).guard(clock)
+    end
+=end
+  end
+
+  transition 'event::enqueue_event' do
+    input event
+    input process
+
+    class EventEnqueueEvent
+      def initialize(binding)
+        @process = binding['process'].value
+        @event = binding['event'].value
+      end
+
+      def process_token(clock)
+        @process.enqueue_event(@event.name, @event.args)
+        { val: @process, ts: clock }
+      end
+
+      def guard(clock)
+        @process.id == @event.process_id
+      end
+    end
+
+    output process do |binding, clock|
+      EventEnqueueEvent.new(binding).process_token(clock)
+    end
+
+    sentry do |marking_for, clock, result|
+      marking_for['event'].each do |e|
+        marking_for['process'].each(:id, e.value.process_id) do |p|
+          result << { 'process' => p, 'event' => e }
+        end
+      end
+    end
+
+=begin
+    guard do |binding, clock|
+      EventEnqueueEvent.new(binding).guard(clock)
+    end
+=end
+  end
+end

data/tcpn/model/stats.rb

@@ -0,0 +1,46 @@
+page "stats" do
+  process = timed_place 'process', { first_event: :first_event }
+
+  # stats for process
+  # args: stats tag
+  class EventStats
+    EventList = [ :stats, :stats_stop, :stats_start, :stats_save ]
+
+    def initialize(binding)
+      @process = binding['process'].value
+      @event_list = EventList
+    end
+
+    def process_token(clock)
+      @process.serve_system_event @process.first_event
+      { val: @process, ts: clock }
+    end
+
+    def guard(clock)
+      @event_list.include? @process.first_event
+    end
+
+  end
+
+  transition 'event::stats' do
+    input process
+
+    output process do |binding, clock|
+      EventStats.new(binding).process_token(clock)
+    end
+
+    sentry do |marking_for, clock, result|
+      EventStats::EventList.each do |e|
+        p = marking_for['process'].each(:first_event, e).first
+        result << { 'process' => p } unless p.nil?
+      end
+    end
+
+=begin
+    guard do |binding, clock|
+      EventStats.new(binding).guard(clock)
+    end
+=end
+  end
+
+end

metadata

@@ -0,0 +1,221 @@
+--- !ruby/object:Gem::Specification
+name: rbsim
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+platform: ruby
+authors:
+- Wojciech Rząsa
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-12-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: docile
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: fast-tcpn
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+description: You can model your distributed infrastructora and application and simulate
+  its behavior and observe its efficiency easily.
+email:
+- me@wojciechrzasa.pl
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- ".hgignore"
+- ".rspec"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- TODO
+- basic_sim.rb
+- fast-tcpn.rb
+- lib/rbsim.rb
+- lib/rbsim/dsl.rb
+- lib/rbsim/dsl/infrastructure.rb
+- lib/rbsim/dsl/mapping.rb
+- lib/rbsim/dsl/process.rb
+- lib/rbsim/dsl/program.rb
+- lib/rbsim/experiment.rb
+- lib/rbsim/hlmodel.rb
+- lib/rbsim/hlmodel/infrastructure.rb
+- lib/rbsim/hlmodel/mapping.rb
+- lib/rbsim/hlmodel/process.rb
+- lib/rbsim/numeric_units.rb
+- lib/rbsim/simulator.rb
+- lib/rbsim/statistics.rb
+- lib/rbsim/tokens.rb
+- lib/rbsim/version.rb
+- new_process.rb
+- rbsim.gemspec
+- show_readme.rb
+- sim.rb
+- sim_bamboo.rb
+- sim_process.rb
+- sim_process_dsl.rb
+- spec/dsl/infrastructure_nets_spec.rb
+- spec/dsl/infrastructure_nodes_spec.rb
+- spec/dsl/infrastructure_routes_spec.rb
+- spec/dsl/mapping_spec.rb
+- spec/dsl/process_spec.rb
+- spec/dsl/program_spec.rb
+- spec/dsl_and_hlmodel/new_process_spec.rb
+- spec/hlmodel/net_spec.rb
+- spec/hlmodel/process_spec.rb
+- spec/hlmodel/route_spec.rb
+- spec/hlmodel/routes_spec.rb
+- spec/integration/basic_simulation_spec.rb
+- spec/integration/net_spec.rb
+- spec/integration/process_spec.rb
+- spec/integration/rbsim_spec.rb
+- spec/simulator/logger_spec.rb
+- spec/simulator/stats_spec.rb
+- spec/spec_helper.rb
+- spec/statistics_spec.rb
+- spec/tcpn/add_route_spec.rb
+- spec/tcpn/cpu_spec.rb
+- spec/tcpn/map_data_spec.rb
+- spec/tcpn/network_spec.rb
+- spec/tcpn/register_event_spec.rb
+- spec/tcpn/route_to_self_spec.rb
+- spec/tcpn/stats_spec.rb
+- spec/tokens/data_queue_obsolete.rb
+- spec/tokens/data_queue_spec.rb
+- spec/units_spec.rb
+- tcpn/model.rb
+- tcpn/model/add_route.rb
+- tcpn/model/application.rb
+- tcpn/model/cpu.rb
+- tcpn/model/map_data.rb
+- tcpn/model/network.rb
+- tcpn/model/register_event.rb
+- tcpn/model/stats.rb
+homepage: https://github.com/wrzasa/rbsim
+licenses:
+- GPL-3.0
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--main"
+- README.md
+- "--title"
+- RBSim -- Distributed system modeling and simulation tool
+- "--line-numbers"
+- "-A"
+- "-x coverage"
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.7
+signing_key: 
+specification_version: 4
+summary: Distributed inftastructure and system simulator with convenient DSL.
+test_files:
+- spec/dsl/infrastructure_nets_spec.rb
+- spec/dsl/infrastructure_nodes_spec.rb
+- spec/dsl/infrastructure_routes_spec.rb
+- spec/dsl/mapping_spec.rb
+- spec/dsl/process_spec.rb
+- spec/dsl/program_spec.rb
+- spec/dsl_and_hlmodel/new_process_spec.rb
+- spec/hlmodel/net_spec.rb
+- spec/hlmodel/process_spec.rb
+- spec/hlmodel/route_spec.rb
+- spec/hlmodel/routes_spec.rb
+- spec/integration/basic_simulation_spec.rb
+- spec/integration/net_spec.rb
+- spec/integration/process_spec.rb
+- spec/integration/rbsim_spec.rb
+- spec/simulator/logger_spec.rb
+- spec/simulator/stats_spec.rb
+- spec/spec_helper.rb
+- spec/statistics_spec.rb
+- spec/tcpn/add_route_spec.rb
+- spec/tcpn/cpu_spec.rb
+- spec/tcpn/map_data_spec.rb
+- spec/tcpn/network_spec.rb
+- spec/tcpn/register_event_spec.rb
+- spec/tcpn/route_to_self_spec.rb
+- spec/tcpn/stats_spec.rb
+- spec/tokens/data_queue_obsolete.rb
+- spec/tokens/data_queue_spec.rb
+- spec/units_spec.rb