sisfc 0.0.1

data/lib/sisfc/simulation.rb

@@ -0,0 +1,205 @@
+require 'sisfc/data_center'
+require 'sisfc/event'
+require 'sisfc/generator'
+require 'sisfc/sorted_array'
+require 'sisfc/statistics'
+require 'sisfc/vm'
+
+
+module SISFC
+  class Simulation
+
+    attr_reader :start_time
+
+
+    def initialize(opts = {})
+      @configuration = opts[:configuration]
+      @evaluator     = opts[:evaluator]
+    end
+
+
+    def new_event(type, data, time, destination)
+      e = Event.new(type, data, time, destination)
+      @event_queue << e
+    end
+
+
+    def now
+      @current_time
+    end
+
+
+    def evaluate_allocation(vm_allocation)
+      # setup simulation start and current time
+      @current_time = @start_time = @configuration.start_time
+
+      # create data centers
+      data_centers = @configuration.data_centers.map {|k,v| DataCenter.new(k,v) }
+
+      # initialize statistics
+      stats    = Statistics.new
+      dc_stats = data_centers.map {|k,v| Statistics.new }
+
+      # create VMs
+      @vms = []
+      vmid = 0
+      vm_allocation.each do |opts|
+        # setup service_time_distribution
+        opts[:service_time_distribution] = @configuration.service_component_types[opts[:component_type]][:service_time_distribution]
+
+        # allocate the VMs
+        opts[:vm_num].times do
+          # create VM ...
+          vm = VM.new(vmid, opts) # vm = VM.new(vmid, opts.except(:vm_num))
+          # ... add it to the vm list ...
+          @vms << vm
+          # ... and register it in the corresponding data center
+          data_centers[opts[:dc_id]-1].add_vm(vm, opts[:component_type])
+          # update vm id
+          vmid += 1
+        end
+      end
+
+      # create event queue
+      @event_queue = SortedArray.new
+
+      # puts "========== Simulation Start =========="
+
+      # generate first request
+      rg = RequestGenerator.new(@configuration.request_generation)
+      new_req = rg.generate
+      new_event(Event::ET_REQUEST_ARRIVAL, new_req, new_req.arrival_time, nil)
+
+      # schedule end of simulation
+      unless @configuration.end_time.nil?
+        # puts "Simulation ends at: #{@configuration.end_time}"
+        new_event(Event::ET_END_OF_SIMULATION, nil, @configuration.end_time, nil)
+      end
+
+      # calculate warmup threshold
+      warmup_threshold = @configuration.start_time + @configuration.warmup_duration.to_i
+
+      requests_being_worked_on = 0
+      events = 0
+
+      # launch simulation
+      until @event_queue.empty?
+        e = @event_queue.shift
+
+        events += 1
+        # sanity check on simulation time flow
+        if @current_time > e.time
+          raise "Error: simulation time inconsistency for event #{events} " +
+                "e.type=#{e.type} @current_time=#{@current_time}, e.time=#{e.time}"
+        end
+
+        @current_time = e.time
+
+        case e.type
+          when Event::ET_REQUEST_ARRIVAL
+            # get request
+            req = e.data
+
+            # find data center
+            data_center = data_centers[req.data_center_id-1]
+
+            # find next component name
+            workflow = @configuration.workflow_types[req.workflow_type_id]
+            next_component_name = workflow[:component_sequence][req.next_step][:name]
+
+            # get random vm providing next service component type
+            vm = data_center.get_random_vm(next_component_name)
+
+            # forward request to the vm
+            vm.new_request(self, req, e.time)
+
+            # update stats
+            if req.arrival_time > warmup_threshold
+              # increase the number of requests being worked on
+              requests_being_worked_on += 1
+            end
+
+            # generate next request
+            new_req = rg.generate
+            new_event(Event::ET_REQUEST_ARRIVAL, new_req, new_req.arrival_time, nil)
+
+
+          # Leave these events for when we add VM migration support
+          # when Event::ET_VM_SUSPEND
+          # when Event::ET_VM_RESUME
+
+
+          when Event::ET_WORKFLOW_STEP_COMPLETED
+            # retrieve request and vm
+            req = e.data
+            vm  = e.destination
+
+            # tell the old vm that it can start processing another request
+            vm.request_finished(self, e.time)
+
+            # find data center and workflow
+            data_center = data_centers[req.data_center_id-1]
+            workflow    = @configuration.workflow_types[req.workflow_type_id]
+
+            # check if there are other steps left to complete the workflow
+            if req.next_step < workflow[:component_sequence].size
+              # find next component name
+              next_component_name = workflow[:component_sequence][req.next_step][:name]
+
+              # get random vm providing next service component type
+              new_vm = data_center.get_random_vm(next_component_name)
+
+              # forward request to the new vm
+              new_vm.new_request(self, req, e.time)
+            else # workflow is finished
+              # schedule request closure
+              new_event(Event::ET_REQUEST_CLOSURE, req, e.time + req.communication_latency, nil)
+            end
+
+
+          when Event::ET_REQUEST_CLOSURE
+            # retrieve request and vm
+            req = e.data
+
+            # request is closed
+            req.finished_processing(e.time)
+
+            # update stats
+            if req.arrival_time > warmup_threshold
+              # decrease the number of requests being worked on
+              requests_being_worked_on -= 1
+
+              # collect request statistics
+              stats.record_request(req)
+              dc_stats[req.data_center_id - 1].record_request(req)
+            end
+
+
+          when Event::ET_END_OF_SIMULATION
+            # puts "#{e.time}: end simulation"
+            break
+
+        end
+      end
+
+      # puts "========== Simulation Finished =========="
+
+      # calculate kpis (for the moment, we only have mttr)
+      kpis = { :mttr            => stats.mean,
+               :served_requests => stats.n,
+               :queued_requests => requests_being_worked_on }
+      dc_kpis = dc_stats.map do |s|
+        { :mttr            => s.mean,
+          :served_requests => s.n, }
+      end
+      fitness = @evaluator.evaluate_business_impact(kpis, dc_kpis, vm_allocation)
+      puts "====== Evaluating new allocation ======\n" +
+        vm_allocation.map{|x| x.except(:service_time_distribution) }.inspect + "\n" +
+        "kpis #{kpis.to_s}\n" +
+        "dc_kpis: #{dc_kpis.to_s}\n" +
+        "=======================================\n"
+      fitness
+    end
+
+  end
+end

data/lib/sisfc/sorted_array.rb

@@ -0,0 +1,57 @@
+module SISFC
+  # the SortedArray class was taken from the ruby cookbook
+  class SortedArray < Array
+    def initialize(*args, &sort_by)
+      @sort_by = sort_by || Proc.new { |x,y| x <=> y }
+      super(*args)
+      sort! &sort_by
+    end
+
+    def insert(i, v)
+      if size == 0 or v < self[0]
+        super(0, v)
+      elsif v > self[-1]
+        super(-1, v)
+      else
+        left = 0
+        right = size - 1
+        middle = (left + right)/2
+        while left < right
+          if v >= self[middle]
+            left = middle + 1
+          else
+            right = middle
+          end
+          middle = (left + right)/2
+        end
+        super(middle, v)
+      end
+    end
+
+    def <<(el)
+      insert(0, el)
+    end
+
+    alias push <<
+    alias unshift <<
+
+    # some methods, like collect!, can modify the items in an array,
+    # taking them out of sort order. we need to redefine those
+    # methods.
+    # we can't use define_method to define these methods because in
+    # Ruby 1.8 you can't use define_method to create a method that
+    # takes a block argument.
+    [ "collect!", "flatten!", "[]=" ].each do |method_name|
+      class_eval %{
+        def #{method_name}(*args)
+          super
+          sort! &@sort_by
+        end
+      }
+    end
+
+    def reverse!
+      # do nothing: reversing the array would disorder it.
+    end
+  end
+end

data/lib/sisfc/statistics.rb

@@ -0,0 +1,29 @@
+require 'sisfc/request'
+
+module SISFC
+  class Statistics
+    attr_reader :mean, :n
+
+    # see http://en.wikipedia.org/wiki/Algorithms_for_calculating_variance#Online_algorithm
+    def initialize
+      @n    = 0 # number of requests
+      @mean = 0.0
+      @m_2  = 0.0
+    end
+
+    def record_request(req)
+      # get new sample
+      x = req.ttr
+
+      # update counters
+      @n += 1
+      delta = x - @mean
+      @mean += delta / @n
+      @m_2  += delta * (x - @mean)
+    end
+
+    def variance
+      @m_2 / (@n - 1)
+    end
+  end
+end

data/lib/sisfc/support/dsl_helper.rb

@@ -0,0 +1,18 @@
+# taken from Jim Freeze's excellent article "Creating DSLs with Ruby"
+# http://www.artima.com/rubycs/articles/ruby_as_dsl.html
+
+class Module
+  def dsl_accessor(*symbols)
+    symbols.each { |sym|
+      class_eval %{
+        def #{sym}(*val)
+          if val.empty?
+            @#{sym}
+          else
+            @#{sym} = val.size == 1 ? val[0] : val
+          end
+        end
+      }
+    }
+  end
+end

data/lib/sisfc/version.rb

@@ -0,0 +1,3 @@
+module SISFC
+  VERSION = '0.0.1'
+end

data/lib/sisfc/vm.rb

@@ -0,0 +1,86 @@
+require 'sisfc/event'
+require 'erv'
+
+
+module SISFC
+
+  class VM
+
+    # setup readable/accessible attributes
+    ATTRIBUTES = [ :vmid, :dc_id, :size ]
+
+    attr_reader *ATTRIBUTES
+
+    def initialize(vmid, opts)
+      # make sure all the required opts were provided
+      [ :dc_id, :vm_size, :service_time_distribution ].each do |k|
+        raise ArgumentError, "opts[:#{k}] missing" unless opts.has_key? k
+      end
+
+      @vmid             = vmid
+      @dcid             = opts[:dc_id]
+      @size             = opts[:vm_size]
+      @service_times_rv = ERV::RandomVariable.new(opts[:service_time_distribution][@size])
+
+      # initialize request queue and related tracking information
+      @busy          = false
+      @request_queue = []
+
+      # @request_queue_info          = []
+      # @request_currently_servicing = nil
+    end
+
+    def new_request(sim, r, time)
+      # put the (request, service time, arrival time) tuple at the end of the queue
+      @request_queue << [ r, @service_times_rv.next, time ]
+
+      # update queue size tracking information
+      # @request_queue_info << { :size => @request_queue.size, :time => time }
+
+      unless @busy
+        # try to allocate operator
+        try_servicing_new_request(sim, time)
+      end
+    end
+
+    def request_finished(sim, time)
+      @busy = false
+      try_servicing_new_request(sim, time)
+    end
+
+    # def suspend(time)
+    #   raise "VM is already suspended!" if @suspended
+    #   @request_currently_servicing.finishing_time =
+    #   @request_currently_servicing.status = Request::STATE_WORKING
+    # end
+
+    # def resume(time)
+    #   raise "VM is already working!" unless @suspended
+    # end
+
+    private
+
+      def try_servicing_new_request(sim, time)
+        raise "Busy VM (vmid: #{@vmid})!" if @busy
+
+        unless @request_queue.empty?
+          # pick request and metadata from the incoming request queue
+          req, service_time, arrival_time = @request_queue.shift
+
+          # update the request's queuing information
+          req.queuing_completed(arrival_time, time - arrival_time)
+
+          # the VM is busy now
+          @busy = true
+
+          # update the request's working information
+          req.step_completed(time, time + service_time)
+
+          # schedule completion of workflow step
+          sim.new_event(Event::ET_WORKFLOW_STEP_COMPLETED, req, time + service_time, self)
+        end
+      end
+
+  end
+
+end

data/lib/sisfc.rb

@@ -0,0 +1,4 @@
+require 'active_support/time'
+
+require 'sisfc/configuration'
+require 'sisfc/simulation'

data/sisfc.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sisfc/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'sisfc'
+  spec.version       = SISFC::VERSION
+  spec.authors       = ['Mauro Tortonesi']
+  spec.email         = ['mauro.tortonesi@unife.it']
+  spec.description   = %q{Simulator for IT Services in Federated Clouds}
+  spec.summary       = %q{A simulator for business-driven IT management research capable of evaluating IT service component placement in federated Cloud environments}
+  spec.homepage      = 'https://github.com/mtortonesi/sisfc'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/).reject{|x| x == '.gitignore' }
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'activesupport', '~> 4.0.0'
+  spec.add_dependency 'awesome_print', '~> 1.2.0'
+  spec.add_dependency 'erv', '~> 0.0.2'
+
+  spec.add_development_dependency 'bundler', '~> 1.5.3'
+  spec.add_development_dependency 'rake', '~> 10.1.1'
+end

data/test/sisfc/configuration_test.rb

@@ -0,0 +1,94 @@
+require 'test_helper'
+
+require 'sisfc/reference_configuration'
+
+
+describe SISFC::Configuration do
+
+  describe 'simulation-related parameters' do
+
+    it 'should correctly load simulation start' do
+      with_reference_config do |conf|
+        conf.start_time.must_equal START_TIME
+      end
+    end
+
+    it 'should correctly load simulation duration' do
+      with_reference_config do |conf|
+        conf.duration.must_equal DURATION
+      end
+    end
+
+    it 'should correctly load simulation end time' do
+      with_reference_config do |conf|
+        conf.end_time.must_equal START_TIME + DURATION
+      end
+    end
+
+    it 'should correctly load warmup phase duration' do
+      with_reference_config do |conf|
+        conf.warmup_duration.must_equal WARMUP_DURATION
+      end
+    end
+
+  end
+
+
+  describe 'service_component_types' do
+
+    it 'should have 3 items' do
+      with_reference_config do |conf|
+        conf.service_component_types.size.must_equal 3
+      end
+    end
+
+    it 'should define a Web Server' do
+      with_reference_config do |conf|
+        conf.service_component_types.keys.must_include('Web Server')
+      end
+    end
+
+    it 'should define an App Server' do
+      with_reference_config do |conf|
+        conf.service_component_types.keys.must_include('App Server')
+      end
+    end
+
+    it 'should define a Financial Transaction Server' do
+      with_reference_config do |conf|
+        conf.service_component_types.keys.must_include('Financial Transaction Server')
+      end
+    end
+
+    describe 'the Web Server' do
+      it 'should work on medium or large VMs' do
+        with_reference_config do |conf|
+          item_conf = conf.service_component_types['Web Server']
+          item_conf[:allowed_vm_types].must_include(:medium)
+          item_conf[:allowed_vm_types].must_include(:large)
+        end
+      end
+    end
+
+    describe 'the App Server' do
+      it 'should work on large and huge VMs' do
+        with_reference_config do |conf|
+          item_conf = conf.service_component_types['App Server']
+          item_conf[:allowed_vm_types].must_include(:large)
+          item_conf[:allowed_vm_types].must_include(:huge)
+        end
+      end
+    end
+
+  end
+
+
+  describe 'data_centers' do
+    it 'should have 5 items' do
+      with_reference_config do |conf|
+        conf.data_centers.size.must_equal 5
+      end
+    end
+  end
+
+end

data/test/sisfc/generator_test.rb

@@ -0,0 +1,63 @@
+require 'tempfile'
+
+require 'test_helper'
+require 'sisfc/generator'
+
+
+describe SISFC::RequestGenerator do
+
+  GENERATION_TIMES = [ Time.now, Time.now + 1.second, Time.now + 2.seconds ].map(&:to_f)
+  DATA_CENTER_IDS  = (1..GENERATION_TIMES.size).to_a
+  ARRIVAL_TIMES    = GENERATION_TIMES.map {|x| x + 1.0 }
+  WORKFLOW_IDS     = GENERATION_TIMES.map { rand(10) }
+  REQUEST_GENERATION_DATA=<<-END
+    Generation Time,Data Center ID,Arrival Time,Workflow ID
+    #{GENERATION_TIMES[0]},#{DATA_CENTER_IDS[0]},#{ARRIVAL_TIMES[0]},#{WORKFLOW_IDS[0]}
+    #{GENERATION_TIMES[1]},#{DATA_CENTER_IDS[1]},#{ARRIVAL_TIMES[1]},#{WORKFLOW_IDS[1]}
+    #{GENERATION_TIMES[2]},#{DATA_CENTER_IDS[2]},#{ARRIVAL_TIMES[2]},#{WORKFLOW_IDS[2]}
+  END
+
+  it 'should read from CSV file' do
+    begin
+      # create temporary file with request generation information
+      tf = Tempfile.new('generator_test')
+      tf.write(REQUEST_GENERATION_DATA)
+      tf.close
+
+      with_reference_config(request_generation: { filename: tf.path }) do |conf|
+        rg = SISFC::RequestGenerator.new(conf.request_generation)
+        r = rg.generate
+        r.rid.must_equal 1
+        r.generation_time.must_equal GENERATION_TIMES[0]
+        r.data_center_id.must_equal DATA_CENTER_IDS[0]
+        r.arrival_time.must_equal ARRIVAL_TIMES[0]
+      end
+
+    ensure
+      # delete temporary file
+      tf.delete
+    end
+  end
+
+  it 'should read from command' do
+    begin
+      # create temporary file with request generation information
+      tf = Tempfile.new('generator_test')
+      tf.write(REQUEST_GENERATION_DATA)
+      tf.close
+
+      with_reference_config(request_generation: { command: "cat #{tf.path}" }) do |conf|
+        rg = SISFC::RequestGenerator.new(conf.request_generation)
+        r = rg.generate
+        r.rid.must_equal 1
+        r.generation_time.must_equal GENERATION_TIMES[0]
+        r.data_center_id.must_equal DATA_CENTER_IDS[0]
+        r.arrival_time.must_equal ARRIVAL_TIMES[0]
+      end
+    ensure
+      # delete temporary file
+      tf.delete
+    end
+  end
+
+end