bliftax 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3684c7584ac8b0997cf6de140dadf03327bea675
-  data.tar.gz: 75bcb8953ee6979a0536f557326b7df0987eaa76
+  metadata.gz: 785167c0e657e38b987fd032dacacfeb2b31229e
+  data.tar.gz: 8144130dde9b34a98b76fb67d940cd81ee861d3d
 SHA512:
-  metadata.gz: c4bd813c5b38f9ee2328f0e0bae284971a9ef88c1fe32d19a16c4d29644af8ce8287c576a3fa3e1a667f3f7c46d5ed544f2f7d64a1e934be520eb4dd6e93d2c9
-  data.tar.gz: 581ec378e22f33b2e0bcaf804f9c3823d0d523094def03fd90f9c9872753ede88487cc45c0c7773a0d98080c433167636f6cfe8bcb813402784eafc4730bcd4c
+  metadata.gz: 769d3fea118d3ee1c2bac90fa5c727f7eb49f5c8ee2c68cc3e6ff3ec511491d47b1ede6b40ad4dbb988ac739cd8340dcdd677f1d4668b9b66e41b9e291d8c444
+  data.tar.gz: b804198d60ee236c8a3084a879fe6630acf38a319b8d6b9aa7b92563fcc825fe4f13209e20c307e46a316ce46266ccd4541afbd4d82f410e4878ad98df47c4f2

data/.travis.yml

@@ -1,4 +1,13 @@
 language: ruby
+
 rvm:
   - 2.2.2
+
 before_install: gem install bundler -v 1.10.4
+
+script: 'bundle exec rake'
+
+notifications:
+    email:
+        on_failure: change
+        on_success: never

data/README.md

@@ -1,5 +1,7 @@
 # Bliftax
 
+[![Build Status](https://travis-ci.org/NigoroJr/bliftax.svg)](https://travis-ci.org/NigoroJr/bliftax)
+
 This is a simple library that parses a
 [BLIF](https://www.ece.cmu.edu/~ee760/760docs/blif.pdf) file and does
 operations used in logic optimization algorithms described in Chapter 4.10.2
@@ -29,6 +31,10 @@ This gem currently only supports the following declarations for BLIF:
 
 Following is the list of main features of this gem:
 
+* 2-level logic optimization
+    - getting the prime implicants
+    - getting the essential prime implicants
+    - using branch heuristic
 * star operators
 * sharp operators
 * coverage check (b is covered by a)
@@ -37,6 +43,28 @@ Following is the list of main features of this gem:
 
 Here is an example usage of this gem.
 
+```ruby
+#!/usr/bin/env ruby
+
+require 'bliftax'
+
+abort "Usage: #{$PROGRAM_NAME} <blif file>" if ARGV.empty?
+
+BLIF_FILE = ARGV.first
+
+model = Bliftax.new(BLIF_FILE)
+output = model.dup
+
+model.gates.each_with_index do |gate, i|
+  final_cover = Bliftax::Optimizer.optimize(gate)
+  output.gates[i].implicants = final_cover.to_a
+end
+
+puts output.to_blif
+```
+
+Some other ways you can use this gem.
+
 ```ruby
 require 'bliftax'
 

data/lib/bliftax/implicant.rb

@@ -98,6 +98,10 @@ class Bliftax
     # * C = NULL if A_i * B_i = NULL for more than one i
     # * Otherwise, C_i = A_i * B_i when A_i * B_i != NULL, and C_i = x (don't
     #   care) for the coordinate where A_i * B_i = NULL
+    #
+    # @param rhs [Implicant] the right hand side of the operation.
+    #
+    # @return [Implicant] the result of the star operation.
     def star(rhs)
       # Sanity check
       unless @inputs.size == rhs.inputs.size
@@ -141,7 +145,7 @@ class Bliftax
     # * C = NULL if A_i # B_i = EPSILON for all i
     # * Otherwise, C = union of A_i = B_i' (negated) if A_i = x and B_i != x
     #
-    # @param rhs [Implicant] the right hand side of the operation
+    # @param rhs [Implicant] the right hand side of the operation.
     #
     # @return [Set<Implicant>] Note that the set size could be 1.
     def sharp(rhs)
@@ -301,6 +305,23 @@ class Bliftax
       format '%s %s', @inputs.map(&:bit).join, @output.bit
     end
 
+    # Creates a dummy implicant with the given inputs.
+    # This is useful when checking if an implicant is equal to what is
+    # expected. The input labels are labeled from 'a' to 'z' then 'A' to 'Z',
+    # and the output label is 'out'.
+    #
+    # @param inputs [String, Array<String>] the input bits.
+    # @param output [String] the output bit.
+    #
+    # @return [Implicant] an implicant with dummy labels and the bits set to
+    #   the given bits.
+    def self.make_dummy(inputs, output = '1')
+      labels = ('a'..'z').to_a + ('A'..'Z').to_a
+      in_labels = labels.first(inputs.size)
+      input_str = inputs.is_a?(Array) ? inputs.join : inputs
+      Implicant.new(in_labels, 'out', format('%s %s', input_str, output))
+    end
+
     # Creates a new NULL Implicant.
     #
     # @return [Implicant] a null Implicant

data/lib/bliftax/optimizer.rb

@@ -0,0 +1,202 @@
+class Bliftax
+  # A module that does 2-level logic optimization
+  module Optimizer
+    module_function
+
+    # Does 2-level logic optimization to the given gate (a set of implicants).
+    # This is done in the following steps (as described in the book
+    # Fundamentals of Digital Logic with Verilog Design.
+    #
+    # 1. Find all prime implicants by using the star operator until the
+    #    resulting set of implicants is the same as the previous round.
+    # 2. Apply the sharp operation to one of the prime implicants against all
+    #    other implicants. The operation is cascaded. If the result is not
+    #    null, it is an essential prime implicant. Do this for all prime
+    #    implicants.
+    # 3. For the non-essential prime implicants, remove the ones that can be
+    #    covered by some other implicant but with less cost.
+    # 4. For the remaining implicants, use the branching heuristic to find the
+    #    set of prime implicants with the minimum cost.
+    #
+    # @param gate [Bliftax::Gate, Set<Implicant>, Array<Implicant>] the set of
+    #   implicants to be optimized.
+    #
+    # @return [Set<Implicant>] the resulting optimized set of implicants that
+    #   covers the same minterms.
+    def optimize(gate)
+      implicants = gate.is_a?(Bliftax::Gate) ? gate.implicants : gate
+      primes = get_prime_implicants(implicants)
+
+      essentials = get_essential_implicants(primes)
+
+      # Essential implicants will always be essential
+      primes -= essentials
+
+      # Find minterms that still needs to be covered
+      need_cover = implicants.map(&:minterms).to_set.flatten
+      need_cover -= essentials.map(&:minterms).to_set.flatten
+
+      # Remove implicants with higher cost
+      primes.to_a.permutation(2).each do |a, b|
+        # If b has same coverage but cheaper
+        if a.cost > b.cost && (a.minterms & need_cover) <= b.minterms
+          primes.delete(a)
+        end
+      end
+
+      # Branching heuristic
+      to_use = branching(need_cover, primes)
+
+      essentials.union(to_use)
+    end
+
+    # Returns the prime implicants of the given set of implicants.
+    # This method successively applies the star operations to the given
+    # implicants to find the prime implicants.
+    #
+    # @param implicants [Set<Implicant>, Array<Implicant>] the original set of
+    #   implicants.
+    #
+    # @return [Set<Implicant>] a set of prime implicants.
+    def get_prime_implicants(implicants)
+      # Use star operator to find prime implicants
+      star_set = Set.new(implicants)
+      prev_set = Set.new
+
+      loop do
+        prev_set = star_set.dup
+        prev_set.to_a.combination(2).each do |a, b|
+          result = a * b
+          star_set.add(result) unless result.null?
+        end
+
+        # Remove redundant implicants
+        union = star_set.union(prev_set)
+        union.to_a.permutation(2).each do |a, b|
+          star_set.delete(b) if a.covers?(b)
+        end
+
+        break if star_set == prev_set
+      end
+
+      star_set
+    end
+
+    # Finds the essential implicants of the given set of implicants.
+    # This method applies the sharp operation to an implicant against each of
+    # the other implicants in the set, and adds the tested implicant if and
+    # only if the result of the cascaded sharp operation is not null.
+    #
+    # @param implicants [Set<Implicant>, Array<Implicant>] the original set of
+    #   implicants.
+    #
+    # @return [Set<Implicant>] the essential implicants of the given set of
+    #   implicants.
+    def get_essential_implicants(implicants)
+      sharp_set = Set.new
+
+      implicants.each do |a|
+        result_set = Set.new([a])
+
+        implicants.each do |b|
+          next if b == a
+
+          copy = result_set.dup
+          result_set.clear
+          copy.each do |new_a|
+            result_set.add(new_a.sharp(b))
+          end
+          result_set.flatten!
+          result_set.delete_if { |s| s.null? }
+        end
+
+        sharp_set.add(a) unless result_set.empty?
+      end
+
+      sharp_set
+    end
+
+    # Cost heuristic.
+    # If an Implicant is given, the cost of that Implicant is returned.
+    # Otherwise, the sum of the number of implicants and the cost of each
+    # implicant is returned as the cost for that collection.
+    #
+    # @param what [Implicant, #to_a<#cost>] the thing to be evaluated.
+    #
+    # @return the evaluated cost
+    def cost(what)
+      return what.cost if what.is_a?(Bliftax::Implicant)
+
+      cost_sum = what.size
+      cost_sum += what.to_a.reduce(0) { |a, e| a + e.cost }
+      cost_sum
+    end
+
+    # Finds the minimum-cost combination to cover the given minterms.
+    # This method does recursive DFS to search for the minimum-cost
+    # combination, so it may become slow depending on the number of available
+    # options.
+    #
+    # @param to_cover [Set<Integer>] the set of minterms that need to be
+    #   covered.
+    # @param options [Set<Implicant>] the set of implicants to choose from.
+    def branching(to_cover, options)
+      to_use = Set.new
+      options.dup.each do |implicant|
+        result = branching_helper(to_cover, options, implicant)
+        if result.include?(implicant)
+          to_use.add(implicant)
+          to_cover -= implicant.minterms
+          options.delete(implicant)
+        end
+      end
+      to_use
+    end
+
+    private
+
+    module_function
+
+    # A helper method for the recursive DFS for branching heuristic.
+    #
+    # @param to_cover [Set<Integer>] minterms that need to be covered.
+    # @param options [Set<Implicant>] the prime implicants that we can choose
+    #   from.
+    # @param implicant [Implicant] the implicant that's being decided whether
+    #   to include in the final cover or not.
+    # @return the set that results in a better cost when including or not
+    #   including the implicant.
+    def branching_helper(to_cover, options, implicant)
+      # Get implicants from options that cover at least one required vertex
+      options = options.select do |o|
+        !(to_cover & o.minterms).empty?
+      end
+      options = options.to_set
+
+      # Base case
+      return Set.new if options.empty?
+
+      # Final cover when using the implicant
+      new_options = options - Set.new([implicant])
+      using_implicant = branching_helper(to_cover - implicant.minterms,
+                                         new_options,
+                                         new_options.to_a.first)
+      # Don't forget to add this implicant
+      using_implicant.add(implicant)
+      # Final cover when not using the implicant
+      not_using_implicant = branching_helper(to_cover,
+                                             new_options,
+                                             new_options.to_a.first)
+
+      cost_using = cost(using_implicant)
+      cost_not_using = cost(not_using_implicant)
+
+      # Not using this implicant results in as good a coverage but less cost
+      minterms_coverage = not_using_implicant.map(&:minterms).to_set.flatten
+      if cost_not_using < cost_using && minterms_coverage >= to_cover
+        return not_using_implicant
+      end
+      return using_implicant
+    end
+  end
+end

data/lib/bliftax/version.rb

@@ -1,3 +1,3 @@
 class Bliftax
-  VERSION = '0.1.1'
+  VERSION = '0.2.0'
 end

data/lib/bliftax.rb

@@ -1,5 +1,6 @@
 require 'bliftax/gate'
 require 'bliftax/implicant'
+require 'bliftax/optimizer'
 require 'bliftax/version'
 
 # A class that parses a BLIF file.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bliftax
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Naoki Mizuno
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-10-16 00:00:00.000000000 Z
+date: 2015-10-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -73,6 +73,7 @@ files:
 - lib/bliftax/gate.rb
 - lib/bliftax/implicant.rb
 - lib/bliftax/implicant/bit.rb
+- lib/bliftax/optimizer.rb
 - lib/bliftax/version.rb
 homepage: https://github.com/NigoroJr/bliftax
 licenses: