fast-tcpn 0.0.5

data/fast-tcpn.gemspec

@@ -0,0 +1,40 @@
+# Used this istruction to create the gem:
+# http://guides.rubygems.org/make-your-own-gem/
+# some things below were based on docile gem.
+
+$:.push File.expand_path('../lib', __FILE__)
+require 'fast-tcpn/version'
+
+Gem::Specification.new do |s|
+  s.name = 'fast-tcpn'
+  s.version = FastTCPN::VERSION
+  s.authors = ['Wojciech Rząsa']
+  s.email = %w(me@wojciechrzasa.pl)
+  s.homepage = 'https://github.com/wrzasa/fast-tcpn'
+  s.summary = 'FastTCPN is Ruby based modeling and simulation tool for simulation of TCPN with convenient DSL.'
+  s.description = 'You can model your Timed Colored Petri Net in Ruby using convenient DSL and simulate it quite efficiently.'
+  s.license = 'GPL-3.0'
+
+  s.platform = 'ruby'
+  s.required_ruby_version = '~> 2.0'
+
+#  s.rubyforge_project = ''
+
+  s.files = `git ls-files -z`.split("\x0")
+  s.test_files = s.files.grep(%r{^(test|spec|features)/})
+  s.executables = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  s.require_paths = %w(lib)
+
+  s.add_runtime_dependency 'docile', '~> 1.1'
+
+  # Running rspec tests from rake
+  s.add_development_dependency 'rspec', '~> 3.1'
+  s.add_development_dependency 'simplecov', '~> 0'
+
+  s.extra_rdoc_files << 'README.md'
+  s.rdoc_options << '--main' << 'README.md'
+  s.rdoc_options << '--title' << 'fast-tcpn -- Fast TCPN modeling and simulation tool'
+  s.rdoc_options << '--line-numbers'
+  s.rdoc_options << '-A'
+  s.rdoc_options << '-x coverage'
+end

data/fast-tcpn.rb

@@ -0,0 +1,192 @@
+# WRz 2014-11-14
+#
+# This is a proof of concept implementation of
+# fast TCPN simulator.
+# Main concept if that guard is not a function
+# receiving binding and answering if it is valid or not.
+# Instead guard gets list of all input tokens from input
+# places and returns valid bindngs. If programmer is a fool
+# and guard is naive, it will be slow as it was so far. But
+# generally it is possible to generate possible bindings
+# using Hashes in linear time (about n*k where k is number of
+# input places and n is number of tokens in each place) instead
+# of n**k as in case of analysing cartesian product for traditional
+# boolean guard.
+#
+# Since what we use instead of guard now is not precisely
+# what Jensen had in mind, we call it sentry, not to confuse
+# anyone.
+
+#
+# Note on cloning.
+#
+# Branch clone_selected_tokens assumes that only tokens
+# used by the user are cloned. Here we clone whole marking
+# before it can be used in guard or inscription. For well 
+# prepared guard, when possible small number of tokens is 
+# taken from marking it is faster to clone individual tokens 
+# (4 sec instead of 6.9 sec). But for worse guard it is faster 
+# to clone whole marking at the begining, then many individual 
+# tokens (14 sec. instead of 6.9 sec). The better guard in this
+# example is when we put all processes in a Hash and try to match 
+# a CPU, worse guard is when we put all CPUs in a Hash and try to 
+# match a process. We have 10 times more CPUs the processes in this 
+# example, and putting a token into a Hash requires cloning it.
+#
+# The above times were obtained for 1000 procs, 10 cpus for each and
+# ruby_deep_clone library.
+#
+# This library might also be worth checking:
+# https://github.com/flajann2/deep_dive/blob/master/lib/deep_dive/deep_dive.rb
+#
+#
+# THIS IS IMPLEMENTED with selective token cloning
+# Possible optimization.
+# If we could define how a place stores its marking, it would make
+# firing transition much faster. Ther would be no need to rewrite
+# tokens from array to other structure, e.g Hash. We could e.g. define
+# that processes should be stored in a Hash keyed by process name and
+# thus make all guards matching by process name much faster! How to
+# do this to make it sufficiently general? Different (custom) 
+# implementations of Marking class?
+#
+# HashMarking -- when creating Place define token keys that will be used
+# to search tokens in different transitions, these keys will be passed to
+# HashMarking object created in the Place. The HashMarking object maintains
+# a Hash of tokens for each of the keys defined when creating the Place.
+# Every token in the Place is put in each Hash udenr different keys. 
+# HashMarking exposes method named after the keys, that find token in
+# appropriate Hash using given key. This way we will have possibility
+# to quickly find tokens using require criterions. Adding a token to marking
+# requires adding to each Hash (an probably an Array that probably should 
+# also be maintaned). Deleting requires removal from every Hash (but using
+# the Hash'es key, thus quickly). It will be a little slower, but adding 
+# and deleting is much less often then finding tokens while trying to fire
+# a transition. Memory oveshead will not be significant, since the Hashes
+# will store only reference to a single copy of the object. The keys may
+# not uniquely identify objects, so the Hashes should store arrays of
+# objects matching given key. Iterators should be exposed for these arrays
+# and for the whole marking. The iterators should shuffle the arrays before
+# starting iteration and clone yielded objects -- anyway we assume that
+# shuffling will let one take first object returned by iterator, so cloning
+# will be rare.
+#
+# Thus we will be able to fire transition not in linear time, but in O(1) 
+# time at the expense of not significant memory overhead and insignificant 
+# complication of add/delete token operations for marking!
+#
+#
+#
+# (***) Note on efficiency (find this mark in code).
+#
+# calling
+# marking_hash[:process].each
+# without additional parameters results in need to do
+# @global_list.keys in HashMarking and to generate an
+# awfully large array. This is major cause that is blocking
+# subsequent speedup of simulation. Unfortunately this
+# array is required to enable shuffling of elements to
+# ensure fair treatment of TCPN conflicts.
+#
+# THE BELOW IS NOT TRUE -- tested it!
+# Similar situation will occcur in case of places that
+# store a lot of tokens under one key -- there we also use
+# Hash with tokens as keys and generate token list using
+# Hash#keys method. Adding and removing tokens is faster
+# in this case, especially for the large token lists.
+#
+#
+# Not timed places causes simulator to be faster! Reason is
+# that their tokens need not be considered when looking for
+# next time to which simulator clock should be advanced to
+# enable a transition. Thus if you have a place with a lot
+# of tokens, you can gain significant speed up by making
+# this place not timed (if you can).
+
+require 'benchmark'
+require 'deep_clone'
+require 'fast-tcpn'
+
+require 'ruby-prof'
+
+
+AppProcess = Struct.new(:name)
+CPU = Struct.new(:name, :process)
+
+
+profile = false
+timed = true
+
+tcpn = FastTCPN.model do
+
+  page "Benchmark model" do
+    if timed
+      puts "Timed places"
+      p1 = timed_place :process, { name: :name }
+      cpu = timed_place :cpu, { process: :process }
+      p2 = timed_place :done
+    else
+      puts "Not timed places"
+      p1 = place :process, { name: :name }
+      cpu = place :cpu, { process: :process }
+      p2 = place :done
+    end
+
+    transition 'run' do
+      input p1
+      input cpu
+      output p2 do |binding|
+        binding[:process].value.name.to_s + "_done"
+      end
+      output cpu do |binding|
+        binding[:cpu]
+      end
+
+      sentry do |marking_for, clock, result|
+        # (***) see note on efficiency above
+        marking_for[:process].each do |p|
+          marking_for[:cpu].each(:process, p.value.name) do |c|
+            result << { process: p, cpu: c }
+          end
+        end
+      end
+    end
+  end
+end
+
+
+p1 = tcpn.find_place(:process)
+p2 = tcpn.find_place(:done)
+cpu = tcpn.find_place(:cpu)
+
+10_000.times do |p| 
+  p1.add AppProcess.new(p)
+  10.times.map { |c| cpu.add CPU.new("CPU#{c}_#{p}", p) }
+end
+
+puts p1.marking.size
+puts p2.marking.size
+puts cpu.marking.size
+
+RubyProf.start if profile
+
+Benchmark.bm do |x|
+  x.report do
+    tcpn.sim
+#    {} while t.fire
+  end
+end
+
+
+if profile
+  result = RubyProf.stop
+  # Print a flat profile to text
+  printer = RubyProf::FlatPrinter.new(result)
+  #printer = RubyProf::FlatPrinterWithLineNumbers.new(result)
+  #printer = RubyProf::GraphHtmlPrinter.new(result)
+  printer.print(STDOUT)
+end
+
+puts p1.marking.size
+puts p2.marking.size
+puts cpu.marking.size

data/lib/fast-tcpn.rb

@@ -0,0 +1,25 @@
+require 'fast-tcpn/version'
+require 'fast-tcpn/place'
+require 'fast-tcpn/timed_place'
+require 'fast-tcpn/transition'
+require 'fast-tcpn/clone'
+require 'fast-tcpn/hash_marking'
+require 'fast-tcpn/timed_hash_marking'
+require 'fast-tcpn/token'
+require 'fast-tcpn/timed_token'
+require 'fast-tcpn/tcpn'
+require 'fast-tcpn/dsl'
+
+module FastTCPN
+  @@debug = false
+
+  # Check debugging of FastTCPN -- full backtraces from simulator
+  def self.debug
+    @@debug
+  end
+
+  # Turn on/off debugging of FastTCPN -- full backtraces from simulator
+  def self.debug=(d)
+    @@debug = d
+  end
+end

data/lib/fast-tcpn/clone.rb

@@ -0,0 +1,7 @@
+# This file should require one selected 
+# implementation of deep-cloning from clone/ dir.
+
+#require 'fast-tcpn/clone/using_deep_clone'
+#require 'fast-tcpn/clone/using_deep_dive'
+#require 'fast-tcpn/clone/using_marshal'
+require 'fast-tcpn/clone/using_code_from_stack'

data/lib/fast-tcpn/clone/using_code_from_stack.rb

@@ -0,0 +1,50 @@
+module FastTCPN
+  DontCloneClasses = [ Numeric, Symbol, TrueClass, FalseClass, NilClass ]
+  module Clone
+  # :nodoc:
+    def clone(token)
+      token.deep_clone
+    end
+  end
+end
+
+# http://stackoverflow.com/questions/8206523/how-to-create-a-deep-copy-of-an-object-in-ruby
+class Object
+  def deep_clone
+    return @deep_cloning_obj if @deep_cloning
+    return @deep_cloning_obj if frozen?
+    @deep_cloning_obj = clone
+    @deep_cloning_obj.instance_variables.each do |var|
+      val = @deep_cloning_obj.instance_variable_get(var)
+      begin
+        @deep_cloning = true
+        val = val.deep_clone
+      # silent rescue is never a good idea...
+      #rescue TypeError
+      #  next
+      ensure
+        # better not to litter original object with
+        # temporary instance variables
+        #@deep_cloning = false
+        remove_instance_variable :@deep_cloning
+      end
+      @deep_cloning_obj.instance_variable_set(var, val)
+    end
+    deep_cloning_obj = @deep_cloning_obj
+    @deep_cloning_obj = nil
+    # better not to litter original object with
+    # temporary instance variables
+    remove_instance_variable :@deep_cloning_obj
+    deep_cloning_obj
+  end
+end
+
+FastTCPN::DontCloneClasses.each do |klazz|
+  klazz.class_eval do
+    def deep_clone
+      self
+    end
+  end
+end
+
+

data/lib/fast-tcpn/clone/using_deep_clone.rb

@@ -0,0 +1,10 @@
+require 'deep_clone'
+
+module FastTCPN
+  module Clone
+  # :nodoc:
+    def clone(token)
+      DeepClone.clone token
+    end
+  end
+end

data/lib/fast-tcpn/clone/using_deep_dive.rb

@@ -0,0 +1,25 @@
+require 'deep_dive'
+
+[ Fixnum, Symbol, TrueClass, FalseClass ].each do |klazz|
+  klazz.class_eval do
+    def clone
+      self
+    end
+  end
+end
+
+class Object
+  include DeepDive
+  exclude do |sym, obj|
+    obj.kind_of? Symbol
+  end
+end
+
+module FastTCPN
+  module Clone
+  # :nodoc:
+    def clone(token)
+      token.dclone
+    end
+  end
+end

data/lib/fast-tcpn/clone/using_marshal.rb

@@ -0,0 +1,8 @@
+module FastTCPN
+  module Clone
+    # :nodoc:
+    def clone(token)
+      Marshal.load Marshal.dump token
+    end
+  end
+end

data/lib/fast-tcpn/dsl.rb

@@ -0,0 +1,177 @@
+require 'docile'
+
+module FastTCPN
+  # Allows to create new TCPN model by interpreting passed block of code.
+  # If you read this code from a file, pass it's name as a parameter, it
+  # will be used in exceptions.
+  def self.model(file = nil, &block)
+    tcpn = TCPN.new
+    load_model tcpn, file, &block
+    tcpn
+  end
+
+  # Read TCPN model from a +file+.
+  def self.read(file)
+    block = instance_eval "proc { #{File.read file} }", file
+    model file, &block
+  end
+
+  # For interal use. Use #read od #model.
+  def self.load_model(tcpn, file, &block)
+    Docile.dsl_eval(DSL::TCPNDSL.new(tcpn, file), &block)
+  end
+
+  # This module implements DSL to easily create TCPN models.
+  # The model consists of pages that have places and transitions.
+  # Places are repsesented by their names and the same place can
+  # appear on numerous pages. Every page can consist of subsequent
+  # pages. Pages can be loaded to the model from other files.
+  #
+  # DSL models can be loaded from external files using FastTCPN.read method
+  # or interpreted directly from core using FastTCPN.model method. Both methods
+  # return created model as TCPN object. You can then use TCPN class API to set
+  # markings, test markings, define callbacks and run simulation.
+  #
+  # Example:
+  #
+  # File: model/top.rb
+  #       page "top" do
+  #         sub_page "process.rb"
+  #       end
+  #
+  # File: model/process.rb
+  #       page "process" do
+  #          process = timed_place :process, { name: :name }
+  #          done = timed_place :done { name: :name }
+  #
+  #          transition "work" do
+  #             input process
+  #             output done do |binding, clock|
+  #               binding[:process].with_time clock + 100
+  #             end
+  #           end
+  #        end
+  #
+  # Calling TCPN.read 'model/top.rb' will load whole model and return as TCPN object.
+  module DSL
+
+    # Represents and encapsulates all errors that will occur while
+    # running DSL.
+    class DSLError < RuntimeError
+      attr_reader :cause, :page, :files
+
+      def initialize(cause, page, file = nil)
+        super cause
+        @cause, @page = cause, page
+        if @cause.respond_to? :full_backtrace
+          set_backtrace @cause.full_backtrace
+        else
+          set_backtrace @cause.backtrace
+        end
+        @files = []
+        @files += @cause.files if @cause.respond_to? :files
+        @files << file
+      end
+
+      def inspect
+        "<#{self.class} #{@cause.inspect} on TCPN page: `#{@page}`>"
+      end
+
+      def message
+        "#{@cause.message} on TCPN page: `#{@page}`"
+      end
+
+      alias full_backtrace backtrace 
+
+      def backtrace
+        return full_backtrace if @files.empty?
+        full_backtrace.select do |b|
+          not @files.select { |f| b =~ /#{f}/ }.empty?
+        end
+      end
+    end
+
+    class TCPNDSL
+      def initialize(tcpn, file)
+        @tcpn = tcpn
+        @file = file
+      end
+
+      # Define a page of TCPN model
+      def page(name, &block)
+        Docile.dsl_eval(PageDSL.new(@tcpn, self, @file), &block)
+      rescue StandardError => e
+        raise DSLError.new e, name, @file
+      rescue SyntaxError => e
+        raise DSLError.new e, name, @file
+      end
+    end
+
+    class PageDSL
+      def initialize(tcpn, dsl, file)
+        @tcpn = tcpn
+        @dsl = dsl
+        @file = file
+      end
+
+      # Create and return a new place (not timed). If a place with this
+      # name exists somewhere in the model (e.g. on other pages), and object
+      # representing exisiting place will be returned. Keys of both keys will
+      # be merged.
+      def place(name, keys = {})
+        @tcpn.place name, keys
+      end
+
+      # Create and return a new timed place. 
+      def timed_place(name, keys = {})
+        @tcpn.timed_place name, keys
+      end
+
+      # Create and return new transition for the TCPN. Block
+      # defines transitions inputs, outputs and sentry.
+      def transition(name, &block)
+        transition = @tcpn.transition name
+        Docile.dsl_eval(TransitionDSL.new(transition), &block)
+        transition
+      end
+
+      # define new TCPN (sub) page on this page.
+      def page(name, &block)
+        @dsl.page name, &block
+      end
+
+      # load TCPN sub page from a file. File location is relative to
+      # the location of currently interpreted file (if known)
+      def sub_page(file)
+        file = File.expand_path(file, File.dirname(@file)) unless @file.nil?
+        block = instance_eval "proc { #{File.read file} }", file
+        FastTCPN.load_model @tcpn, file, &block
+      end
+    end
+
+    class TransitionDSL
+      def initialize(transition)
+        @transition = transition
+      end
+
+      # Defines input place for this transition. +place+ must an
+      # object returned by +place+ ot +timed_place+ statement.
+      def input(place)
+        @transition.input place
+      end
+
+      # Defines output place for this transition. +place+ must an
+      # object returned by +place+ ot +timed_place+ statement.
+      #
+      def output(place, &block)
+        @transition.output place, &block
+      end
+
+      # Defines sentry for this transition.
+      def sentry(&block)
+        @transition.sentry &block
+      end
+    end
+
+  end
+end