rbsim 0.0.3

data/spec/tokens/data_queue_obsolete.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+
+describe RBSim::Tokens::DataQueue do
+
+  let(:apache1_first)  { RBSim::Tokens::DataToken.new(:node01, 'wget', size: 1024, to: 'apache1') }
+  let(:apache1_second) { RBSim::Tokens::DataToken.new(:node01, 'wget', size: 1024, to: 'apache1') }
+  let(:apache1_third)  { RBSim::Tokens::DataToken.new(:node01, 'wget', size: 1024, to: 'apache1') }
+  let(:apache5_first)  { RBSim::Tokens::DataToken.new(:node01, 'wget', size: 1024, to: 'apache5') }
+  let(:apache3_first)  { RBSim::Tokens::DataToken.new(:node01, 'wget', size: 1024, to: 'apache3') }
+
+  describe "enqueues data for each process separatelly" do
+    subject do
+      queue = RBSim::Tokens::DataQueueToken.new
+      queue.put apache1_first
+      queue.put apache5_first
+      queue.put apache1_second
+      queue.put apache3_first
+      queue.put apache1_third
+      queue
+    end
+
+    it "has 3 data packages for apache1" do
+      expect(subject.get 'apache1').to eq apache1_first
+      expect(subject.get 'apache1').to eq apache1_second
+      expect(subject.get 'apache1').to eq apache1_third
+      expect(subject.get 'apache1').to be nil
+    end
+
+    it "has 1 data package for apache5" do
+      expect(subject.get 'apache5').to eq apache5_first
+      expect(subject.get 'apache5').to be nil
+    end
+
+    it "has 1 data package for apache3" do
+      expect(subject.get 'apache3').to eq apache3_first
+      expect(subject.get 'apache3').to be nil
+    end
+
+    it "has no data packages for apache0" do
+      expect(subject.get 'apache0').to be nil
+    end
+
+  end
+
+  describe "collects queue lengths for processes" do
+    context "when putting something to the queue" do
+      subject do
+        queue = RBSim::Tokens::DataQueueToken.new
+        queue.put RBSim::Tokens::DataToken.new(:node01, 'wget', size: 1024, to: 'apache1')
+        queue.put RBSim::Tokens::DataToken.new(:node01, 'wget', size: 1024, to: 'apache5')
+        queue.put RBSim::Tokens::DataToken.new(:node01, 'wget', size: 1024, to: 'apache1')
+        queue.put RBSim::Tokens::DataToken.new(:node01, 'wget', size: 1024, to: 'apache3')
+        queue.put RBSim::Tokens::DataToken.new(:node01, 'wget', size: 1024, to: 'apache1')
+        queue
+      end
+      it "has 3 packages for apache1" do
+        expect(subject.length_for('apache1')).to eq 3
+      end
+
+      it "has 1 package for apache5" do
+        expect(subject.length_for('apache5')).to eq 1
+      end
+
+      it "has 1 package for apache3" do
+        expect(subject.length_for('apache3')).to eq 1
+      end
+
+      it "has no packages for apache333" do
+        expect(subject.length_for('apache333')).to eq 0
+      end
+
+    end
+
+    context "when putting and getting from the queue" do
+      subject do
+        queue = RBSim::Tokens::DataQueueToken.new
+        queue.put RBSim::Tokens::DataToken.new(:node01, 'wget', size: 1024, to: 'apache0')
+        queue.put RBSim::Tokens::DataToken.new(:node01, 'wget', size: 1024, to: 'apache2')
+        queue.put RBSim::Tokens::DataToken.new(:node01, 'wget', size: 1024, to: 'apache2')
+        queue.get 'apache0'
+        queue.get 'apache2'
+        queue
+      end
+
+      it "has 1 package for apache2" do
+        expect(subject.length_for('apache2')).to eq 1
+      end
+
+      it "has no packages for apache0" do
+        expect(subject.length_for('apache0')).to eq 0
+      end
+    end
+
+  end
+
+  describe "remembers last involved process" do
+    context "when putting" do
+      subject do
+        queue = RBSim::Tokens::DataQueueToken.new
+        queue.put RBSim::Tokens::DataToken.new(:node01, 'wget', size: 1024, to: 'apache0')
+        queue.put RBSim::Tokens::DataToken.new(:node01, 'wget', size: 1024, to: 'apache2')
+        queue.put RBSim::Tokens::DataToken.new(:node01, 'wget', size: 1024, to: 'apache1')
+        queue
+      end
+      its(:last_involved_queue) { should eq 'apache1' }
+    end
+
+    context "when getting" do
+      subject do
+        queue = RBSim::Tokens::DataQueueToken.new
+        queue.put RBSim::Tokens::DataToken.new(:node01, 'wget', size: 1024, to: 'apache0')
+        queue.put RBSim::Tokens::DataToken.new(:node01, 'wget', size: 1024, to: 'apache2')
+        queue.put RBSim::Tokens::DataToken.new(:node01, 'wget', size: 1024, to: 'apache1')
+        queue.get 'apache0'
+        queue
+      end
+      its(:last_involved_queue) { should eq 'apache0' }
+    end
+  end
+
+end

data/spec/tokens/data_queue_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+describe RBSim::Tokens::DataQueue do
+  subject { RBSim::Tokens::DataQueue.new(:apache) }
+
+  let(:data_id) { 12332432 }
+  let(:other_data_id) { 23634657 }
+
+  let(:data1) do
+    data = RBSim::Tokens::Data.new(data_id, :node01, :apache1, to: :apache, size: 1024)
+    data.fragments = 3
+    data
+  end
+
+  let(:data2) do
+    data = RBSim::Tokens::Data.new(data_id, :node01, :apache1, to: :apache, size: 1024)
+    data.fragments = 3
+    data
+  end
+
+  let(:data3) do
+    data = RBSim::Tokens::Data.new(data_id, :node01, :apache1, to: :apache, size: 1024)
+    data.fragments = 3
+    data
+  end
+
+  let(:other_data1) do
+    data = RBSim::Tokens::Data.new(other_data_id, :node01, :apache1, to: :apache, size: 1024)
+    data.fragments = 2
+    data
+  end
+
+  let(:other_data2) do
+    data = RBSim::Tokens::Data.new(other_data_id, :node01, :apache1, to: :apache, size: 1024)
+    data.fragments = 2
+    data
+  end
+
+  shared_examples_for "empty queue" do
+    it "is empty" do
+      expect(subject.empty?).to be true
+    end
+
+    it "has length 0" do
+      expect(subject.length).to eq 0
+    end
+
+    it "dequeues nil" do
+      expect(subject.get).to be_nil
+    end
+  end
+
+  it "raises error when fragment count is not set" do
+    data = RBSim::Tokens::Data.new(other_data_id, :node01, :apache1, to: :apache, size: 1024)
+    expect { subject.put data }.to raise_error
+  end
+
+  describe "until all fragments arrive" do
+    before :each do
+      subject.put data1
+      subject.put data2
+      subject.put other_data1
+    end
+
+    it_behaves_like "empty queue"
+
+  end
+
+  describe "when all fragments arrive" do
+    before :each do
+      subject.put data1
+      subject.put data2
+      subject.put other_data1
+      subject.put data3
+    end
+
+    it "is not empty" do
+      expect(subject.empty?).to be false
+    end
+
+    it "has length 1" do
+      expect(subject.length).to eq 1
+    end
+
+    it "dequeues data" do
+      expect(subject.get.data_id).to eq data_id
+    end
+
+    describe "when data is dequeued" do
+      before :each do
+        subject.get
+      end
+
+      it_behaves_like "empty queue"
+
+
+      describe "when another data arrives" do
+        before :each do
+          subject.put other_data2
+        end
+
+        it "dequeues data" do
+          expect(subject.get.data_id).to eq other_data_id
+        end
+
+      end
+
+    end
+  end
+
+end

data/spec/units_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe "Numeric units" do
+
+  let(:jiffies) { Numeric::RBSIM_JIFFIES_PER_SECOND }
+
+  shared_examples "has correct units" do
+      # volume units
+      its(:bits)      { should eq subject }
+      its(:bytes)     { should eq subject * 8 }
+      its(:in_bits)   { should eq subject }
+      its(:in_bytes)  { should eq subject / 8 }
+
+      # network units
+      its(:bps)     { should eq subject.to_f / jiffies}
+      its(:Bps)     { should eq subject.to_f * 8 / jiffies }
+      its(:in_bps)  { should eq subject * jiffies }
+      its(:in_Bps)  { should eq subject / 8 * jiffies }
+
+      # time units
+      its(:seconds)         { should eq subject * jiffies }
+      its(:miliseconds)     { should eq subject * jiffies / 1000 }
+      its(:microseconds)    { should eq subject * jiffies / 1000000 }
+      its(:minutes)         { should eq subject * jiffies * 60 }
+      its(:hours)           { should eq subject * jiffies * 60 * 60 }
+      its(:days)            { should eq subject * jiffies * 60 * 60 * 24 }
+
+      its(:in_seconds)      { should eq subject / jiffies }
+      its(:in_miliseconds)  { should eq subject * 1000 / jiffies }
+      its(:in_microseconds) { should eq subject * 1000 * 1000 / jiffies }
+      its(:in_minutes)      { should be_within(1.0/jiffies).of( subject / (jiffies * 60) ) }
+      its(:in_hours)        { should be_within(1.0/jiffies).of( subject / (jiffies * 60 * 60) ) }
+      its(:in_days)         { should be_within(1.0/jiffies).of( subject / (jiffies * 60 * 60 * 24) ) }
+  end
+
+  describe 128 do
+    include_examples 'has correct units'
+  end
+
+  describe 1.5 do
+    include_examples 'has correct units'
+  end
+
+  describe 50000 do
+    include_examples 'has correct units'
+  end
+
+end

data/tcpn/model.rb

@@ -0,0 +1,6 @@
+page "rbsim model" do
+  sub_page "model/application.rb"
+  sub_page "model/map_data.rb"
+  sub_page "model/add_route.rb"
+  sub_page "model/network.rb"
+end

data/tcpn/model/add_route.rb

@@ -0,0 +1,78 @@
+# add route to data
+# before network transmission
+page 'add route' do
+  RouteNotFound = Class.new RuntimeError
+
+  data_for_network = place 'data for network'
+  routes = place 'routes'
+  data_with_route = place 'data with route'
+  data_to_receive = place 'data to receive', process_name: :process_name
+
+  class TCPNAddRouteToData
+    def initialize(binding)
+      @data = binding['data for network'].value
+      @queue = binding['data to receive'].value
+      @routes = binding['routes'].value
+    end
+
+    def with_route_token(clock)
+      if to_self?
+        nil
+      else
+        @data.route = route
+        { ts: clock, val: @data }
+      end
+    end
+
+    def to_self_token(clock)
+      if to_self?
+        @queue.put @data
+      end
+      { ts: clock, val: @queue }
+    end
+
+    private
+
+    def to_self?
+      @data.src_node == @data.dst_node
+    end
+
+    def route
+      r = @routes.find @data.src_node, @data.dst_node
+      if r.nil?
+        raise RouteNotFound.new("from #{@data.src_node} to #{@data.dst_node}")
+      end
+      r
+    end
+  end
+
+  transition 'add_route' do
+    input data_for_network
+    input routes
+    input data_to_receive
+
+    output routes do |binding, clock|
+      binding['routes']
+    end
+
+    output data_with_route do |binding, clock|
+      TCPNAddRouteToData.new(binding).with_route_token(clock)
+    end
+
+    output data_to_receive do |binding, clock|
+      TCPNAddRouteToData.new(binding).to_self_token(clock)
+    end
+
+    sentry do |marking_for, clock, result|
+      marking_for['data for network'].each do |data|
+        marking_for['data to receive'].each(:process_name, data.value.dst) do |queue|
+          routes = marking_for['routes'].first
+          result << { 'data for network' => data,
+                      'data to receive' => queue,
+                      'routes' => routes }
+        end
+      end
+    end
+  end
+end
+

data/tcpn/model/application.rb

@@ -0,0 +1,250 @@
+page 'application' do
+  process = timed_place 'process', { first_event: :first_event, user_event: :has_user_event?, name: :name }
+  data_to_send = place 'data to send'
+  mapping = place 'mapping'
+  data_to_receive = place 'data to receive', empty: :empty?
+
+  # model of CPU load by application logic 
+  sub_page "cpu.rb"
+
+  # statistics
+  sub_page "stats.rb"
+
+  # new event from user (register_event statement)
+  sub_page "register_event.rb"
+
+  # Delay process execution for specified time.
+  # args: { time: time for which we should wait }
+  class EventDelayFor
+    def initialize(binding)
+      @process = binding['process'].value
+      @event = @process.serve_system_event :delay_for
+    end
+
+    def process_token(clock)
+      ts = clock + @event[:args][:time].to_i
+      { val: @process, ts: ts }
+    end
+  end
+
+  transition 'event::delay_for' do
+    input process
+    output process do |binding, clock|
+      EventDelayFor.new(binding).process_token(clock)
+    end
+
+    sentry do |marking_for, clock, result|
+      marking_for['process'].each(:first_event, :delay_for) do |p|
+        result << { 'process' => p }
+      end
+    end
+=begin
+    guard do |binding, clock|
+      binding[:process][:val].has_event? :delay_for
+    end
+=end
+  end
+
+  transition 'event::serve_user' do
+    input process
+
+    output process do |binding, clock|
+      process = binding['process'].value
+      process.serve_user_event
+      process
+    end
+
+    sentry do |marking_for, clock, result|
+      marking_for['process'].each(:user_event, true) do |p|
+        result << { 'process' => p }
+      end
+    end
+
+=begin
+    guard do |binding, clock|
+      binding[:process][:val].has_user_event?
+    end
+=end
+  end
+
+  transition 'event::send_data' do
+    input process
+
+    # Sending data to anothe node.
+    # args: { to: destination process name,
+    #         size: volume of send data,
+    #         type: type of send data (to use in HLModel),
+    #         content: content of send data (to use in HLModel) }
+    class EventSendData
+      def initialize(bndng)
+        @process = bndng['process'].value
+        @event = @process.serve_system_event :send_data
+        fragments = [
+          @process.data_fragmentation,
+          @event[:args][:size].to_i / 1500.bytes
+        ].min
+        fragments = 1 if fragments == 0
+        @data = fragments.times.map do
+          d = RBSim::Tokens::DataToken.new(self.object_id, @process.node, @process.name, @event[:args])
+          d.fragments = fragments
+          d
+        end
+      end
+
+      def data_token(clock)
+        @data.map { |d| { val: d, ts: clock } }
+      end
+
+      def process_token(clock)
+        { val: @process, ts: clock }
+      end
+    end
+
+    output process do |binding, clock|
+      EventSendData.new(binding).process_token clock
+    end
+
+    output data_to_send do |binding, clock|
+      EventSendData.new(binding).data_token clock
+    end
+
+    sentry do |marking_for, clock, result|
+      marking_for['process'].each(:first_event, :send_data) do |p|
+        result << { 'process' => p }
+      end
+    end
+
+=begin
+    guard do |binding, clock|
+      binding[:process][:val].has_event? :send_data
+    end
+=end
+  end
+
+  transition 'event::new_process' do
+    input process
+    input mapping
+
+    # Creating new process on the same node
+    # args: { program: program name for new process (optional),
+    #         constructor: block called as constructor of new process (adds initial events),
+    #         constructor_args: args passed to the constructor }
+    class EventNewProcess
+      def initialize(binding)
+        @process = binding['process'].value
+        @event = @process.serve_system_event :new_process
+        @new_process = @event[:args][:constructor].call @event[:args][:constructor_args]
+        @mapping = binding['mapping'].value
+        @mapping[@new_process.name] = @new_process.node
+      end
+
+      def process_tokens(clock)
+        [ { ts: clock, val: @process }, { ts: clock, val: @new_process } ]
+      end
+
+      def mapping_token(clock)
+        { ts: clock, val: @mapping }
+      end
+    end
+
+    output process do |binding, clock|
+      EventNewProcess.new(binding).process_tokens(clock)
+    end
+
+    output mapping do |binding, clock|
+      EventNewProcess.new(binding).mapping_token(clock)
+    end
+
+    sentry do |marking_for, clock, result|
+      marking_for['process'].each(:first_event, :new_process) do |p|
+        mapping = marking_for['mapping'].first
+        result << { 'process' => p , 'mapping' => mapping}
+      end
+    end
+=begin
+    guard do |binding, clock|
+      binding[:process][:val].has_event? :new_process
+    end
+=end
+  end
+
+  transition 'event::data_received' do
+    input process
+    input data_to_receive
+
+    class EventDataReceived
+      def initialize(binding)
+        @process = binding['process'].value
+        @queue = binding['data to receive'].value
+        @data = @queue.get
+        @process.enqueue_event :data_received, @data
+      end
+
+      def process_token(clock)
+        { ts: clock, val: @process }
+      end
+
+      def queue_token(clock)
+        { ts: clock, val: @queue }
+      end
+    end
+
+    output process do |binding, clock|
+      EventDataReceived.new(binding).process_token(clock)
+    end
+
+    output data_to_receive do |binding, clock|
+      EventDataReceived.new(binding).queue_token(clock)
+    end
+
+    sentry do |marking_for, clock, result|
+      marking_for['data to receive'].each(:empty, false) do |queue|
+        marking_for['process'].each(:name, queue.value.process_name) do |process|
+          result << { 'process' => process, 'data to receive' => queue }
+        end
+      end
+    end
+
+=begin
+    guard do |binding, clock|
+      process = binding[:process][:val]
+      data = binding[:queue][:val].get process.name
+      !data.nil?
+    end
+=end
+  end
+
+  transition 'event::log' do
+    input process
+
+    # Log message from process
+    # args: log message
+    class EventLog
+      def initialize(binding)
+        @process = binding['process'].value
+        @event = @process.serve_system_event :log
+      end
+
+      def process_token(clock)
+        { val: @process, ts: clock }
+      end
+    end
+
+    output process do |binding, clock|
+      EventLog.new(binding).process_token(clock)
+    end
+
+    sentry do |marking_for, clock, result|
+      marking_for['process'].each(:first_event, :log) do |p|
+        result << { 'process' => p }
+      end
+    end
+
+=begin
+    guard do |binding, clock|
+      binding[:process][:val].has_event? :log
+    end
+=end
+  end
+
+end