blifutils 0.0.1

data/lib/blifutils/blif_to_vhdl.rb

@@ -0,0 +1,180 @@
+##
+# Copyright (C) 2017 Théotime bollengier <theotime.bollengier@gmail.com>
+#
+# This file is part of Blifutils.
+#
+# Blifutils is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Blifutils is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Blifutils. If not, see <http://www.gnu.org/licenses/>.
+
+
+require 'blifutils/netlist'
+
+
+module BlifUtils
+
+	class Netlist
+
+		def create_vhdl_files (topLevelModuleName = nil)
+			if topLevelModuleName then
+				tLModel = get_model_by_name(topLevelModuleName)
+			else
+				tLModel = first_model
+			end
+
+			abort "ERROR: create_vhdl_file(#{topLevelModuleName}): cannot find top level model" if tLModel.nil?
+
+			update_clocks()
+
+			models.each do |model| 
+				model.create_vhdl_file(model == tLModel)
+			end
+		end 
+
+
+		class Model
+
+			def create_vhdl_file (topLevel = false)
+				return if @isBlackBox
+				fileName = @name + '.vhd'
+				file = File.open(fileName, 'w')
+
+				to_vhdl(toplevel: topLevel, stream: file)
+
+				file.close
+				STDERR.puts "File \"#{fileName}\" written."
+			end
+
+
+			def to_vhdl (topLevel: false, stream: "")
+				iNames = @inputs.collect{|io| io.name.gsub(/(\[|\])/, '_').gsub(/_$/,'').gsub(/^_/,'')}
+				oNames = @outputs.collect{|io| io.name.gsub(/(\[|\])/, '_').gsub(/_$/,'').gsub(/^_/,'')}
+				just = [([0] + iNames.collect{|name| name.length}).max + 3, ([0] + oNames.collect{|name| name.length}).max + 4].max
+				entityStr = iNames.collect{|name| "#{(name + '_in').ljust(just)} : in  std_ulogic;"} + 
+					oNames.collect{|name| "#{(name + '_out').ljust(just)} : out std_ulogic;"}
+
+				stream << "\nlibrary IEEE;\nuse IEEE.STD_LOGIC_1164.ALL;\n\n\nentity #{@name.upcase} is\n\tport ( "
+				stream << entityStr.join("\n\t       ").chop
+				stream << ");\nend #{name.upcase};\n\n\n"
+				stream << "architecture blif of #{name.upcase} is\n\n"
+
+				just = @nets.collect{|net| net.name.length}.max
+
+				@clocks.reject{|clkname| @nets.collect{|net| net.name}.include?(clkname)}.each do |name|
+					stream << "\tsignal #{name.gsub(/(\[|\])/, '_').gsub(/_$/,'').gsub(/^_/,'').ljust(just)} : std_ulogic;\n"
+				end
+				@nets.each do |net|
+					name = net.name
+					stream << "\tsignal #{name.gsub(/(\[|\])/, '_').gsub(/_$/,'').gsub(/^_/,'').ljust(just)} : std_ulogic#{if net.driver.kind_of?(BlifUtils::Netlist::Latch) and net.driver.initValue <= 1 then " := '#{net.driver.initValue}'" end};\n"
+				end
+
+				stream << "\nbegin\n\n"
+
+				@inputs.each do |io|
+					stream << "\t#{io.net.name.gsub(/(\[|\])/, '_').gsub(/_$/,'').gsub(/^_/,'')} <= #{io.name.gsub(/(\[|\])/, '_').gsub(/_$/,'').gsub(/^_/,'') + '_in'};\n"
+				end
+				stream <<("\n") unless @inputs.empty?
+				@outputs.each do |io|
+					stream << "\t#{io.name.gsub(/(\[|\])/, '_').gsub(/_$/,'').gsub(/^_/,'') + '_out'} <= #{io.net.name.gsub(/(\[|\])/, '_').gsub(/_$/,'').gsub(/^_/,'')};\n"
+				end
+				stream <<("\n") unless @outputs.empty?
+
+				stream <<("\n")
+
+				latches = @components.select{|comp| comp.kind_of?(BlifUtils::Netlist::Latch)}
+				unless latches.empty? then
+					clks = latches.collect{|latch| latch.ctrlSig}.reject{|el| el.nil?}.collect{|ctrlsig| if ctrlsig.kind_of?(String) then ctrlsig else ctrlsig.name.gsub(/(\[|\])/, '_').gsub(/_$/,'').gsub(/^_/,'') end}.uniq
+
+					clks.each do |clkname|
+						stream << "\tprocess(#{clkname.gsub(/(\[|\])/, '_').gsub(/_$/,'').gsub(/^_/,'')})\n\tbegin\n\t\tif rising_edge(#{clkname.gsub(/(\[|\])/, '_').gsub(/_$/,'').gsub(/^_/,'')}) then\n"
+						latches.select{|latch| latch.ctrlSig != nil and (latch.ctrlSig == clkname or latch.ctrlSig.name.gsub(/(\[|\])/, '_').gsub(/_$/,'').gsub(/^_/,'') == clkname)}.each do |latch|
+							stream << "\t\t\t#{latch.output.name.gsub(/(\[|\])/, '_').gsub(/_$/,'').gsub(/^_/,'')} <= #{latch.input.name.gsub(/(\[|\])/, '_').gsub(/_$/,'').gsub(/^_/,'')};\n"
+						end
+						stream << "\t\tend if;\n\tend process;\n"
+					end
+
+					if clks.empty? then
+						stream << "\n\tprocess(_clk)\n\tbegin\n\t\tif rising_edge(_clk) then\n"
+						latches.select{|latch| latch.ctrlSig.nil?}.each do |latch|
+							stream << "\n\t\t\t#{latch.output.name.gsub(/(\[|\])/, '_').gsub(/_$/,'').gsub(/^_/,'')} <= #{latch.input.name.gsub(/(\[|\])/, '_').gsub(/_$/,'').gsub(/^_/,'')};\n"
+						end
+						stream << "\t\tend if;\n\tend process;\n"
+					end
+					stream <<("\n")
+				end
+
+				gates = @components.select{|comp| comp.kind_of?(BlifUtils::Netlist::LogicGate)}
+				gates.each do |gate|
+					next if gate.is_constant?
+					oname = gate.output.name.gsub(/(\[|\])/, '_').gsub(/_$/,'').gsub(/^_/,'')
+					inames = gate.inputs.collect{|net| net.name.gsub(/(\[|\])/, '_').gsub(/_$/,'').gsub(/^_/,'')}
+					stream << "\t#{oname} <= "
+					polarity = gate.singleOutputCoverList.collect{|inputs_output| inputs_output[1]}.uniq
+					if polarity.length != 1 or (polarity[0] != 0 and polarity[0] != 1) then
+						abort "ERROR: Output cover list of gate \"#{oname}\" contains '1' and '0' as output!"
+					end
+					stream <<("not(") if polarity[0] == 0 
+					socvlst = gate.singleOutputCoverList.collect { |cvlst|
+						cvlstArr = []
+						cvlst[0].each_with_index { |val, i|
+							if val == 1 then
+								cvlstArr << inames[i]
+							elsif val == 0 then
+								cvlstArr << "not(#{inames[i]})"
+								#else
+								#	cvlstArr << "'1'"
+							end
+						}
+						'(' + cvlstArr.join(' and ') + ')'
+					}.join(" or\n\t#{' '*oname.length}    ")
+					stream << socvlst
+					stream <<(")") if polarity[0] == 0 
+					stream <<(";\n")
+				end
+				stream <<("\n") unless gates.empty?
+
+				constants = gates.select{|gate| gate.is_constant?}
+				constants.each do |cstGate|
+					oname = cstGate.output.name.gsub(/(\[|\])/, '_').gsub(/_$/,'').gsub(/^_/,'')
+					if cstGate.singleOutputCoverList.empty? or cstGate.singleOutputCoverList[0][2] == 0 then
+						stream << "\t#{oname} <= '0';\n"
+					else
+						stream << "\t#{oname} <= '1';\n"
+					end
+				end
+				stream <<("\n") unless constants.empty?
+
+				@components.select{|comp| comp.kind_of?(BlifUtils::Netlist::SubCircuit)}.each_with_index do |subckt, i|
+					stream << "\tCMPINST#{i}: entity work.#{subckt.modelName.upcase}\n\tport map ( "
+
+					iNames = subckt.inputFormalAcutalList.collect{|io| io.name.gsub(/(\[|\])/, '_').gsub(/_$/,'').gsub(/^_/,'') + '_in'}
+					oNames = subckt.outputFormalAcutalList.collect{|io| io.name.gsub(/(\[|\])/, '_').gsub(/_$/,'').gsub(/^_/,'') + '_out'}
+					just = ([0] + iNames.collect{|name| name.length} + oNames.collect{|name| name.length}).max
+
+					portmapStr = subckt.inputFormalAcutalList.collect{|io| "#{(io.name.gsub(/(\[|\])/, '_').gsub(/_$/,'').gsub(/^_/,'') + '_in').ljust(just)} => #{io.net.name.gsub(/(\[|\])/, '_').gsub(/_$/,'').gsub(/^_/,'')},"} + 
+						subckt.outputFormalAcutalList.collect{|io| "#{(io.name.gsub(/(\[|\])/, '_').gsub(/_$/,'').gsub(/^_/,'') + '_out').ljust(just)} => #{io.net.name.gsub(/(\[|\])/, '_').gsub(/_$/,'').gsub(/^_/,'')},"}
+
+					stream << portmapStr.join("\n\t           ").chop
+					stream << ");\n\n"
+				end
+
+				stream << "end blif;\n\n"
+
+				return stream
+			end
+
+		end # BlifUtils::Netlist::Model
+
+	end # BlifUtils::Netlist
+
+end # BlifUtils
+

data/lib/blifutils/elaborator.rb

@@ -0,0 +1,257 @@
+##
+# Copyright (C) 2017 Théotime bollengier <theotime.bollengier@gmail.com>
+#
+# This file is part of Blifutils.
+#
+# Blifutils is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Blifutils is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Blifutils. If not, see <http://www.gnu.org/licenses/>.
+
+
+require 'blifutils/parser.rb'
+require 'blifutils/ast.rb'
+require 'blifutils/netlist.rb'
+
+
+module BlifUtils
+
+	module Elaborator
+
+		def self.elaborate_netlist (ast, quiet: false)
+			modelDeclarations = gather_model_declarations(ast)
+
+			netlist = BlifUtils::Netlist.new
+			models = ast.modelList.collect do |modelAst|
+				puts "Elaborating model \"#{modelAst.name}\"..." unless quiet
+				netlist.add_model(elaborate_model(modelAst, modelDeclarations, quiet: quiet))
+			end
+
+			return netlist
+		end # BlifUtils::Elaborator::elaborate_netlist
+
+
+		private
+
+
+		class ModelDeclaration
+			attr_reader :name
+			attr_reader :inputs  #[String, ... ]
+			attr_reader :outputs #[String, ... ]
+
+			def initialize (name, inputs, outputs)
+				@name = name
+				@inputs = inputs
+				@outputs = outputs
+			end
+
+			def to_s
+				str  = "Model \"#{@name}\"\n"
+				str += "  Inputs:  #{@inputs.join(', ')}\n"
+				str += "  Outputs: #{@outputs.join(', ')}\n"
+				return str
+			end
+		end # BlifUtils::Elaborator::ModelDeclaration
+
+
+		def self.gather_model_declarations (ast)
+			modelDeclarations = ast.modelList.collect do |modelAst|
+				inputs = []
+				modelAst.header.select{|headerElement| headerElement.class == BlifUtils::AST::ModelHeaderElementInputs}.each do |headerInput|
+					headerInput.inputList.each do |inputStr|
+						inputs << inputStr
+					end
+				end
+				outputs = []
+				modelAst.header.select{|headerElement| headerElement.class == BlifUtils::AST::ModelHeaderElementOutputs}.each do |headerOutput|
+					headerOutput.outputList.each do |outputStr|
+						outputs << outputStr
+					end
+				end
+				BlifUtils::Elaborator::ModelDeclaration.new(modelAst.name, inputs, outputs)
+			end
+
+			# Check that each model is defined only once #
+			(0 ... (modelDeclarations.length - 1)).each do |i|
+				md1name = modelDeclarations[i].name
+				((i+1) ... modelDeclarations.length).each do |j|
+					md2name = modelDeclarations[j].name
+					if md1name == md2name then
+						abort "ERROR: Model \"#{md1name}\" is defined more than once"
+					end
+				end
+			end
+
+			return modelDeclarations
+		end # BlifUtils::Elaborator::gather_model_declarations
+
+
+		def self.elaborate_model (modelAst, modelDeclarations, quiet: false)
+			name = modelAst.name
+			inputs = []
+			outputs = []
+			components = []
+			nets = []
+			clocks = []
+
+			# Create inputs #
+			modelAst.header.select{|headerElement| headerElement.class == BlifUtils::AST::ModelHeaderElementInputs}.each do |headerInput|
+				headerInput.inputList.each do |inputStr|
+					if inputs.include?(inputStr) then
+						abort "ERROR: In model \"#{name}\": input \"#{inputStr}\" is declared more than once"
+					end
+					inputs << BlifUtils::Netlist::IO.new(inputStr, inputStr)
+				end
+			end
+
+			# Create outputs #
+			modelAst.header.select{|headerElement| headerElement.class == BlifUtils::AST::ModelHeaderElementOutputs}.each do |headerOutput|
+				headerOutput.outputList.each do |outputStr|
+					if outputs.include?(outputStr) then
+						abort "ERROR: In model \"#{name}\": output \"#{outputStr}\" is declared more than once"
+					end
+					outputs << BlifUtils::Netlist::IO.new(outputStr, outputStr)
+				end
+			end
+
+			unless modelAst.commands.index{|commandAst| commandAst.class == BlifUtils::AST::BlackBox}.nil? then
+				return BlifUtils::Netlist::Model.new(name, inputs, outputs, components, nets, clocks, true)
+			end
+
+			# Create components #
+			modelAst.commands.each do |commandAst|
+				if commandAst.class == BlifUtils::AST::LogicGate then
+					components << BlifUtils::Netlist::LogicGate.new(commandAst.inputs, commandAst.output, commandAst.single_output_cover_list)
+				elsif commandAst.class == BlifUtils::AST::GenericLatch then
+					components << BlifUtils::Netlist::Latch.new(commandAst.input, commandAst.output, commandAst.initValue, commandAst.ctrlType, commandAst.ctrlSig)
+				elsif commandAst.class == BlifUtils::AST::ModelReference then
+					modelDeclarationIndex = modelDeclarations.index{|md| md.name == commandAst.modelName}
+					if modelDeclarationIndex.nil? then
+						abort "ERROR: In model \"#{name}\": model \"#{commandAst.modelName}\" is referenced but is not defined in the parsed blif files"
+					end
+					modelDeclaration = modelDeclarations[modelDeclarationIndex]
+					inputFormalAcutalList = []
+					outputFormalAcutalList = []
+					commandAst.formalAcutalList.each do |form_act| 
+						newIO = BlifUtils::Netlist::IO.new(form_act[0], form_act[1])
+						if modelDeclaration.inputs.include?(newIO.name) then
+							inputFormalAcutalList << newIO
+						elsif modelDeclaration.outputs.include?(newIO.name) then
+							outputFormalAcutalList << newIO
+						else
+							abort "ERROR: In model \"#{name}\": model \"#{commandAst.modelName}\" is referenced with formal \"#{newIO.name}\" which is neither an input nor an output of this referenced model"
+						end
+					end
+					components << BlifUtils::Netlist::SubCircuit.new(commandAst.modelName, inputFormalAcutalList, outputFormalAcutalList)
+				end
+			end
+
+			# Create all nets from their drivers #
+			inputs.each do |iIO|
+				newNet = BlifUtils::Netlist::Net.new(iIO.net, :input, [], true, false)
+				nets << newNet
+				iIO.net = newNet
+			end
+			components.reject{|comp| comp.isSubcircuit?}.each do |component|
+				newNet = BlifUtils::Netlist::Net.new(component.output, component, [], false, false)
+				if nets.collect{|net| net.name}.include?(newNet.name) then
+					abort "ERROR: In model \"#{name}\": net \"#{newNet.name}\" has more than one driver"
+				end
+				nets << newNet
+				component.output = newNet
+			end
+			components.select{|comp| comp.isSubcircuit?}.each do |subcircuit|
+				subcircuit.outputFormalAcutalList.each do |outIO|
+					newNet = BlifUtils::Netlist::Net.new(outIO.net, subcircuit, [], false, false)
+					if nets.collect{|net| net.name}.include?(newNet.name) then
+						abort "ERROR: In model \"#{name}\": net \"#{newNet.name}\" has more than one driver"
+					end
+					nets << newNet
+					outIO.net = newNet
+				end
+			end
+
+			# Update nets fanouts #
+			outputs.each_with_index do |oIO, i|
+				index = nets.index{|net| net.name == oIO.name}
+				if index.nil? then
+					abort "ERROR: In model \"#{name}\": output \"#{oIO.name}\" has no driver"
+				end
+				nets[index].fanouts << BlifUtils::Netlist::Fanout.new(:output, i)
+				nets[index].isOutput = true
+				oIO.net = nets[index]
+			end
+			components.select{|comp| comp.isLatch?}.each do |latch|
+				index = nets.index{|net| net.name == latch.input}
+				if index.nil? then
+					abort "ERROR: In model \"#{name}\": input \"#{latch.input}\" from latch \"#{latch.output.name}\" has no driver"
+				end
+				nets[index].fanouts << BlifUtils::Netlist::Fanout.new(latch, 0)
+				latch.input = nets[index]
+			end
+			components.select{|comp| comp.isGate?}.each do |gate|
+				gate.inputs.each_with_index do |gin, i|
+					index = nets.index{|net| net.name == gin}
+					if index.nil? then
+						abort "ERROR: In model \"#{name}\": input \"#{gin}\" from gate \"#{gate.output.name}\" has no driver"
+					end
+					nets[index].fanouts << BlifUtils::Netlist::Fanout.new(gate, i)
+					gate.inputs[i] = nets[index]
+				end
+			end
+			components.select{|comp| comp.isSubcircuit?}.each do |subcircuit|
+				subcircuit.inputFormalAcutalList.each_with_index do |iIO, i|
+					index = nets.index{|net| net.name == iIO.net}
+					if index.nil? then
+						abort "ERROR: In model \"#{name}\": input \"#{iIO}\" (formal \"#{iIO.name}\" from reference model \"#{subcircuit.modelName}\" has no driver"
+					end
+					nets[index].fanouts << BlifUtils::Netlist::Fanout.new(subcircuit, i)
+					iIO.net = nets[index]
+				end
+			end
+
+			clocks = components.select{|comp| comp.isLatch?}.collect{|latch| latch.ctrlSig}.reject{|el| el.nil?}.uniq
+
+			# Check that each net has at least one fanout #
+			nets.each do |net|
+				if net.fanouts.empty? and not(clocks.include?(net.name)) then
+					STDERR.puts "WARNING: In model \"#{name}\": net \"#{net.name}\" has no fanouts" unless quiet
+				end
+			end
+
+			return BlifUtils::Netlist::Model.new(name, inputs, outputs, components, nets, clocks)
+		end # BlifUtils::Elaborator::elaborate_model
+
+	end # BlifUtils::Elaborator
+
+
+	def self.read(fileName, quiet: false)
+		ast = BlifUtils::Parser.parse(fileName, quiet: quiet)
+		netlist = BlifUtils::Elaborator.elaborate_netlist(ast, quiet: quiet)
+		return netlist
+	end # BlifUtils::read
+
+end # BlifUtils
+
+
+
+if __FILE__ == $0
+	if ARGV.length == 0
+		puts "You must provide the file to process as argument!"
+		exit
+	end
+
+	ast = BlifUtils::Parser.parse(ARGV[0])
+
+	netlist = BlifUtils::Elaborator.elaborate_netlist(ast)
+	puts netlist.analyze
+end
+

data/lib/blifutils/layering.rb

@@ -0,0 +1,406 @@
+##
+# Copyright (C) 2017 Théotime bollengier <theotime.bollengier@gmail.com>
+#
+# This file is part of Blifutils.
+#
+# Blifutils is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Blifutils is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Blifutils. If not, see <http://www.gnu.org/licenses/>.
+
+
+require 'blifutils/netlist'
+
+
+module BlifUtils
+
+	module NetlistGraph
+
+		class Graph
+			attr_accessor :vertices
+			attr_reader :fromModel
+
+			def initialize (vertices = [], model = nil)
+				@vertices = vertices
+				@fromModel = model
+				check unless @vertices.empty?
+			end
+
+
+			def get_graph_without_input_output_reg_cst_modinst
+				newGraph = clone
+				newGraph.vertices.delete_if do |vertice|
+					vertice.component == :input or
+						vertice.component == :output or
+						vertice.component.class == BlifUtils::Netlist::SubCircuit or
+						vertice.component.class == BlifUtils::Netlist::Latch or
+						(vertice.component.class == BlifUtils::Netlist::LogicGate and vertice.component.is_constant?)
+				end
+				newGraph.vertices.each do |vertice|
+					vertice.remove_input_output_reg_cst_modinst_references
+				end
+				return newGraph
+			end
+
+
+			def clone
+				vertices = @vertices.collect{|vertice| vertice.clone}
+				# Update successors and predecessors references to cloned vertices
+				vertices.each do |vertice|
+					(0 ... vertice.successors.length).each do |i|
+						next if vertice.successors[i] == :output
+						successorVertice = vertices.select{|vever| vever.component == vertice.successors[i].component}
+						if successorVertice.empty? then
+							abort "ERROR: While cloning netlist graph: successor #{vertice.successors[i].component} of component #{vertice.component} has no reference in the graph."
+						end
+						if successorVertice.length > 1 then
+							abort "ERROR: While cloning netlist graph: successor #{vertice.successors[i].component} of component #{vertice.component} has more than one reference in the graph."
+						end
+						vertice.successors[i] = successorVertice[0]
+					end
+					(0 ... vertice.predecessors.length).each do |i|
+						next if vertice.predecessors[i] == :input
+						predecessorVertice = vertices.select{|vever| vever.component == vertice.predecessors[i].component}
+						if predecessorVertice.empty? then
+							abort "ERROR: While cloning netlist graph: predecessor #{vertice.predecessors[i].component} of component #{vertice.component} has no reference in the graph."
+						end
+						if predecessorVertice.length > 1 then
+							abort "ERROR: While cloning netlist graph: predecessor #{vertice.predecessors[i].component} of component #{vertice.component} has more than one reference in the graph."
+						end
+						vertice.predecessors[i] = predecessorVertice[0]
+					end
+				end
+				newGraph = BlifUtils::NetlistGraph::Graph.new(vertices, @fromModel)
+				return newGraph
+			end
+
+
+			def self.create_from_model (model)
+				vertices = BlifUtils::NetlistGraph::Vertice.get_vertices_from_model(model)
+				###vertices.each{|ver| puts "#{ver.component} #{ver.component.class.name} #{ver.component.label}"}
+				# Update successors and predecessors references to components by references to Vertices
+				vertices.each do |vertice|
+					(0 ... vertice.successors.length).each do |i|
+						next if vertice.successors[i] == :output
+						successorVertice = vertices.select{|vever| vever.component == vertice.successors[i]}
+						if successorVertice.empty? then
+							abort "ERROR: While elaborating netlist graph: successor #{vertice.successors[i]} of component #{vertice.component} has no reference in the graph."
+						end
+						if successorVertice.length > 1 then
+							abort "ERROR: While elaborating netlist graph: successor #{vertice.successors[i]} of component #{vertice.component} has more than one reference in the graph."
+						end
+						vertice.successors[i] = successorVertice[0]
+					end
+					(0 ... vertice.predecessors.length).each do |i|
+						next if vertice.predecessors[i] == :input
+						predecessorVertice = vertices.select{|vever| vever.component == vertice.predecessors[i]}
+						if predecessorVertice.empty? then
+							abort "ERROR: While elaborating netlist graph: predecessor #{vertice.predecessors[i]} of component #{vertice.component} has no reference in the graph."
+						end
+						if predecessorVertice.length > 1 then
+							abort "ERROR: While elaborating netlist graph: predecessor #{vertice.predecessors[i]} of component #{vertice.component} has more than one reference in the graph."
+						end
+						vertice.predecessors[i] = predecessorVertice[0]
+					end
+				end
+				newGraph = BlifUtils::NetlistGraph::Graph.new(vertices, model)
+				return newGraph
+			end
+
+
+			def to_graphviz
+				@vertices.each_with_index{|vert, i| vert.id = i}
+				str = "digraph #{@fromModel.nil? ? '' : @fromModel.name} {\n"
+				@vertices.each do |vertice|
+					str += "\t#{vertice.id} [label=\"#{vertice.to_s}\""
+					if vertice.component == :input or
+							vertice.component == :output or
+							vertice.component.class == BlifUtils::Netlist::Latch or
+							(vertice.component.class == BlifUtils::Netlist::LogicGate and vertice.component.is_constant?) then
+						str += ",shape=box"
+					end
+					str += "];\n"
+				end
+				@vertices.each do |vertice|
+					vertice.successors.each do |successor|
+						next if successor.class == Symbol
+						str += "\t#{vertice.id} -> "
+						str += "#{successor.id};\n"
+					end
+					if vertice.successors.empty? and vertice.predecessors.empty? then
+						str += "\t#{vertice.id};\n"
+					end
+				end
+				str += "}\n"
+				return str
+			end
+
+
+			def check
+				# Check that each component is in only one vertice
+				allComponents = @vertices.collect{|vertice| vertice.component}
+				allComponents.each do |component|
+					if allComponents.select{|compo| compo == component}.length > 1 then
+						abort "ERROR: Checking graph: component #{component} has more than one corresponding vertice."
+					end
+				end
+
+				@vertices.each do |vertice|
+					# Check that each successor has the current vertice as predecessor
+					vertice.successors.each do |successor|
+						next if successor == :output
+						predecessorVertices = successor.predecessors.select{|prede| prede == vertice}
+						if predecessorVertices.empty? then
+							abort "ERROR: While elaborating netlist graph: successor #{successor.component} of component #{vertice.component} has no reference to component #{vertice.component} as predecessor."
+						end
+						if predecessorVertices.length > 1 then
+							abort "ERROR: While elaborating netlist graph: successor #{successor.component} of component #{vertice.component} has more than one reference to component #{vertice.component} as predecessor."
+						end
+					end
+
+					# Check that each predecessor has the current vertice as successor
+					vertice.predecessors.each do |predecessor|
+						next if predecessor == :input
+						successorVertices = predecessor.successors.select{|succe| succe == vertice}
+						if successorVertices.empty? then
+							abort "ERROR: While elaborating netlist graph: predecessor #{predecessor.component} of component #{vertice.component} has no reference to component #{vertice.component} as successor."
+						end
+						if successorVertices.length > 1 then
+							abort "ERROR: While elaborating netlist graph: predecessor #{predecessor.component} of component #{vertice.component} has more than one reference to component #{vertice.component} as successor."
+						end
+					end
+				end
+			end
+
+
+			def get_connected_subgraphs
+				dags = []
+
+				verticePool = @vertices.collect{|vert| vert}
+
+				until verticePool.empty? do
+					newDAGvertices = []
+					# Pick up a vertice
+					BlifUtils::NetlistGraph::Graph.get_connected_vertices_recursive(verticePool[0], newDAGvertices, verticePool)
+					dags << BlifUtils::NetlistGraph::Graph.new(newDAGvertices, @fromModel)
+				end
+
+				return dags
+			end
+
+
+			def is_acyclic?
+				# If a directed graph is acyclic, it has at least a node with no successors,
+				# if there is no such node, the graph cannot be acyclic.
+				# If we remove a node with no successors, the graph is still acyclic as it leaves new nodes without successors
+
+				# We make a copy of the graph as we will modigy it and its nodes
+				graph = self.clone
+
+				until graph.vertices.empty? do
+					# Find a leaf, e.g. a node with no successors
+					leafs = graph.vertices.select{|vertice| vertice.successors.empty?}
+					return false if leafs.empty?
+					# Remove the leaf from the graph
+					leaf = leafs[0]
+					graph.vertices.delete(leaf)
+					leaf.predecessors.each do |predecessor|
+						predecessor.successors.delete(leaf)
+					end
+				end
+
+				return true
+			end
+
+
+			def assign_layers_to_vertices
+				@vertices.each{|vertice| vertice.layer = nil}
+				v_remainder_set = @vertices.collect{|vert| vert}
+				u_new_set = []
+				u_set_length = 0
+				z_set = []
+				currentLayer = 1
+				while u_set_length != @vertices.length do
+					selectedVertice = nil
+					v_remainder_set.each do |vertice| 
+						unless vertice.successors.collect{|suc| suc.layer != nil and suc.layer < currentLayer}.include?(false)
+							selectedVertice = vertice
+							break
+						end
+					end
+					if selectedVertice.nil? then
+						currentLayer += 1
+						z_set += u_new_set
+						u_new_set = []
+					else
+						selectedVertice.layer = currentLayer	
+						u_set_length += 1
+						u_new_set << selectedVertice
+						v_remainder_set.delete(selectedVertice)
+					end
+				end
+			end
+
+
+			private
+
+
+			def self.get_connected_vertices_recursive (vertice, newDAGvertices, verticePool)
+				return if newDAGvertices.include?(vertice)
+				newDAGvertices << vertice
+				raise 'Mah! Que passa ?' unless verticePool.include?(vertice)
+				verticePool.delete(vertice)
+				vertice.predecessors.each do |predecessor|
+					BlifUtils::NetlistGraph::Graph.get_connected_vertices_recursive(predecessor, newDAGvertices, verticePool)
+				end
+				vertice.successors.each do |successor|
+					BlifUtils::NetlistGraph::Graph.get_connected_vertices_recursive(successor, newDAGvertices, verticePool)
+				end
+			end
+
+		end # BlifUtils::NetlistGraph::Graph
+
+
+		class Vertice
+			attr_accessor :component
+			attr_accessor :successors
+			attr_accessor :predecessors
+			attr_accessor :layer
+			attr_accessor :id
+
+			def initialize
+				@component = nil
+				@successors = []
+				@predecessors = []
+				@layer = nil
+				@id = -1
+			end
+
+
+			def clone
+				newVertice = BlifUtils::NetlistGraph::Vertice.new
+				newVertice.component = @component
+				newVertice.layer = @layer
+				newVertice.successors = @successors.collect{|suc| suc}
+				newVertice.predecessors = @predecessors.collect{|pred| pred}
+				newVertice.id = @id
+				return newVertice
+			end
+
+
+			def remove_input_output_reg_cst_modinst_references
+				@successors.delete_if do |successor|
+					successor == :output or
+						successor.component.class == BlifUtils::Netlist::Latch
+				end
+				@predecessors.delete_if do |predecessor|
+					predecessor == :input or
+						predecessor.component.class == BlifUtils::Netlist::Latch or
+						(predecessor.component.class == BlifUtils::Netlist::LogicGate and predecessor.component.is_constant?)
+				end
+			end
+
+
+			def to_s
+				return "#{@component.class.name.split('::')[-1]} (#{@component.output.name})#{@layer.nil? ? '' : " [L#{@layer}]"}"
+			end
+
+
+			def self.create_from_model_component (component, model)
+				newVertice = BlifUtils::NetlistGraph::Vertice.new
+
+				newVertice.component = component
+				component.inputs.each do |net|
+					driverCompo = net.driver
+					newVertice.predecessors << driverCompo unless newVertice.predecessors.include?(driverCompo)
+				end
+
+				component.output.fanouts.each do |fanout|
+					fanoutCompo = fanout.target
+					newVertice.successors << fanoutCompo unless newVertice.successors.include?(fanoutCompo)
+				end
+
+				return newVertice
+			end
+
+
+			def self.get_vertices_from_model (model)
+				vertices = model.components.collect{|component| self.create_from_model_component(component, model)}
+				return vertices
+			end
+
+		end # BlifUtils::NetlistGraph::Vertice
+
+	end # BlifUtils::NetlistGraph
+
+
+	class Netlist
+
+		class Model
+
+			def simulation_components_to_schedule_stack (withOutputGraphviz: false, quiet: false)
+				unless is_self_contained? then 
+					raise "#{self.class.name}##{__method__.to_s}() requires that the model has no model reference in it. You must flatten the model before."
+				end
+				puts "Generating graph from model components..." unless quiet
+				graphFull = BlifUtils::NetlistGraph::Graph.create_from_model(self)
+				print "Extracting connected subgraphs... " unless quiet
+				graphDAGs = graphFull.get_graph_without_input_output_reg_cst_modinst
+				dags = graphDAGs.get_connected_subgraphs
+				puts "#{dags.length} subgraph#{dags.length > 1 ? 's' : ''} found" unless quiet
+
+				print "Checking that there are no cycles in subgraphs... " unless quiet
+				# Check that all subgraphs are acyclic
+				dags.each_with_index do |dag, i|
+					unless dag.is_acyclic? then
+						str = "\nERROR: There is a combinatorial loop.\n       (See cycle in file \"#{@name}_graph_DAG_#{i}.gv\")\n       This subgraph includes components:\n"
+						dag.vertices.each do |vertice|
+							str += "       Component #{vertice.to_s}\n"
+						end
+
+						abort str
+					end
+				end
+				puts "Ok" unless quiet
+
+				# Do graph layering
+				puts "Layering subgraphs..." unless quiet
+				dags.each_with_index do |dag, i|
+					dag.assign_layers_to_vertices
+					File.write("#{@name}_graph_DAG_#{i}.gv", dag.to_graphviz) if withOutputGraphviz
+				end
+
+				File.write("#{@name}_graph_subgraphs.gv", graphDAGs.to_graphviz) if withOutputGraphviz 
+				graphDAGs.vertices.each do |vertice|
+					ind = graphFull.vertices.index{|vert| vert.component == vertice.component}
+					graphFull.vertices[ind].layer = vertice.layer unless ind.nil?
+				end
+				File.write("#{@name}_graph_full.gv", graphFull.to_graphviz) if withOutputGraphviz 
+				puts "Maximum number of layers: #{dags.collect{|dag| dag.vertices.collect{|vertice| vertice.layer}.reject{|l| l.nil?}.max}.reject{|m| m.nil?}.max}" unless quiet
+
+				puts "Writing static schedule for component simulation..." unless quiet
+				componentSchedulingStack = []
+				dags.each do |dag|
+					dag.vertices.sort{|verta, vertb| vertb.layer <=> verta.layer}.each{|vert| componentSchedulingStack << vert.component}
+				end
+				unless componentSchedulingStack.index{|comp| comp.class != BlifUtils::Netlist::LogicGate}.nil? then
+					raise "merde"
+				end
+
+				return componentSchedulingStack
+			end
+
+		end # BlifUtils::Netlist::Model
+
+	end # BlifUtils::Netlist
+
+end # BlifUtils
+