sisfc 0.1.0 → 0.2.0

data/lib/sisfc/data_center.rb

@@ -1,57 +1,70 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
 module SISFC
 
   class DataCenter
+    extend Forwardable
+
+    def_delegator :@vms, :has_key?, :has_vms_of_type?
+
+    attr_reader :dcid, :location_id
 
-    def initialize(id, opts)
-      @dcid      = id
-      @capacity  = opts[:maximum_vm_capacity]
-      @available = @capacity.dup
-      @vms       = {}
+    def initialize(id:, location_id:, name:, type:, **opts)
+      @dcid          = id
+      @location_id   = location_id
+      @vms           = {}
+      @vm_type_count = {}
+      @name          = name
+      @type          = type
+      raise ArgumentError, "Unsupported type!" unless [ :private, :public ].include?(@type)
+      @availability_check_proc = opts[:maximum_vm_capacity]
     end
 
+    # returns false in case no more VMs can be allocated
     def add_vm(vm, component_name)
       @vms[component_name] ||= []
+      @vm_type_count[vm.size] ||= 0
+
       raise 'Error! VM is already present!' if @vms[component_name].include? vm
-      if @available[vm.size] > 0
-        @available[vm.size] -= 1
-      else
-        raise 'Error! VM capacity exceeded!'
+
+      # defer availablility check to user specified procedure
+      if @availability_check_proc
+        return false unless @availability_check_proc.call(@vm_type_count)
       end
+
+      # allocate VM
       @vms[component_name] << vm
+      @vm_type_count[vm.size] += 1
     end
 
     def remove_vm(vm, component_name)
-      unless @vms.has_key? component_name
-        raise "Error! Service component type #{component_name} not present in data center #{@dcid}!"
-      end
-      unless @vms[component_name].include? vm
-        raise 'Error! VM not present!'
+      if @vms.has_key? component_name and @vms[component_name].include? vm
+        raise 'Error! Inconsistent number of VMs!' unless @vm_type_count[vm.size] >= 1
+        @vm_type_count[vm.size] += 1
+        @vms.delete(vm)
       end
-      @available[vm.size] += 1
-      @vms.delete(vm)
     end
 
+    # returns nil in case no VM for component component_name is running
     def get_random_vm(component_name)
-      unless @vms.has_key? component_name
-        raise "Error! Service component type #{component_name} not present in data center #{@dcid}!"
+      if @vms.has_key? component_name
+        @vms[component_name].sample
       end
-      @vms[component_name].sample
     end
 
-    def get_number_of_vms(component_name)
-      unless @vms.has_key? component_name
-        raise "Error! Service component type #{component_name} not present in data center #{@dcid}!"
-      end
-      @vms[component_name].size
+    def to_s
+      "Data center #{@dcid}, with VMs:" +
+        @vms.inject("") {|s,(k,v)| s += " (#{k}: #{v.size})" }
     end
 
-    def available(size)
-      @available[size]
+    def private?
+      @type == :private
     end
 
-    def to_s
-      "Data center #{@dcid}, with VMs:" +
-        @vms.inject("") {|s,(k,v)| s += " (#{k}: #{v.size})" }
+    def public?
+      @type == :public
     end
 
   end

data/lib/sisfc/evaluation.rb

@@ -1,35 +1,43 @@
-require 'sisfc/configuration'
+# frozen_string_literal: true
+
+require_relative './logger'
 
 module SISFC
   class Evaluator
+
+    include Logging
+
     def initialize(conf)
       @vm_hourly_cost = conf.evaluation[:vm_hourly_cost]
       raise ArgumentError, 'No VM hourly costs provided!' unless @vm_hourly_cost
 
+      @fixed_hourly_cost = conf.evaluation[:fixed_hourly_cost] || {}
+
       @penalties_func = conf.evaluation[:penalties]
     end
 
-    def evaluate_business_impact(kpis, dc_kpis, vm_allocation)
-      # evaluate VM daily costs
+    def evaluate_business_impact(all_kpis, per_workflow_and_customer_kpis,
+                                 vm_allocation)
+      # evaluate variable hourly costs related to VM allocation
       cost = vm_allocation.inject(0.0) do |s,x|
         hc = @vm_hourly_cost.find{|i| i[:data_center] == x[:dc_id] and i[:vm_type] == x[:vm_size] }
-        unless hc
-          raise "Cannot find hourly cost for data center #{x[:dc_id]} and VM size #{x[:vm_size]}!"
-        end
+        raise "Cannot find hourly cost for data center #{x[:dc_id]} and VM size #{x[:vm_size]}!" unless hc
         s += x[:vm_num] * hc[:cost]
       end
+
+      # evaluate fixed hourly costs (for private Cloud data centers)
+      @fixed_hourly_cost.values.each do |fixed_cost|
+        cost += fixed_cost
+      end
+
+      # calculate daily cost
       cost *= 24.0
-      kpis[:cost] = cost
-      # puts "vm allocation cost: #{cost}"
 
-      # consider SLO violations
-      penalties = (@penalties_func.nil? ? 0.0 : (@penalties_func.call(kpis, dc_kpis) or 0.0))
-      kpis[:penalties] = penalties
-      # puts "slo penalties cost: #{penalties}"
-      cost += penalties
+      # consider SLO violation penalties
+      penalties = (@penalties_func.nil? ? 0.0 : (@penalties_func.call(all_kpis, per_workflow_and_customer_kpis) or 0.0))
 
-      # we want to minimize the cost, so we define fitness as -cost
-      fitness = -cost
+      { it_cost:   cost,
+        penalties: penalties }
     end
   end
 end

data/lib/sisfc/event.rb

@@ -1,13 +1,16 @@
+# frozen_string_literal: true
+
 module SISFC
 
   class Event
 
-    ET_REQUEST_ARRIVAL         = 0
-    ET_WORKFLOW_STEP_COMPLETED = 1
-    ET_VM_FREE                 = 2
-    ET_VM_SUSPEND              = 3
-    ET_VM_RESUME               = 4
-    ET_REQUEST_CLOSURE         = 5
+    ET_REQUEST_GENERATION      = 0
+    ET_REQUEST_ARRIVAL         = 1
+    ET_REQUEST_FORWARDING      = 2
+    ET_WORKFLOW_STEP_COMPLETED = 3
+    ET_REQUEST_CLOSURE         = 4
+    # ET_VM_SUSPEND              = 5
+    # ET_VM_RESUME               = 6
     ET_END_OF_SIMULATION       = 100
 
     # let the comparable mixin provide the < and > operators for us

data/lib/sisfc/generator.rb

@@ -1,21 +1,19 @@
-require 'csv'
-require 'sisfc/request'
-
+# frozen_string_literal: true
 
 module SISFC
 
   class RequestGenerator
 
-    def initialize(opts)
+    def initialize(opts={})
       if opts.has_key? :filename
         filename = opts[:filename]
-        raise "File #{filename} does not exist!" unless File.exists?(filename)
+        raise ArgumentError, "File #{filename} does not exist!" unless File.exists?(filename)
         @file = File.open(filename, mode='r')
       elsif opts.has_key? :command
         command = opts[:command]
         @file = IO.popen(command)
       else
-        raise ArgumentError, 'Need to provide either a filename or a command!'
+        raise ArgumentError, "Need to provide either a filename or a command!"
       end
 
       # throw away the first line (containing the CSV headers)
@@ -34,26 +32,21 @@ module SISFC
       raise "End of input reached while reading request #{@next_rid}!" unless line
 
       # parse data
-      tokens = line.parse_csv
+      tokens = line.split(",") # should be faster than CSV parsing
       generation_time  = tokens[0].to_f
-      data_center_id   = tokens[1].to_i
-      arrival_time     = tokens[2].to_f
-      workflow_type_id = tokens[3].to_i
+      workflow_type_id = tokens[1].to_i
+      customer_id      = tokens[2].to_i
 
       # increase @next_rid
       @next_rid += 1
 
-      # sanity check
-      if generation_time > arrival_time
-        raise "Generation time (#{generation_time}) is larger than arrival time (#{arrival_time})!"
-      end
-
-      # generate and return request
-      Request.new(@next_rid,
-                  generation_time,
-                  data_center_id,
-                  arrival_time,
-                  workflow_type_id)
+      # return request
+      {
+        rid: @next_rid,
+        generation_time: generation_time,
+        workflow_type_id: workflow_type_id,
+        customer_id: customer_id,
+      }
     end
 
 

data/lib/sisfc/latency_manager.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'erv'
+
+module SISFC
+  class LatencyManager
+    def initialize(latency_models)
+      # here we build a (strictly upper triangular) matrix of random variables
+      # that represent the communication latency models between the different
+      # locations
+      @latency_models_matrix = latency_models.map do |lms_conf|
+        lms_conf.map do |rv_conf| 
+          rv_conf
+          ERV::RandomVariable.new(rv_conf) 
+        end
+      end
+
+      # should we turn @latency_models_matrix from a (strictly upper)
+      # triangular to a full matrix, for convenience? probably not. it would
+      # require more memory and: 1) ruby is ***very*** memory hungry already,
+      # 2) ruby's performance is very sensitive to memory usage.
+
+      # precalculate average latencies
+      @average_latency_matrix = @latency_models_matrix.map do |lms|
+        lms.map{|x| x.mean }
+      end
+
+      # latency in the same location is implemented as a truncated gaussian
+      # with mean = 20ms, sd = 5ms, and a = 2ms
+      @same_location_latency = ERV::RandomVariable.new(distribution: :gaussian, args: { mean: 20E-3, sd: 5E-3 })
+    end
+
+    def sample_latency_between(loc1, loc2)
+      if loc1 == loc2
+        # rejection sampling to implement (crudely) PDF truncation
+        while (lat = @same_location_latency.next) < 2E-3; end
+        lat
+      else
+        l1, l2 = loc1 < loc2 ? [ loc1, loc2 ] : [ loc2, loc1 ]
+
+        # since we use a compact representation for @latency_models_matrix, the
+        # indexes become l1 and (l2-l1-1)
+        # rejection sampling to implement (crudely) PDF truncation to positive numbers
+        while (lat = @latency_models_matrix[l1][l2-l1-1].next) <= 0.0; end
+        lat
+      end
+    end
+
+    def average_latency_between(loc1, loc2)
+      # the results returned by this method are not entirely accurate, because
+      # rejection sampling changes the shape of the PDF. see, e.g.,
+      # https://stackoverflow.com/questions/47933019/how-to-properly-sample-truncated-distributions
+      # still, it is an acceptable approximation
+      if loc1 == loc2
+        @same_location_latency.mean
+      else
+        l1, l2 = loc1 < loc2 ? [ loc1, loc2 ] : [ loc2, loc1 ]
+
+        # since we use a compact representation for @average_latency_between, the
+        # indexes become l1 and (l2-l1-1)
+        @average_latency_between[l1][l2-l1-1]
+      end
+    end
+  end
+end

data/lib/sisfc/logger.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+
+module SISFC
+  module Logging
+    class << self
+      def logger
+        @logger ||= ::Logger.new(STDERR).tap{|l| l.level = ::Logger::INFO }
+      end
+    end
+
+    def self.included(base)
+      class << base
+        # this version of the logger method will be called from class methods
+        def logger
+          Logging.logger
+        end
+      end
+    end
+
+    # this version of the logger method will be called from instance methods
+    def logger
+      Logging.logger
+    end
+  end
+end

data/lib/sisfc/request.rb

@@ -1,101 +1,65 @@
-module SISFC
+# frozen_string_literal: true
 
+module SISFC
   class Request
 
-    # states
-    STATE_WORKING   = 1
-    STATE_SUSPENDED = 2
-
-    attr_accessor :rid, :generation_time, :data_center_id, :arrival_time,
-                  :workflow_type_id, :closure_time #, :status
-    attr_reader :communication_latency
-
-    def initialize(rid, generation_time, data_center_id, arrival_time, workflow_type_id)
+    # # states
+    # STATE_WORKING   = 1
+    # STATE_SUSPENDED = 2
+
+    attr_reader :rid,
+                :arrival_time,
+                :closure_time,
+                # :communication_latency,
+                :customer_id,
+                :generation_time,
+                :next_step,
+                # :status,
+                :workflow_type_id
+
+    # the data_center_id attribute is updated as requests move from a Cloud
+    # data center to another
+    attr_accessor :data_center_id
+
+    def initialize(rid:,
+                   generation_time:,
+                   initial_data_center_id:,
+                   arrival_time:,
+                   workflow_type_id:,
+                   customer_id:)
       @rid              = rid
       @generation_time  = generation_time
-      @data_center_id   = data_center_id
+      @data_center_id   = initial_data_center_id
       @arrival_time     = arrival_time
       @workflow_type_id = workflow_type_id
+      @customer_id      = customer_id
 
-      # steps count from zero
-      @step = 0
+      # steps start counting from zero
+      @next_step = 0
 
       # calculate communication latency
       @communication_latency = @arrival_time - @generation_time
 
-      # consider initial communication latency
-      @tracking_information  = [
-        {
-          :type     => :communication,
-          :at       => @generation_time,
-          :duration => @communication_latency,
-        }
-      ]
-
-      # NOTE: the format for each element of the @tracking_information array is:
-      # { :type => one of [ :queue, :work, :communication ]
-      #   :at => begin time
-      #   :duration => duration
-      #   :vm => vm (optional)
-      # }
-    end
-
-    def queuing_completed(start, duration)
-      @tracking_information << {
-        :type     => :queue,
-        :at       => start,
-        :duration => duration,
-        # :vm =>
-      }
+      @queuing_time = 0.0
+      @working_time = 0.0
     end
 
-    def step_completed(start, duration)
-      @tracking_information << {
-        :type     => :work,
-        :at       => start,
-        :duration => duration,
-        # :vm =>
-      }
-      @step += 1
+    def update_queuing_time(duration)
+      @queuing_time += duration
     end
 
-    def finished_processing(time)
-      # consider final communication latency
-      @tracking_information << {
-        :type     => :communication,
-        :at       => time,
-        :duration => @communication_latency,
-      }
-      # save closure time
-      @closure_time = time + @communication_latency
+    def update_transfer_time(duration)
+      @communication_latency += duration
     end
 
-    def next_step
-      @step
+    def step_completed(duration)
+      @working_time += duration
+      @next_step += 1
     end
 
-    def with_tracking_information(type=:all)
-      selected_ti = if type == :all
-        @tracking_information
-      else
-        @tracking_information.select{|el| el.type == type }
-      end
-
-      selected_ti.each do |ti|
-        yield ti
-      end
-    end
-
-    def total_communication_time
-      calculate_time(:communication)
-    end
-
-    def total_work_time
-      calculate_time(:work)
-    end
-
-    def total_queue_time
-      calculate_time(:queue)
+    def finished_processing(time)
+      # save closure time
+      @closure_time = time
     end
 
     def closed?
@@ -110,13 +74,6 @@ module SISFC
     def to_s
       "rid: #{@rid}, generation_time: #{@generation_time}, data_center_id: #{@data_center_id}, arrival_time: #{@arrival_time}"
     end
-
-    private
-
-      def calculate_time(type)
-        return 0 unless @tracking_information
-        @tracking_information.inject(0) {|sum,x| sum += ((type == :all || type == x[:type]) ? x[:duration].to_i : 0) }
-      end
   end
 
 end