rbsim 0.0.3

data/sim_bamboo.rb

@@ -0,0 +1,251 @@
+require 'rbsim'
+
+client_no = 1
+router_no = 100
+server_no = 10
+request_per_client = 1000
+request_gap = 30.miliseconds
+long_prob = 0.01
+REQUEST_TIMES = {
+  long: 5000.miliseconds,
+  short: 50.miliseconds
+}
+
+model = RBSim.model do
+
+  # gets array of server names and assigns
+  # requests to servers using round-robin, but
+  # next request is assigned to a server only
+  # when previous is served.
+  program :router do |servers|
+    request_queue = []
+    on_event :data_received do |data|
+      if data.type == :request
+        stats :requests, process.name
+        request_queue << data
+        stats_start :request_in_queue, process.name
+        register_event :process_request
+        stats_save request_queue.size, :rqueue_len, process.name
+      elsif data.type == :response
+        servers << data.src
+        send_data to: data.content[:from], size: data.size, type: :response, content: data.content[:content]
+        register_event :process_request
+      else
+        raise "Unknown data type #{data.type} received by #{process.name}"
+      end
+    end
+
+    on_event :process_request do
+      unless servers.empty? or request_queue.empty?
+        data = request_queue.shift
+        stats_stop :request_in_queue, process.name
+        server = servers.shift
+        stats_save request_queue.size, :rqueue_len, process.name
+        send_data to: server, size: data.size, type: :request, content: { from: data.src, content: data.content }
+        register_event :process_request unless request_queue.empty?
+      end
+    end
+  end
+
+  program :webserver do
+    on_event :data_received do |data|
+      if data.type == :request
+        tag = "request_#{data.content[:content][:length]}".to_sym
+        stats tag, process.name
+        stats :request, process.name
+        #log "#{process.name} got request #{data.content[:content][:number]} from #{data.content[:from]} #{data.content[:content][:length]}"
+        cpu do |cpu|
+          # request holds information about its processing time
+          REQUEST_TIMES[data.content[:content][:length]] / cpu.performance
+        end
+        data.content[:content].merge!({ server: process.name })
+        send_data to: data.src, size: data.size * 10, type: :response, content: data.content
+      else
+        raise "Unknown data type #{data.type} received by #{process.name}"
+      end
+    end
+  end
+
+  # opts are: count, delay, target
+  program :wget do |opts|
+    sent = 0
+    on_event :send do
+      length = if rand < opts[:long_prob]
+                  stats :requests_long#, process.name
+                  stats_start :requests_long#, process.name
+                  :long
+                else
+                  stats :requests_short#, process.name
+                  stats_start :requests_short#, process.name
+                  :short
+                end
+      content = { number: sent, length: length }
+      target = opts[:targets][rand opts[:targets].length]
+      send_data to: target, size: 1024.bytes, type: :request, content: content
+      #log "#{process.name} sent request #{sent} #{length}"
+      stats_start :request, process.name
+      stats_start "request_#{sent}".to_sym, process.name
+      sent += 1
+      register_event :send, delay: opts[:delay] if sent < opts[:count]
+    end
+
+    on_event :data_received do |data|
+      stats_stop :request, process.name
+      stats_stop "requests_#{data.content[:length]}".to_sym#, process.name
+      #log "#{process.name} got response #{data.content[:number]} #{data.content[:server]} #{data.content[:length]}"
+      stats :request_served, process.name
+      stats_stop "request_#{data.content[:number]}".to_sym, process.name
+    end
+
+    register_event :send
+  end
+
+
+
+
+
+  clients = (0..client_no - 1).map { |i| "client#{i}".to_sym }
+  routers = (0..router_no - 1).map { |i| "router#{i}".to_sym }
+  servers = (0..server_no - 1).map { |i| "thin#{i}".to_sym }
+
+  servers.each do |s|
+    node s do
+      cpu 1
+    end
+    new_process s, program: :webserver
+    put s, on: s
+  end
+
+
+  routers.each_with_index do |r, i|
+    new_process r, program: :router, args: servers.clone
+    node r do
+      cpu 1
+    end
+    put r, on: r
+  end
+
+  clients.each do |c|
+    new_process c, program: :wget, args: { count: request_per_client, delay: request_gap, targets: routers, long_prob: long_prob }
+    node c do
+      cpu 1
+    end
+    put c, on: c
+
+    routers.each do |r|
+      route from: c, to: r, via: [ :wan ], twoway: true
+    end
+  end
+
+  net :wan, bw: 102400.bps
+  net :lan, bw: 1024000.bps
+
+
+  servers.each do |s|
+    routers.each do |r|
+      route from: r, to: s, via: [ :lan ], twoway: true
+    end
+  end
+
+end
+
+prev_seconds = 0
+model.tcpn.cb_for :clock, :after do |tag, event|
+  print "\b"*40
+  seconds = event.clock.in_seconds.truncate
+  print "Time: #{seconds} sec." if seconds > prev_seconds
+  prev_seconds = seconds
+end
+
+puts "Clients\t\t: #{client_no}"
+puts "Routers\t\t: #{router_no}"
+puts "Servers\t\t: #{server_no}"
+puts "Requests\t: #{request_per_client}"
+puts "Request gap\t: #{request_gap.in_miliseconds}ms"
+puts "Long req. prob.\t: #{long_prob}"
+puts "Request times\t: #{REQUEST_TIMES.map{ |n,t| "#{n}: #{t.in_miliseconds}ms"}.join ', '}"
+puts
+
+model.run
+
+#model.stats_print
+#p model.stats_summary
+
+=begin
+puts "======================="
+puts "Routers' queue length"
+model.stats_data[:application].values.each do |process, tag, time, values|
+  next unless tag == :rqueue_len
+  puts "#{process}\t#{time}: #{values.last}"
+end
+=end
+puts
+
+max_rqueue_len = model.stats_summary[:application][:values].map do |process, records|
+  records[:rqueue_len].map{ |time, values| values.last }.max
+end.max
+
+max_thinqueue_len = model.stats_summary[:resources][:values]['DATAQ LEN'].map do |process, records|
+  if process.to_s =~ /thin*/
+    records.map{ |time, values| values.last }.max
+  else
+    0
+  end
+end.max
+
+#max_thinqueue_wait = model.stats_summary[:resources][:durations]['DATAQ WAIT'].select do |process, time|
+#  process.to_s =~ /thin*/
+#end.values.max
+
+max_thinq_wait = nil
+model.stats_data[:resources].durations do |group, tag, start, stop|
+  next unless group == 'DATAQ WAIT'
+  next unless tag.to_s =~ /thin.*/
+  if max_thinq_wait.nil? || (stop - start) > max_thinq_wait[:time]
+    max_thinq_wait = { time: stop - start, tag: tag }
+  end
+end
+
+sum_rqueue_wait = 0
+max_rqueue_wait = 0
+model.stats_data[:application].durations do |group, tag, start, stop|
+  next unless group.to_s =~ /router.*/
+  next unless tag == :request_in_queue
+  wait = stop - start
+  sum_rqueue_wait += wait
+  max_rqueue_wait = wait if wait > max_rqueue_wait
+end
+
+summary_thinqueue_wait = model.stats_summary[:resources][:durations]['DATAQ WAIT'].select do |process, time|
+  process.to_s =~ /thin*/
+end.values.reduce(:+)
+
+puts
+puts "Max rtr queue len\t: #{max_rqueue_len}"
+puts "Max rtr queue wait\t: #{max_rqueue_wait.in_miliseconds}ms"
+puts "Sum rtr queue wait\t: #{sum_rqueue_wait.in_miliseconds}ms"
+puts "Avg rtr queue wait\t: #{(sum_rqueue_wait/(client_no*request_per_client)).in_miliseconds}ms"
+puts "Max thin queue len\t: #{max_thinqueue_len}"
+puts "Max thin queue wait\t: #{max_thinq_wait[:time].in_miliseconds}ms #{max_thinq_wait[:tag]}"
+puts "Sum thin queue wait\t: #{summary_thinqueue_wait.in_miliseconds}ms"
+puts "Avg. thin queue wait\t: #{(summary_thinqueue_wait/(client_no*request_per_client)).in_miliseconds}ms"
+
+long_time = (model.stats_summary[:application][:durations][""][:requests_long] || 0).to_f
+short_time = (model.stats_summary[:application][:durations][""][:requests_short] || 0).to_f
+long_count = (model.stats_summary[:application][:counters][""][:requests_long] || 0).to_f
+short_count = (model.stats_summary[:application][:counters][""][:requests_short] || 0).to_f
+
+if short_count > 0
+  short_req_avg = short_time / short_count
+  puts "Short req. avg\t\t: #{short_req_avg.in_miliseconds}ms"
+end
+
+if long_count > 0
+  long_req_avg = long_time / long_count
+  puts "Long req. avg\t\t: #{long_req_avg.in_miliseconds}ms"
+end
+
+file = "rtr_#{router_no}_req_#{request_per_client}.dump"
+model.stats_save file
+puts "\nStats saved in #{file}"
+

data/sim_process.rb

@@ -0,0 +1,83 @@
+require 'hlmodel'
+require 'tcpn'
+
+class ProcessToken < RBSim::HLModel::Process
+  include TCPN::TokenMethods
+end
+
+class CPU
+  attr_accessor :node, :performance
+  def initialize(node, performance)
+    @node, @performance = node, performance
+  end
+end
+
+class CPUToken < CPU
+  include TCPN::TokenMethods
+end
+
+class Handler
+  def call(*)
+    2345
+  end
+end
+
+def doproc(&block)
+  return block
+end
+
+model = TCPN.read 'lib/tcpn/model/application.rb'
+
+process = ProcessToken.new(:node01)
+process.on_event :data do |process, args|
+  handler = proc do |cpu|
+    4000 * args[:volume]/cpu.performance
+  end
+  process.register_event :cpu, block: handler
+  process.register_event :delay_for, time: 300
+  if args[:volume] > 10
+    process.register_event :data, volume: args[:volume]/10
+  else
+    constructor = proc do |process, args|
+      puts "===> FORKED <=="
+      process.register_event :delay_for, time: args
+      process.register_event :send_data, volume: args, type: :HTTP_REQUEST
+    end
+    process.register_event :new_process, program: :curl, constructor: constructor, constructor_args: 5000
+  end
+  process.register_event :send_data, volume: args[:volume], type: :response
+end
+
+
+#handler = Handler.new
+handler = Proc.new { |cpu| 1000/cpu.performance } # java error if handler is set to Proc or lambda...
+#handler = Proc.new { |cpu| 1000 } # java error if handler is set to Proc or lambda...
+#handler = doproc do |cpu|
+#  1000/cpu.performance
+#end
+process.register_event(:cpu, block: handler )
+process.register_event(:cpu, block: handler )
+process.register_event(:data, volume: 1000)
+#process.register_event(:delay_for, time: 100)
+model.add_marking_for 'process', process
+
+cpu = CPUToken.new(:node01, 10)
+model.add_marking_for 'CPU', cpu
+
+sim = TCPN.sim model
+
+sim.cb_for :transition, :after do |t, e|
+  puts "==> FIRING: #{e.transition} #{e.binding.map { |k, v| "#{k}: #{v}"}.join ',' }"
+  #puts model.marking
+end
+
+sim.cb_for :clock, :after do |t, e|
+  puts e.clock #if (tick += 1) % 100 == 0
+end
+
+sim.run
+
+puts model.marking
+
+process = sim.model.marking_for 'process'
+p process

data/sim_process_dsl.rb

@@ -0,0 +1,58 @@
+require 'rbsim'
+require 'tcpn'
+
+class CPU
+  attr_accessor :node, :performance
+  def initialize(node, performance)
+    @node, @performance = node, performance
+  end
+end
+
+class CPUToken < CPU
+  include TCPN::TokenMethods
+end
+
+hlmodel = RBSim.dsl do
+  new_process :worker do
+    on_event :data do |volume|
+      delay_for 100
+      cpu do |c|
+        12/c.performance
+      end
+    end
+    delay_for 100
+    cpu do |cpu|
+      100/cpu.performance
+    end
+    register_event :data, 1000
+  end
+end
+
+
+process_token = hlmodel.processes[:worker]
+process_token.node = :node01
+cpu_token = CPUToken.new(:node01, 10)
+
+
+tcpn = TCPN.read 'lib/tcpn/model/application.rb'
+
+tcpn.add_marking_for 'CPU', cpu_token
+tcpn.add_marking_for 'process', process_token
+
+sim = TCPN.sim tcpn
+
+transitions = []
+sim.cb_for :transition, :after do |t, e|
+  transitions << e.transition
+  puts "==> FIRING: #{e.transition} #{e.binding.map { |k, v| "#{k}: #{v}"}.join ',' }"
+  #puts model.marking
+end
+
+sim.run
+
+p transitions
+
+puts " MARKING ".center(70, '=')
+tcpn.marking.each do |p, m|
+  puts "#{p}: #{m}"
+end

data/spec/dsl/infrastructure_nets_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe 'RBSim#dsl' do
+  context "model with two nets" do
+
+    let(:model) do
+     RBSim.dsl do
+
+      net :net01, bw: 100, delay: 10
+      net :net02, bw: 1000, delay: 20, drop: 0.3
+
+     end
+    end
+
+    it "has two nets" do
+      expect(model.nets.size).to eq 2
+    end
+
+    it "has net called :net01" do
+      expect(model.nets.first.name).to eq :net01
+    end
+    context "net called :net01" do
+      subject { model.nets.first }
+      its(:bw) { should eq(100) }
+      its(:delay) { should eq(10) }
+    end
+
+    it "has net called :net02" do
+      expect(model.nets[1].name).to eq :net02
+    end
+    context "net called :net02" do
+      subject { model.nets[1] }
+      its(:bw) { should eq(1000) }
+      its(:delay) { should eq(20) }
+      its(:drop) { should eq(0.3) }
+    end
+  end
+
+end

data/spec/dsl/infrastructure_nodes_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe "RBSim#dsl" do
+  context "model with one empty node" do
+    let(:model) do
+      RBSim.dsl do
+        node :worker do
+        end
+      end
+    end
+
+    it "has one node" do
+      expect(model.nodes.size).to eq(1)
+    end
+
+    it "has node called :worker" do
+      expect(model.nodes.first.name).to eq(:worker)
+    end
+
+    it "has node with no CPUs" do
+      expect(model.nodes.first.cpus.size).to eq(0)
+    end
+
+  end
+
+  context "model with nodes and CPUs" do
+    let(:model) do
+      RBSim.dsl do
+
+        node :worker1 do
+          cpu 1000
+          cpu 2000
+        end
+        node :worker2 do
+          cpu 200
+        end
+
+      end
+    end
+
+    it "has two nodes" do
+      expect(model.nodes.size).to eq 2
+    end
+
+    it "has first node called :worker1" do
+      expect(model.nodes.first.name).to eq :worker1
+    end
+
+    it "has first node with two cpus" do
+      expect(model.nodes.first.cpus.size).to eq 2
+    end
+
+    it "has first node with first cpu with performance 1000" do
+      expect(model.nodes.first.cpus.first.performance).to eq 1000
+    end
+
+
+    it "has first node with second cpu with performance 2000" do
+      expect(model.nodes.first.cpus[1].performance).to eq 2000
+    end
+
+    it "has second node called :worker2" do
+      expect(model.nodes[1].name).to eq :worker2
+    end
+
+    it "has second node with cpu with performance 200" do
+      expect(model.nodes[1].cpus.first.performance).to eq 200
+    end
+
+  end
+
+end