art-decomp 0.3.0 → 0.4.0

data/Rakefile

@@ -34,7 +34,7 @@ Jeweler::Tasks.new do |gem|
 
   gem.files.exclude 'kiss/**/*'
 
-  gem.add_dependency 'teejayvanslyke-gazer'
+  gem.add_dependency 'rcapture'
   gem.add_dependency 'trollop'
 
   gem.add_development_dependency 'diff-lcs'

data/VERSION

@@ -1 +1 @@
-0.3.0
+0.4.0

data/bin/ad-kiss2vhdl

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require_relative '../lib/art-decomp'
+
+file = ARGV.first
+name = File.basename(file).gsub /[^a-z0-9]/, '_'
+puts ArtDecomp::FSM.from_kiss(file).to_vhdl name

data/lib/art-decomp.rb

@@ -37,6 +37,7 @@ end
 
 
 require 'set'
+require 'yaml'
 
 require_relative 'core/enumerable'
 require_relative 'core/file'
@@ -65,3 +66,4 @@ require_relative 'art-decomp/uv_relevance_generator'
 require_relative 'art-decomp/uv_generator/braindead'
 require_relative 'art-decomp/uv_generator/general_relevance'
 require_relative 'art-decomp/uv_generator/unique_relevance'
+require_relative 'art-decomp/vhdl'

data/lib/art-decomp/bipainter.rb

@@ -1,7 +1,7 @@
 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 }
+    raise 'non-disjoint beta_v' unless beta_v.ints.pairs.all? { |a, b| (a & b).zero? }
     @beta_v = beta_v
     @qv_colours = {}
     @g_colours  = {}
@@ -35,13 +35,13 @@ module ArtDecomp class Bipainter
     @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[] }
+  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_g_vertex! g_vertex
@@ -66,6 +66,25 @@ module ArtDecomp class Bipainter
     colour_g_vertex! g_vertex if g_vertex
   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 colour_qv_vertex! qv_vertex
     begin
       backup!
@@ -92,32 +111,17 @@ module ArtDecomp class Bipainter
     @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 }
+  def painted?
+    @qv_graph.vertices == @qv_colours.keys.to_set and @g_graph.vertices == @g_colours.keys.to_set
   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
+  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 siblings_of g_vertex
@@ -135,8 +139,4 @@ module ArtDecomp class Bipainter
     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/executable.rb

@@ -43,9 +43,9 @@ module ArtDecomp class Executable
     @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}" }
+    @uv_gens = opts[:uv].map { |gen| UVGenerator.const_get gen }
+    @qu_gens = opts[:qu].map { |gen| QuGenerator.const_get gen }
+    @qv_gens = opts[:qv].map { |gen| QvGenerator.const_get gen }
 
     if opts[:log_given]
       require_relative 'logging'

data/lib/art-decomp/fsm.rb

@@ -1,14 +1,27 @@
 module ArtDecomp class FSM
 
+  attr_reader :codes
+
   def self.from_kiss kiss
     kiss = File.read kiss unless kiss.index "\n"
     inputs, outputs, state, next_state = [], [], [], []
+    codes = Hash[kiss.lines.grep(/^\.code [^*]/).map(&:split).map { |_, state, code| [state.to_sym, code.to_sym] }]
+    codes = Hash[kiss.lines.grep(/^# States\./).map(&:split).map { |_, state, code| [state[7..-1].to_sym, code.to_sym] }] if codes.empty?
     kiss.lines do |line|
       case line
       when /^\s*[01-]+\s+\S+\s+\S+\s+[01-]+\s*$/ then ins, st, nxt, outs = *line.split
       when /^\s*[01-]+\s+[01-]+\s*$/             then st, nxt, ins, outs = DontCare, DontCare, *line.split
+      when /^\.end_kiss$/                        then break
       else next
       end
+      next if [DontCare, '*'].include? nxt and outs =~ /^-*$/
+      if line =~ /^[01-]+\s+[01-]+$/ and not codes.empty?
+        size = codes.values.first.size
+        st   = ins[-size..-1] == '-' * size ? DontCare : codes.invert[ins[-size..-1].to_sym]
+        nxt  = outs[0...size] == '-' * size ? DontCare : codes.invert[outs[0...size].to_sym]
+        ins  = ins[0...-size]
+        outs = outs[size..-1]
+      end
       inputs     << ins.split(//).map(&:to_sym)
       outputs    << outs.split(//).map(&:to_sym)
       state      << (st  == '*' ? DontCare : st.to_sym)
@@ -22,11 +35,11 @@ module ArtDecomp class FSM
       inputs     << inputs[i]
       outputs    << outputs[i]
     end if state.index DontCare
-    new inputs.transpose, outputs.transpose, state, next_state
+    new inputs.transpose, outputs.transpose, state, next_state, codes
   end
 
-  def initialize inputs, outputs, state, next_state
-    @inputs, @outputs, @state, @next_state = inputs.freeze, outputs.freeze, state.freeze, next_state.freeze
+  def initialize inputs, outputs, state, next_state, codes = {}
+    @inputs, @outputs, @state, @next_state, @codes = inputs.freeze, outputs.freeze, state.freeze, next_state.freeze, codes.freeze
   end
 
   def == other
@@ -99,6 +112,14 @@ module ArtDecomp class FSM
     "#{@inputs.size}/#{@outputs.size}+#{(@state.uniq - [DontCare]).size}s"
   end
 
+  def structure
+    structure = Hash.new { |state, input| state[input] = {} }
+    @state.each_index do |row|
+      structure[@state[row]][@inputs.transpose[row].join] = {:next_state => @next_state[row], :output => @outputs.transpose[row].join}
+    end
+    structure
+  end
+
   def to_kiss
     st   = @state.map      { |e| e == DontCare ? '*' : e }
     nxt  = @next_state.map { |e| e == DontCare ? '*' : e }
@@ -108,6 +129,10 @@ module ArtDecomp class FSM
     KISS.new(cols.transpose.map(&:join)).formatted
   end
 
+  def to_vhdl name
+    VHDL.new(self).vhdl name
+  end
+
   def truth_table?
     @state.all? { |s| s == DontCare } and @next_state.all? { |ns| ns == DontCare }
   end

data/lib/art-decomp/graph.rb

@@ -3,23 +3,23 @@ module ArtDecomp class Graph
   def initialize blanket, seps
     vertices = blanket.ints.dup
     vertices.delete_if { |this| vertices.any? { |other| other != this and other & this == this } }
-    @edges = Hash[vertices.map { |vertex| [vertex, Set[]] }]
+    @neighbours = Hash[vertices.map { |vertex| [vertex, Set[]] }]
     relevant = Hash[vertices.map { |v| [v, seps.select { |s| v&s != 0 and v&s != s }.to_set] }]
     vertices.pairs.each do |a, b|
       if (relevant[a] & relevant[b]).any? { |s| a&s != b&s }
-        @edges[a] << b
-        @edges[b] << a
+        @neighbours[a] << b
+        @neighbours[b] << a
       end
     end
   end
 
   def adjacent *vertices
-    vertices.map { |vertex| @edges[vertex] }.inject(:|) - vertices
+    vertices.map { |vertex| @neighbours[vertex] }.inject(:|) - vertices
   end
 
   def blanket_from_colouring
     colours = {}
-    @edges.keys.sort_by { |vert| [-degree(vert), vert] }.each do |vertex|
+    @neighbours.keys.sort_by { |vert| [-degree(vert), vert] }.each do |vertex|
       forbidden = adjacent(vertex).map { |vert| colours[vert] }.to_set
       # FIXME: consider selecting colours on the least-popular-first basis
       colour = :a
@@ -32,21 +32,21 @@ module ArtDecomp class Graph
   end
 
   def complete?
-    @edges.values.map(&:size).inject(:+) == @edges.size * (@edges.size - 1)
+    @neighbours.values.map(&:size).inject(:+) == @neighbours.size * (@neighbours.size - 1)
   end
 
   def degree vertex
-    @edges[vertex].size
+    @neighbours[vertex].size
   end
 
   def edges
-    @edges.map { |v, adjacents| adjacents.map { |adj| Set[v, adj] } }.flatten.to_set
+    @neighbours.map { |v, adjacents| adjacents.map { |adj| Set[v, adj] } }.flatten.to_set
   end
 
   def merge_by_edge_labels!
-    return self if @edges.size == 1
-    pins = @edges.size.log2_ceil
-    until @edges.size.log2_ceil < pins
+    return self if @neighbours.size == 1
+    pins = @neighbours.size.log2_ceil
+    until @neighbours.size.log2_ceil < pins
       # FIXME: edge labels can/should be cached from previous computations
       a, b = *edges.sort_by { |edge| yield *edge }.first
       merge! a, b
@@ -55,9 +55,9 @@ module ArtDecomp class Graph
   end
 
   def merge_by_vertex_degrees!
-    pins = @edges.size.log2_ceil
-    until @edges.size.log2_ceil < pins or complete?
-      a, b = *@edges.keys.sort_by { |v| -degree(v) }.pairs.find { |v1, v2| not @edges[v1].include? v2 }
+    pins = @neighbours.size.log2_ceil
+    until @neighbours.size.log2_ceil < pins or complete?
+      a, b = *@neighbours.keys.sort_by { |v| -degree(v) }.pairs.find { |v1, v2| not @neighbours[v1].include? v2 }
       merge! a, b
     end
     self
@@ -69,7 +69,7 @@ module ArtDecomp class Graph
   end
 
   def vertices
-    @edges.keys.to_set
+    @neighbours.keys.to_set
   end
 
   private
@@ -77,10 +77,10 @@ module ArtDecomp class Graph
   def merge! a, b
     new = a | b
     adjs = adjacent(a) | adjacent(b)
-    adjs.each { |adj| @edges[adj] << new }
-    @edges[new] = adjs
-    @edges.delete(a).each { |adj| @edges[adj].delete a } unless a == new
-    @edges.delete(b).each { |adj| @edges[adj].delete b } unless b == new
+    adjs.each { |adj| @neighbours[adj] << new }
+    @neighbours[new] = adjs
+    @neighbours.delete(a).each { |adj| @neighbours[adj].delete a } unless a == new
+    @neighbours.delete(b).each { |adj| @neighbours[adj].delete b } unless b == new
   end
 
 end end

data/lib/art-decomp/logging.rb

@@ -1,54 +1,71 @@
 # encoding: UTF-8
 
-require 'gazer'
 require 'logger'
+require 'rcapture'
 
-module ArtDecomp class Logging < Gazer::Aspect::Base
+module ArtDecomp class Logging
 
-  def self.level
-    @@log.level
-  end
+class << self
 
-  def self.level= level
-    @@log.level = level
+  def level
+    @log.level
   end
 
-  def self.log= log
-    @@log = Logger.new log
-    @@log.level = Logger::INFO
-    @@log.formatter = proc { |sev, date, name, msg| "#{date} #{msg}\n" }
-    @@indent = ''
-    apply!
-    @@start = Time.now
+  def level= level
+    @log.level = level
   end
 
-  def self.off
-    # FIXME: if instances can be unadvised, do that and close @@log
-    @@log = Logger.new '/dev/null'
+  def log= log
+    @start = Time.now
+    @log = Logger.new log
+    @log.level = Logger::INFO
+    @log.formatter = proc do |sev, date, name, msg|
+      secs = (Time.now - @start).ceil
+      time = "#{secs / 60 / 60}h#{(secs / 60 % 60).to_s.rjust 2}m#{(secs % 60).to_s.rjust 2}s"
+      best = @best.nil? ? '' : @best.to_s + 'c'
+      path = @path.nil? ? '' : '/' + @path
+      "#{time.rjust 10} #{best.rjust 4}  ·#{path.ljust 10} #{msg}\n"
+    end
+    add_logging
   end
 
-  after instances_of(Executable) => :run do |point|
-    secs = (Time.now - @@start).to_i
-    @@log.info "#{point.object.best ? "final best decomposition: #{point.object.best} cells" : 'no final decomposition'}; done in #{secs}s (#{secs / 60 / 60}h #{secs / 60 % 60}m #{secs % 60}s)"
+  def off
+    # FIXME: if methods can be uncaptured, do that and close @log
+    @log = Logger.new '/dev/null'
   end
 
-  before instances_of(Executable) => :decompositions do |point|
-    @@indent = '  ' * (point.object.iters - point.args[1])
-    path     = point.args[2][point.object.dir.size+1..-1]
-    archs    = point.object.archs.map(&:to_s).sort.reverse.join '+'
-    @@log.info "#{@@indent}FSM #{point.args[0].stats} → #{archs} (#{path}) with #{point.object.gens} – #{point.object.best ? "best so far: #{point.object.best} cells" : 'no decomposition so far'}"
-  end
+  private
 
-  before instances_of(UVGenerator.constants.map { |c| eval("UVGenerator::#{c}") }) => :uv_pairs do |point|
-    @@log.info "#{@@indent}  UV with #{point.object.class.to_s.split('::').last}"
-  end
+  def add_logging
+    uv_gens = UVGenerator.constants.map { |c| UVGenerator.const_get c }
+    qu_gens = QuGenerator.constants.map { |c| QuGenerator.const_get c }
 
-  before instances_of(QuGenerator.constants.map { |c| eval("QuGenerator::#{c}") }) => :blankets do |point|
-    @@log.info "#{@@indent}    U = #{point.args[1].sort.inspect}, V = #{point.args[2].sort.inspect}, Qu with #{point.object.class.to_s.split('::').last}"
-  end
+    (uv_gens + qu_gens + [Executable]).each { |c| c.class_eval { include RCapture::Interceptable } }
 
-  before instances_of(QvGenerator.constants.map { |c| eval("QvGenerator::#{c}") }) => :blankets do |point|
-    @@log.debug "#{@@indent}      |Qu| = #{point.args[3].size}, Qv+G with #{point.object.class.to_s.split('::').last}"
+    Executable.capture_pre :methods => :decompositions do |point|
+      @best = point.sender.best
+      @path = point.args[2][point.sender.dir.size+1..-1]
+      @log.info "#{point.args[0].stats} with #{point.sender.gens}"
+    end
+
+    uv_gens.each do |uv_gen|
+      uv_gen.capture_pre :methods => :uv_pairs do |point|
+        @uv_gen = uv_gen.to_s.split('::').last
+      end
+    end
+
+    qu_gens.each do |qu_gen|
+      qu_gen.capture_pre :methods => :blankets do |point|
+        @log.debug "#{point.args[1].sort.join(' ').ljust 10} #{point.args[2].sort.join(' ').ljust 10} via #{@uv_gen} with #{qu_gen.to_s.split('::').last}"
+      end
+    end
+
+    Executable.capture_post :methods => :run do |point|
+      @best = point.sender.best
+      @log.info "took #{(Time.now - @start).ceil}s"
+    end
   end
 
+end
+
 end end

data/lib/art-decomp/uv_generator/braindead.rb

@@ -2,13 +2,12 @@ module ArtDecomp class UVGenerator::Braindead
 
   def uv_pairs fsm, archs
     input_count = fsm.input_count
-    inputs      = (0...input_count).to_a
     max_v_size  = archs.map(&:pins).max
     Enumerator.new do |yielder|
       (0...2**input_count).each do |vector|
         u, v = Set[], Set[]
         input_count.times do |bit|
-          (vector[bit].zero? ? u : v) << inputs[bit]
+          (vector[bit].zero? ? u : v) << bit
         end
         yielder.yield fsm.expand_x(v), u, v if v.size <= max_v_size
       end

data/lib/art-decomp/vhdl.rb

@@ -0,0 +1,72 @@
+module ArtDecomp class VHDL
+
+  def initialize fsm
+    @fsm = fsm
+  end
+
+  def vhdl name
+    structure = @fsm.structure
+    logic = structure[DontCare].map do |input, results|
+      results[:next_state] = "s#{results[:next_state]}".to_sym if results[:next_state] =~ /^\d+$/
+      [
+        "    if std_match(input, \"#{input}\") then next_state <= #{results[:next_state]}; output <= \"#{results[:output]}\";",
+        '    else',
+      ]
+    end
+    structure.delete DontCare
+    logic << '    case current_state is'
+    logic += structure.map do |state, transitions|
+      state = "s#{state}".to_sym if state =~ /^\d+$/
+      [
+        "      when #{state} =>",
+        transitions.map.with_index do |(input, results), i|
+          results[:next_state] = "s#{results[:next_state]}".to_sym if results[:next_state] =~ /^\d+$/
+          "        #{'els' if i > 0}if std_match(input, \"#{input}\") then next_state <= #{results[:next_state]}; output <= \"#{results[:output]}\";"
+        end,
+        '        end if;',
+      ]
+    end
+    logic << "      when others => next_state <= \"#{'-' * @fsm.codes.values.first.size}\"; output <= \"#{'-' * structure.first.last.first.last[:output].size}\";" unless @fsm.codes.empty?
+    logic << '    end case;'
+    logic << '    end if;' if logic.flatten.include? '    else'
+    if @fsm.codes.empty?
+      states = [
+        "  type state is (#{structure.keys.join ', '});",
+        '  signal current_state, next_state: state;',
+      ]
+      default_state = structure.keys.first
+    else
+      states = @fsm.codes.map do |state, code|
+        state = "s#{state}".to_sym if state =~ /^\d+$/
+        "  constant #{state}: std_logic_vector(#{code.size - 1} downto 0) := \"#{code}\";"
+      end
+      states << "  signal current_state, next_state: std_logic_vector(#{@fsm.codes.first.last.size - 1} downto 0);"
+      default_state = "\"#{'-' * @fsm.codes.values.first.size}\""
+    end
+    <<-VHDL
+library ieee;
+use ieee.numeric_std.all;
+use ieee.std_logic_1164.all;
+entity #{name} is
+  port(
+    clock:  in  std_logic;
+    input:  in  std_logic_vector(#{structure.first.last.first.first.size - 1} downto 0);
+    output: out std_logic_vector(#{structure.first.last.first.last[:output].size - 1} downto 0)
+  );
+end #{name};
+architecture behaviour of #{name} is
+#{states.join "\n"}
+begin
+  process(clock) begin
+    if rising_edge(clock) then current_state <= next_state;
+    end if;
+  end process;
+  process(input, current_state) begin
+    next_state <= #{default_state}; output <= "#{'-' * structure.first.last.first.last[:output].size}";
+#{logic.join "\n"}
+  end process;
+end behaviour;
+    VHDL
+  end
+
+end end