art-decomp 0.0.0

data/Rakefile

@@ -0,0 +1,46 @@
+# encoding: UTF-8
+
+require 'spec/rake/spectask'
+
+Spec::Rake::SpecTask.new :cov do |t|
+  t.rcov      = true
+  t.rcov_opts = ['--exclude', 'spec']
+  t.spec_opts = ['--options', 'spec/spec.opts']
+end
+
+Spec::Rake::SpecTask.new :spec do |t|
+  t.spec_opts = ['--options', 'spec/spec.opts']
+end
+
+namespace :spec do
+  FileList['spec/**/*_spec.rb'].each do |file|
+    spec = file.split('/').last[0...-8]
+    desc "Run the #{spec} spec"
+    Spec::Rake::SpecTask.new spec do |t|
+      t.spec_files = [file]
+      t.spec_opts  = ['--options', 'spec/spec.opts']
+    end
+  end
+end
+
+require 'jeweler'
+
+Jeweler::Tasks.new do |gem|
+  gem.authors  = ['Piotr Szotkowski']
+  gem.email    = 'p.szotkowski@tele.pw.edu.pl'
+  gem.homepage = 'http://github.com/chastell/art-decomp'
+  gem.name     = 'art-decomp'
+  gem.summary  = 'art décomp: an FSM → FPGA decomposer'
+
+  gem.files.exclude 'kiss/**/*'
+
+  gem.add_dependency 'teejayvanslyke-gazer'
+  gem.add_dependency 'trollop'
+
+  gem.add_development_dependency 'diff-lcs'
+  gem.add_development_dependency 'jeweler'
+  gem.add_development_dependency 'rcov'
+  gem.add_development_dependency 'rspec'
+end
+
+Jeweler::GemcutterTasks.new

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/bin/ad-compare

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require_relative '../lib/art-decomp'
+
+input_limit = ARGV.first.to_i.zero? ? 0 : ARGV.shift.to_i
+
+ARGV.each do |fsm_file|
+  fsm = ArtDecomp::FSM.from_kiss fsm_file
+  seps = fsm.beta_f.seps
+  input_seps = (0...fsm.input_count).map { |i| fsm.beta_x(Set[i]).seps & seps }
+
+  puts
+  puts fsm_file
+  puts "X seps: #{input_seps.map(&:size).inspect}"
+
+  (0...input_seps.size).pairs.to_a.each do |a, b|
+    puts "#{a} ⊂ #{b}" if input_seps[a].proper_subset?   input_seps[b]
+    puts "#{a} = #{b}" if input_seps[a] ==               input_seps[b]
+    puts "#{a} ⊃ #{b}" if input_seps[a].proper_superset? input_seps[b]
+  end
+end

data/bin/ad-console

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'      if RUBY_VERSION < '1.9'
+require 'backports/1.9' if RUBY_VERSION < '1.9'
+
+require 'irb'
+
+require_relative '../lib/art-decomp'
+include ArtDecomp
+
+IRB.start

data/bin/ad-inputs

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require 'rubygems'      if RUBY_VERSION < '1.9'
+require 'backports/1.9' if RUBY_VERSION < '1.9'
+
+require_relative '../lib/art-decomp'
+
+input_limit = ARGV.first.to_i.zero? ? 0 : ARGV.shift.to_i
+
+ARGV.each do |fsm_file|
+  fsm = ArtDecomp::FSM.from_kiss fsm_file
+  next if fsm.input_count < input_limit
+  seps = fsm.beta_f.seps
+  rel_q = (fsm.beta_q.seps & seps).size
+  puts
+  puts fsm_file
+  puts "inputs: #{fsm.input_count}"
+  puts "βf sep: #{seps.size}"
+  puts "βq sep: #{rel_q}"
+  puts "βq.pin: #{fsm.beta_q.pins}"
+  puts "perpin: #{rel_q.to_f / fsm.beta_q.pins}"
+  puts "X seps: #{(0...fsm.input_count).map { |i| (fsm.beta_x(Set[i]).seps & seps).size }.sort.reverse.inspect}"
+end

data/bin/ad-validate

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'      if RUBY_VERSION < '1.9'
+require 'backports/1.9' if RUBY_VERSION < '1.9'
+
+require_relative '../lib/art-decomp'
+
+$stdout.sync = true
+p Marshal.load(File.open ARGV.first).all? { |d| print '.'; d.valid? }

data/bin/art-decomp

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'      if RUBY_VERSION < '1.9'
+require 'backports/1.9' if RUBY_VERSION < '1.9'
+
+require_relative '../lib/art-decomp'
+
+ArtDecomp::Executable.new.run

data/lib/art-decomp/arch.rb

@@ -0,0 +1,32 @@
+module ArtDecomp class Arch
+
+  attr_reader :pins, :pons
+
+  def self.[] pins, pons
+    new pins, pons
+  end
+
+  def initialize pins, pons
+    @pins, @pons = pins, pons
+  end
+
+  def == other
+    [@pins, @pons] == [other.pins, other.pons]
+  end
+
+  def cells archs
+    pons = archs.select { |a| a.pins >= @pins }.map(&:pons).max
+    (@pons % pons).zero? ? @pons / pons : @pons / pons + 1 rescue nil
+  end
+
+  alias eql? ==
+
+  def hash
+    @pins.hash ^ @pons.hash
+  end
+
+  def to_s
+    "#{pins}/#{pons}"
+  end
+
+end end

data/lib/art-decomp/b.rb

@@ -0,0 +1,7 @@
+module ArtDecomp class B
+
+  def self.[] *ints
+    ints.inject(0) { |int, elem| int | 1 << elem }
+  end
+
+end end

data/lib/art-decomp/bipainter.rb

@@ -0,0 +1,142 @@
+module ArtDecomp class Bipainter
+
+  def initialize beta_q, beta_v, seps
+    raise 'non-disjoint beta_v' if beta_v.ints.pairs.any? { |a, b| a & b != 0 }
+    @beta_v = beta_v
+    @qv_colours = {}
+    @g_colours  = {}
+    @qv_forbidden = Hash.new { |h, k| h[k] = Set[] }
+    @g_forbidden  = Hash.new { |h, k| h[k] = Set[] }
+    @qv_graph = Graph.new beta_q,          seps - beta_v.seps
+    @g_graph  = Graph.new beta_q * beta_v, seps
+  end
+
+  def blankets
+    colour_next_vertex! until painted?
+    qv_blocks = Hash.new 0
+    g_blocks  = Hash.new 0
+    @qv_colours.each { |vertex, colour| qv_blocks[colour] |= vertex }
+    @g_colours.each  { |vertex, colour| g_blocks[colour]  |= vertex }
+    [Blanket.new(qv_blocks.values), Blanket.new(g_blocks.values)]
+  end
+
+  private
+
+  def backup!
+    @g_forbidden.default  = nil
+    @qv_forbidden.default = nil
+    @backup = {
+      :g_colours    => Marshal.dump(@g_colours),
+      :g_forbidden  => Marshal.dump(@g_forbidden),
+      :qv_colours   => Marshal.dump(@qv_colours),
+      :qv_forbidden => Marshal.dump(@qv_forbidden),
+    }
+    @g_forbidden.default_proc  = proc { |h, k| h[k] = Set[] }
+    @qv_forbidden.default_proc = proc { |h, k| h[k] = Set[] }
+  end
+
+  def restore!
+    @g_colours    = Marshal.load @backup[:g_colours]
+    @g_forbidden  = Marshal.load @backup[:g_forbidden]
+    @qv_colours   = Marshal.load @backup[:qv_colours]
+    @qv_forbidden = Marshal.load @backup[:qv_forbidden]
+    @g_forbidden.default_proc  = proc { |h, k| h[k] = Set[] }
+    @qv_forbidden.default_proc = proc { |h, k| h[k] = Set[] }
+  end
+
+  def colour_g_vertex! g_vertex
+    begin
+      backup!
+      colour = :a
+      colour = colour.next while @g_forbidden[g_vertex].include? colour
+      colour_g! g_vertex, colour
+    rescue PaintingError
+      restore!
+      forbid_g! g_vertex, colour
+      retry
+    end
+  end
+
+  def colour_next_vertex!
+    # FIXME: consider colouring G graph’s vertex first
+    # FIXME: consider other vertex selection algorithms
+    qv_vertex = (@qv_graph.vertices - @qv_colours.keys).sort_by { |v| [-@qv_forbidden[v].size, -@qv_graph.degree(v)] }.first
+    colour_qv_vertex! qv_vertex if qv_vertex
+    g_vertex = (@g_graph.vertices - @g_colours.keys).sort_by { |v| [-@g_forbidden[v].size, -@g_graph.degree(v)] }.first
+    colour_g_vertex! g_vertex if g_vertex
+  end
+
+  def colour_qv_vertex! qv_vertex
+    begin
+      backup!
+      colour = :a
+      colour = colour.next while @qv_forbidden[qv_vertex].include? colour
+      colour_qv! qv_vertex, colour
+    rescue PaintingError
+      restore!
+      forbid_qv! qv_vertex, colour
+      retry
+    end
+  end
+
+  def forbid_g! g_vertex, colour
+    return if @g_forbidden[g_vertex].include? colour
+    raise PaintingError if colour == @g_colours[g_vertex]
+    @g_forbidden[g_vertex] << colour
+    siblings_of(g_vertex).each { |sibling| forbid_g! sibling, colour }
+  end
+
+  def forbid_qv! qv_vertex, colour
+    return if @qv_forbidden[qv_vertex].include? colour
+    raise PaintingError if colour == @qv_colours[qv_vertex]
+    @qv_forbidden[qv_vertex] << colour
+  end
+
+  def colour_g! g_vertex, colour
+    return if @g_colours[g_vertex] == colour
+    raise PaintingError if @g_colours[g_vertex] and @g_colours[g_vertex] != colour
+    raise PaintingError if @g_forbidden[g_vertex].include? colour
+    @g_colours[g_vertex] = colour
+    @g_graph.adjacent(g_vertex).each { |adjacent| forbid_g! adjacent, colour }
+    siblings_of(g_vertex).each { |sibling| colour_g! sibling, colour }
+  end
+
+  def colour_qv! qv_vertex, colour
+    return if @qv_colours[qv_vertex] == colour
+    raise PaintingError if @qv_colours[qv_vertex] and @qv_colours[qv_vertex] != colour
+    raise PaintingError if @qv_forbidden[qv_vertex].include? colour
+    @qv_colours[qv_vertex] = colour
+    @qv_graph.adjacent(qv_vertex).each { |adjacent| forbid_qv! adjacent, colour }
+    if @qv_colours.any? { |q, col| q != qv_vertex and col == colour }
+      @g_graph.vertices.select { |g| g & qv_vertex == g }.each do |g_vertex|
+        v_parent = @beta_v.ints.find { |v| v & g_vertex == g_vertex }
+        @g_graph.adjacent(g_vertex).select { |g| v_parent & g == g and qv_vertex & g != g }.each do |neighbour|
+          @qv_graph.vertices.select { |q| q & neighbour == neighbour }.each do |q_parent|
+            forbid_qv! q_parent, colour
+          end
+        end
+        siblings_of(g_vertex).each { |sibling| sync_colours g_vertex, sibling }
+      end
+    end
+  end
+
+  def siblings_of g_vertex
+    v_parent = @beta_v.ints.find { |v| v & g_vertex == g_vertex }
+    colours  = @qv_colours.select { |q, col| g_vertex & q == g_vertex }.values
+    similar  = @qv_colours.select { |q, col| colours.include? col }.keys
+    (similar.map { |q| q & v_parent }.to_set & @g_graph.vertices).delete g_vertex
+  end
+
+  def sync_colours v1, v2
+    (@g_forbidden[v1] - @g_forbidden[v2]).each { |col| forbid_g! v2, col }
+    (@g_forbidden[v2] - @g_forbidden[v1]).each { |col| forbid_g! v1, col }
+    if    @g_colours[v1] then colour_g! v2, @g_colours[v1]
+    elsif @g_colours[v2] then colour_g! v1, @g_colours[v2]
+    end
+  end
+
+  def painted?
+    @qv_graph.vertices == @qv_colours.keys.to_set and @g_graph.vertices == @g_colours.keys.to_set
+  end
+
+end end

data/lib/art-decomp/blanket.rb

@@ -0,0 +1,82 @@
+module ArtDecomp class Blanket
+
+  attr_reader :ints
+
+  def self.[] *ints
+    new ints
+  end
+
+  def self.from_array array
+    ints = Hash.new 0
+    array.each_with_index do |enc, i|
+      ints[enc] |= 1 << i
+    end
+    ints.each_key do |key|
+      ints[key] |= ints[DontCare]
+    end unless ints[DontCare].zero?
+    ints.delete DontCare unless ints.size <= 1
+    new ints.values
+  end
+
+  def initialize ints
+    @ints = ints.to_set.delete(0).freeze
+  end
+
+  def * other
+    ints = []
+    @ints.each do |this_int|
+      other.ints.each do |other_int|
+        ints << (this_int & other_int)
+      end
+    end
+    Blanket.new ints
+  end
+
+  def == other
+    @ints == other.ints
+  end
+
+  def encoding bits
+    encs = encodings bits
+    encs.size == 1 ? encs.first : raise(AmbiguousEncodingQuery, "ambiguous encoding query: block #{bits.bits.join ','}")
+  end
+
+  def encodings bits
+    sorted = @ints.sort
+    width = sorted.size.log2_ceil
+    encs = @ints.select { |int| int & bits == bits }.map { |int| sorted.index(int) }.map { |i| i.to_s(2).rjust width, '0' }
+    encs.size == 0 or encs.size == @ints.size ? [DontCare.to_s * width] : encs
+  end
+
+  alias eql? ==
+
+  def hash
+    @ints.hash
+  end
+
+  def inspect
+    blocks = @ints.map(&:bits).sort.map { |bl| "B[#{bl.join ','}]" }
+    "Blanket[#{blocks.join ', '}]"
+  end
+
+  def pins
+    @ints.size.log2_ceil
+  end
+
+  def seps
+    # FIXME: consider an algorithm with lesser complexity
+    seps = Set[]
+    singles = 0
+    @ints.pairs.each { |int1, int2| singles |= int1 ^ int2 }
+    singles.bits.pairs.each do |elem1, elem2|
+      sep = Sep[elem1, elem2]
+      seps << sep unless @ints.any? { |int| int & sep == sep }
+    end
+    seps
+  end
+
+  def size
+    @ints.size
+  end
+
+end end

data/lib/art-decomp/decomposer.rb

@@ -0,0 +1,75 @@
+module ArtDecomp class Decomposer
+
+  def initialize params
+    @archs   = params[:archs]
+    @uv_gens = params[:uv_gens].map { |gen| gen.new params[:fsm], params[:archs] }
+    @qu_gens = params[:qu_gens].map &:new
+    @qv_gens = params[:qv_gens].map &:new
+  end
+
+  def decompositions opts = {}
+    @seen = Set[]
+    Enumerator.new do |yielder|
+      @uv_gens.each do |uv_gen|
+        uv_gen.uv_pairs.each do |fsm, u, v|
+          unless @seen.include? [fsm, u, v]
+            @qu_gens.each do |qu_gen|
+              qu_gen.blankets(fsm, u, v).each do |qu|
+                unless @seen.include? [fsm, u, v, qu]
+                  @qv_gens.each do |qv_gen|
+                    qv_gen.blankets(fsm, u, v, qu).each do |qv, g|
+                      unless @seen.include? [fsm, u, v, qu, qv, g]
+                        dec = Decomposition.new fsm, u, v, qu, qv, g
+                        if dec.sensible? @archs
+                          if opts[:non_disjoint]
+                            non_disjoint(fsm, u, v, qu, qv, g, opts).each do |ndj|
+                              yielder.yield ndj
+                            end
+                          end
+                          yielder.yield dec
+                        end
+                        @seen << [fsm, u, v, qu, qv, g] unless opts[:keep_seen]
+                      end
+                    end
+                  end
+                  @seen << [fsm, u, v, qu] unless opts[:keep_seen]
+                end
+              end
+            end
+            @seen << [fsm, u, v] unless opts[:keep_seen]
+          end
+        end
+      end
+    end
+  end
+
+  private
+
+  def non_disjoint fsm, u_dj, v, qu, qv_dj, g_dj, opts
+    Enumerator.new do |yielder|
+      (v - u_dj).each do |v_input|
+        u = u_dj + [v_input]
+        unless @seen.include? [fsm, u, v, qu]
+          @qv_gens.each do |qv_gen|
+            qv_gen.blankets(fsm, u, v, qu).each do |qv, g|
+              unless @seen.include? [fsm, u, v, qu, qv, g]
+                dec = Decomposition.new fsm, u, v, qu, qv, g
+                if dec.sensible? @archs and g.pins < g_dj.pins
+                  if opts[:deep_ndj]
+                    non_disjoint(fsm, u, v, qu, qv, g, opts).each do |ndj|
+                      yielder.yield ndj
+                    end
+                  end
+                  yielder.yield dec
+                end
+                @seen << [fsm, u, v, qu, qv, g] unless opts[:keep_seen]
+              end
+            end
+          end
+          @seen << [fsm, u, v, qu] unless opts[:keep_seen]
+        end
+      end
+    end
+  end
+
+end end

data/lib/art-decomp/decomposition.rb

@@ -0,0 +1,91 @@
+module ArtDecomp class Decomposition
+
+  def initialize fsm, u, v, qu, qv, g, opts = {}
+    @fsm, @u, @v, @qu, @qv, @g = fsm, u, v, qu, qv, g
+  end
+
+  def == other
+    [@fsm, @u, @v, @qu, @qv, @g] == [other.fsm, other.u, other.v, other.qu, other.qv, other.g]
+  end
+
+  def decomposable?
+    @qu.size > 2
+  end
+
+  def disjoint?
+    (@u & @v).empty?
+  end
+
+  alias eql? ==
+
+  def f_kiss
+    @fsm.to_kiss
+  end
+
+  def final? archs
+    pins = archs.map(&:pins).max
+    @v.size + @qv.pins <= pins and @u.size + @qu.pins + @g.pins <= pins
+  end
+
+  def g_cells archs
+    Arch[@v.size + @qv.pins, @g.pins].cells archs
+  end
+
+  def g_kiss
+    lines = (@fsm.beta_x(@v) * @qv).ints.map do |row|
+      v  = @fsm.x_encoding @v, row
+      qv = @qv.encoding row
+      g  = @g.encoding row
+      "#{v}#{qv} #{g}"
+    end
+    KISS.new(lines).formatted
+  end
+
+  def h_cells archs
+    Arch[@u.size + @qu.pins + @g.pins, @fsm.output_count + @qu.pins + @qv.pins].cells archs
+  end
+
+  def h_kiss
+    lines = (@fsm.beta_x(@u) * @g * @qu).ints.map do |row|
+      u   = @fsm.x_encoding @u, row
+      qu  = @qu.encoding row
+      qup = @qu.encoding @fsm.state_rows_of_next_state_of(row)
+      qvp = @qv.encoding @fsm.state_rows_of_next_state_of(row)
+      y   = @fsm.y_encoding row
+      qu  = '*' if qu  =~ /^-+$/
+      qup = '*' if qup =~ /^-+$/
+      # FIXME: use only the encoding(s) really mapped from this row
+      @g.encodings(row).map do |g|
+        "#{u}#{g} #{qu} #{qup} #{qvp}#{y}"
+      end
+    end.flatten
+    KISS.new(lines).formatted
+  end
+
+  def hash
+    @fsm.hash ^ @u.hash ^ @v.hash ^ @qu.hash ^ @qv.hash ^ @g.hash
+  end
+
+  def q_kiss
+    lines = @fsm.beta_q.ints.map do |row|
+      qu = @qu.encoding row
+      qv = @qv.encoding row
+      q  = @fsm.q_encoding row
+      "#{qu} #{qv}  #{q}"
+    end
+    KISS.new(lines).formatted
+  end
+
+  def sensible? archs
+    @v.size + @qv.pins <= archs.map(&:pins).max and @u.size + @qu.pins + @g.pins < @fsm.input_count + @fsm.beta_q.pins
+  end
+
+  def valid?
+    @g.seps.subset?((@fsm.beta_x(@v) * @qv).seps) and @fsm.beta_f.seps.subset?((@fsm.beta_x(@u) * @qu * @g).seps)
+  end
+
+  protected
+
+  attr_reader :fsm, :u, :v, :qu, :qv, :g
+
+end end

data/lib/art-decomp/exceptions.rb

@@ -0,0 +1,9 @@
+module ArtDecomp
+
+  class AmbiguousEncodingQuery < RuntimeError
+  end
+
+  class PaintingError < RuntimeError
+  end
+
+end

data/lib/art-decomp/executable.rb

@@ -0,0 +1,94 @@
+require 'trollop'
+
+module ArtDecomp class Executable
+
+  attr_reader :archs, :best, :iters, :dir
+
+  def initialize args = ARGV
+    opts = Trollop.options(args) do
+      opt :archs,        'Target architecture(s)',               :type => :strings
+      opt :outdir,       'Output directory',                     :type => :string
+      opt :iters,        'Number of iterations, 0 for infinite', :default => 1
+      opt :uv,           'UV generator(s)',                      :default => ['Relevance']
+      opt :qu,           'Qu generator(s)',                      :default => ['EdgeLabels']
+      opt :qv,           'Qv generator(s)',                      :default => ['GraphColouring']
+      opt :non_disjoint, 'Compute non-disjoint decompositions',  :default => false
+      opt :deep_ndj,     'Compute deep non-dj decompositions',   :default => false
+      opt :log,          'Logging target',                       :type => :string
+      opt :debug,        'Log debug-level activities',           :default => false
+    end
+
+    opts[:uv] = UVGenerator.constants.map(&:to_s).sort if opts[:uv] == ['all']
+    opts[:qu] = QuGenerator.constants.map(&:to_s).sort if opts[:qu] == ['all']
+    opts[:qv] = QvGenerator.constants.map(&:to_s).sort if opts[:qv] == ['all']
+
+    Trollop.die          'no FSM given'                      if     args.empty?
+    Trollop.die          'FSM does not exist'                unless File.exists? args.first
+    Trollop.die          'no architecture given'             unless opts[:archs_given]
+    Trollop.die          'no output directory given'         unless opts[:outdir_given]
+    Trollop.die :archs,  'not in the form of inputs/outputs' unless opts[:archs].all? { |s| s =~ /^\d+\/\d+$/ }
+    Trollop.die :outdir, 'output directory exists'           if     File.exists? opts[:outdir]
+    Trollop.die :uv,     'no such UV generator'              unless (opts[:uv] - UVGenerator.constants.map(&:to_s)).empty?
+    Trollop.die :qu,     'no such Qu generator'              unless (opts[:qu] - QuGenerator.constants.map(&:to_s)).empty?
+    Trollop.die :qv,     'no such Qv generator'              unless (opts[:qv] - QvGenerator.constants.map(&:to_s)).empty?
+
+    Dir.mkdir opts[:outdir] rescue Trollop.die :outdir, 'output directory cannot be created'
+
+    @dir          = opts[:outdir]
+    @fsm          = FSM.from_kiss args.first
+    @archs        = opts[:archs].map { |s| Arch[*s.split('/').map(&:to_i)] }.to_set
+    @iters        = opts[:iters]
+    @non_disjoint = opts[:non_disjoint]
+    @deep_ndj     = opts[:deep_ndj]
+
+    @uv_gens = opts[:uv].map { |gen| eval "UVGenerator::#{gen}" }
+    @qu_gens = opts[:qu].map { |gen| eval "QuGenerator::#{gen}" }
+    @qv_gens = opts[:qv].map { |gen| eval "QvGenerator::#{gen}" }
+
+    if opts[:log_given]
+      require_relative 'logging'
+      Logging.log = opts[:log] == '-' ? $stdout : opts[:log]
+      Logging.level = Logger::DEBUG if opts[:debug]
+    end
+  end
+
+  def gens
+    [@uv_gens, @qu_gens, @qv_gens].map do |gens|
+      gens.map { |gen| gen.to_s.split('::').last }.join '+'
+    end.join ', '
+  end
+
+  def run dump_decs = true
+    @best = @fsm.fsm_cells @archs
+    dumps = Hash.new { |h, k| h[k] = [] }
+    decompositions(@fsm, @iters, @dir, 0).each do |dec, dir, i|
+      dumps[dir] << dec
+      File.dump_object dec, "#{dir}/#{i}.dec" if dump_decs
+    end unless @fsm.implementable_in? @archs
+    dumps.each do |dir, decs|
+      File.dump_object decs, "#{dir}/decompositions"
+    end
+  end
+
+  private
+
+  def decompositions fsm, iters, dir, cells
+    decomposer = Decomposer.new :fsm => fsm, :archs => @archs, :uv_gens => @uv_gens, :qu_gens => @qu_gens, :qv_gens => @qv_gens
+    Enumerator.new do |yielder|
+      decomposer.decompositions(:non_disjoint => @non_disjoint, :deep_ndj => @deep_ndj).with_index do |dec, i|
+        yielder.yield dec, dir, i
+        if dec.final? @archs
+          this = cells + dec.g_cells(@archs) + dec.h_cells(@archs)
+          @best = this if @best.nil? or this < @best
+        elsif iters != 1 and dec.decomposable? and (@best.nil? or cells < @best)
+          in_dir = "#{dir}/#{i}"
+          Dir.mkdir in_dir
+          decompositions(FSM.from_kiss(dec.h_kiss), iters - 1, in_dir, cells + dec.g_cells(@archs)).each do |in_dec, in_dir, in_i|
+            yielder.yield in_dec, in_dir, in_i
+          end
+        end
+      end
+    end
+  end
+
+end end