bones-compiler 1.1.0 → 1.3.1

data/lib/bones/species.rb

@@ -26,7 +26,8 @@ module Bones
 	# to::           '31' or '15' or '1'
 	# sum::          '32' or '16' or '3'
 	class Species < Common
-		attr_reader :name, :inputs, :outputs, :skeleton_name, :settings, :prefix
+		attr_reader :name, :inputs, :outputs, :prefix
+		attr_accessor :skeleton_name, :settings
 		
 		# Initializes the species with a prefix, inputs and out-
 		# puts. It additionally verifies the correctness of the 
@@ -144,7 +145,7 @@ module Bones
 						 ((parameters == 'N,N') && (search.parameters.length == 2)) ||
 						 ((parameters == 'N,1') && (search.parameters.length == 2) && simplify(sum(search.parameters[1])) == '1') ||
 						 ((parameters == '1,N') && (search.parameters.length == 2) && simplify(sum(search.parameters[0])) == '1') ||
-						 ((parameters == simplify(search.parameters.map { |r| sum(r) }.join(','))))
+						 ((parameters == search.parameters.map { |r| simplify(sum(r)) }.join(',')))
 						condition = condition && true
 					else
 						condition = false
@@ -156,7 +157,7 @@ module Bones
 				if (dimensions == 'D') ||
 					 ((dimensions == 'N') && (search.dimensions.length == 1)) ||
 					 ((dimensions == 'N,N') && (search.dimensions.length == 2)) ||
-					 ((dimensions == simplify(search.dimensions.map { |r| sum(r) }.join(','))))
+					 ((dimensions == search.dimensions.map { |r| simplify(sum(r)) }.join(',')))
 					condition = condition && true
 				else
 					condition = false

data/lib/bones/structure.rb

@@ -46,16 +46,26 @@ module Bones
 		
 		# Method to get the start of a range given a dimension 'n'.
 		# The method returns the proper simplified result, taking
-		# chunk-sizes into account.
+		# chunk/neighbourhood-sizes into account.
 		def from_at(n)
-			return simplify(from(@dimensions[n]))
+			if (neighbourhood?)
+				return simplify('('+from(@dimensions[n])+')-('+from(@parameters[n])+')')
+			else
+				return simplify(from(@dimensions[n]))
+			end
 		end
 		
 		# Method to get the end of a range given a dimension 'n'.
 		# The method returns the proper simplified result, taking
-		# chunk-sizes into account.
+		# chunk/neighbourhood-sizes into account.
 		def to_at(n)
-			return (chunk?) ? simplify('((('+to(@dimensions[n])+'+1)/('+to(@parameters[n])+'+1))-1)') : simplify(to(@dimensions[n]))
+			if (chunk?)
+				return simplify('((('+to(@dimensions[n])+'+1)/('+to(@parameters[n])+'+1))-1)')
+			elsif (neighbourhood?)
+				return simplify('('+to(@dimensions[n])+')-('+to(@parameters[n])+')')
+			else
+				return simplify(to(@dimensions[n]))
+			end
 		end
 		
 		# Method to verify if a structure is empty or not (e.g. if

data/lib/castaddon.rb

@@ -7,12 +7,17 @@ end
 require 'rubygems'
 require 'cast'
 
-# Include the extentions to the CAST gem provided by the author
-# of Bones. These extentions provide a significant amount of
-# functionality for Bones itself.
-require 'castaddon/node.rb'
-require 'castaddon/type.rb'
-require 'castaddon/index.rb'
+# Include the extentions to the CAST gem provided. These
+# extentions provide a significant amount of functionality
+# for Bones and A-Darwin.
+require 'castaddon/node_common.rb'
+require 'castaddon/node_adarwin.rb'
+if File.exists?('lib/bones.rb')
+	require 'castaddon/node_bones.rb'
+	require 'castaddon/transformations.rb'
+	require 'castaddon/type.rb'
+	require 'castaddon/index.rb'
+end
 
 # Modify the NodeArray and NodeChain lists to output correct
 # code when printed to a file.

data/lib/castaddon/node_adarwin.rb

@@ -0,0 +1,245 @@
+
+
+# This is an extension to the CAST Node class. This particular extension is for
+# A-Darwin only methods. These methods are mainly used to extract loops and loop
+# data from the CAST nodes.
+class C::Node
+	
+	# This method retrieves all directly following loops from a node, i.e. the
+	# loops belonging to a perfectly nested loop. It is a recursive method: it
+	# retrieves a first loop and calls the method again on the body of the loop.
+	# It collects all the data in the +loop_data+ array.
+	def get_direct_loops(loop_data = [])
+		
+		# Retrieve the next loop
+		new_loop = get_single_loop()
+		
+		# Don't continue if the loop is independent of the writes in the code. This
+		# is part of the selection process of what loops to be considered inner or
+		# outer loops.
+		if loop_data.length > 0
+			written_indices = self.clone.get_accesses().map do |a|
+				(a[:type] == "write") ? a[:indices].map{ |i| i.to_s } : []
+			end
+			if !written_indices.flatten.uniq.include?(new_loop[:var])
+				return loop_data
+			end
+		end
+		
+		# Push the new loop into the array
+		loop_data.push(new_loop)
+		
+		# Check whether the current is actually a loop.
+		# TODO: Is this check really needed or is this just a safety net?
+		if self.for_statement? && self.stmt
+			body = self.stmt.stmts
+			
+			# Check whether or not there is another loop directly following and make
+			# sure that the body is not empty.
+			if body.length == 1 && body.first.for_statement?
+				body.first.get_direct_loops(loop_data)
+			end
+		end
+		
+		# Return all the loop data
+		return loop_data
+	end
+	
+	# This method retrieves all array references in the current node. It retrieves
+	# information on loops and on if-statements as well. This method is
+	# destructive on the current node. It is furthermore called recursively.
+	def get_accesses(accesses = [],loop_data = [],if_statements = [])
+		
+		# Iterate over all the nodes
+		self.preorder do |node|
+			
+			# A loop has been found. Proceed as follows: 1) store the loop data, 2)
+			# call this method recursively on the loop body, and 3) remove the loop
+			# body from the node.
+			if node.for_statement? && node.stmt
+				next_loop_data = loop_data.clone
+				next_loop_data.push(node.get_single_loop)
+				node.stmt.clone.get_accesses(accesses,next_loop_data,if_statements)
+				node.remove_node(node.stmt)
+			
+			# An if-statement has been found. Proceed as follows: 1) store the (one or
+			# more) if-statement conditions, 2) call this method recursively on the
+			# if-statement body, and 3) remove the if-statement body from the node.
+			elsif node.if_statement?
+				next_if_statements = if_statements.clone
+				node.cond.get_conditions().each do |condition|
+					next_if_statements.push(condition)
+				end
+				node.then.clone.get_accesses(accesses,loop_data,next_if_statements)
+				node.remove_node(node.then)
+			
+			# We haven't found an if-statement or loop in the current node, so it
+			# implies that we can search for an array reference.
+			# TODO: Array references as part of conditions or bounds of loops are not
+			# found in this way.
+			else
+			
+				# Collect all the writes we have seen so far. This is used to check for
+				# references that are 'register' references because they have been
+				# written before.
+				writes = accesses.map{ |e| e[:access] if e[:type] == 'write' }.flatten
+				
+				# Collect the potential references
+				to_search = []
+				if node.assignment_expression?
+					to_search << [node.lval,'write',true]
+					to_search << [node.lval,'read',false] if !node.assign?
+					to_search << [node.rval,'read',false]
+				elsif node.binary_expression?
+					to_search << [node.expr1,'read',false]
+					to_search << [node.expr2,'read',false]
+				elsif node.declarator? && node.init
+					to_search << [node.init,'read',false]
+				end
+				
+				# Process the potential references into 'accesses' hashes
+				to_search.each do |item|
+					if item[2] || (writes & item[0].get_index_nodes().flatten).empty?
+						item[0].get_index_nodes().each do |access|
+							accesses << {
+								:access => access,
+								:name => access.get_array_name(),
+								:indices => access.get_indices(),
+								:type => item[1],
+								:loop_data => loop_data,
+								:if_statements => if_statements
+							}
+						end
+					end
+				end
+			end
+		end
+		
+		# Return the array references as hashes
+		return accesses.uniq
+	end
+	
+	# This method retrieves the bounds for an if-statement. The method is called
+	# recursively if there are multiple conditions.
+	# TODO: What about '||' (or) conditions? They are currently handles as '&&'.
+	# TODO: Are these all the possibilities (&&,||,>=,>,<=,<) for conditions?
+	def get_conditions(results=[])
+		
+		# Recursive call for 'And' (&&) and 'or' (||) compound conditions
+		if and? || or?
+			expr1.get_conditions(results)
+			expr2.get_conditions(results)
+			
+		# Greater than or equal (>=)
+		elsif more_or_equal?
+			results << [simplify("#{expr1}")+'='+simplify("(#{expr2})"),'']
+			
+		# Greater than (>)
+		elsif more?
+			results << [simplify("#{expr1}")+'='+simplify("(#{expr2})+1"),'']
+			
+		# Less than or equal (<=)
+		elsif less_or_equal?
+			results << ['',simplify("#{expr1}")+'='+simplify("(#{expr2})")]
+			
+		# Less than (<)
+		elsif less?
+			results << ['',simplify("#{expr1}")+'='+simplify("(#{expr2})-1")]
+			
+		# Unsupported conditions
+		else
+			raise_error("Unsupported if-condition: #{self.to_s}")
+		end
+	end
+	
+	# This method retrieves a single loop from the current node and collects its
+	# data: 1) the loop variable, 2) the lower-bound, 3) the upper-bound, and 4)
+	# the loop step.
+	# FIXME: For decrementing loops, should the min/max be swapped?
+	def get_single_loop()
+		loop_datum = { :var => '', :min => '', :max => '', :step => ''}
+		if self.for_statement?
+			
+			# Get the loop start condition and the loop variable.
+			# TODO: Add support for other types of initialisations, e.g. a declaration
+			if self.init.assign?
+				loop_datum[:var] = self.init.lval.name
+				loop_datum[:min] = self.init.rval.get_value.to_s
+			elsif self.init.declaration?
+				loop_datum[:var] = self.init.declarators.first.name
+				loop_datum[:min] = self.init.declarators.first.init.to_s
+			else
+				raise_error("Unsupported loop initialization: #{self.init}")
+			end
+			
+			# Get the loop's upper-bound condition.
+			# TODO: Add support for the unsupported cases.
+			var_is_on_left = (self.cond.expr1.get_value == loop_datum[:var])
+			loop_datum[:max] = case
+				when self.cond.less? then (var_is_on_left) ? simplify("#{self.cond.expr2.get_value}-1") : "unsupported"
+				when self.cond.more? then (var_is_on_left) ? "unsupported" : simplify("#{self.cond.expr1.get_value}-1")
+				when self.cond.less_or_equal? then (var_is_on_left) ? "#{self.cond.expr2.get_value}" : "unsupported"
+				when self.cond.more_or_equal? then (var_is_on_left) ? "unsupported" : "#{self.cond.expr1.get_value}"
+			end
+			raise_error("Unsupported loop condition: #{self.cond}") if loop_datum[:max] == "unsupported"
+			
+			# Get the loop iterator.
+			# TODO: Investigate whether we can handle non-basic cases
+			iterator = self.iter.to_s
+			loop_datum[:step] = case iterator
+				when "#{loop_datum[:var]}++" then '1'
+				when "++#{loop_datum[:var]}" then '1'
+				when "#{loop_datum[:var]}--" then '-1'
+				when "--#{loop_datum[:var]}" then '-1'
+				else simplify(self.iter.rval.to_s.gsub(loop_datum[:var],'0'))
+			end
+		end
+		return loop_datum
+	end
+	
+	# This method retrieves all loops from a loop nest. The method is based on the
+	# +get_single_loop+ method to extract the actual loop information.
+	def get_all_loops()
+		loops = []
+		self.preorder do |node|
+			loops << node.get_single_loop() if node.for_statement?
+		end
+		return loops
+	end
+	
+	# This method retrieves all nodes from the current node that are index node.
+	# Such nodes represent array references, e.g. in A[i+3], [i+3] is the index
+	# node.
+	def get_index_nodes()
+		nodes = []
+		self.preorder do |node|
+			nodes << node if node.index? && !node.parent.index?
+		end
+		return nodes
+	end
+	
+	# This method retrieves all indices of index nodes from the current node.
+	def get_indices()
+		indices = []
+		self.postorder do |node|
+			indices << node.index if node.index?
+		end
+		return indices
+	end
+	
+	# This method retrieves the name of the array reference.
+	def get_array_name()
+		self.preorder do |node|
+			return node.expr.to_s if node.index? && !node.expr.index?
+		end
+	end
+	
+	# This method retrieves the value from the current node. The value can be an
+	# integer (in case of a constant) or a string (in case of a variable).
+	def get_value()
+		return self.val if self.intliteral?
+		return self.name if self.variable?
+		return self.to_s
+	end
+	
+end

data/lib/castaddon/node_bones.rb

@@ -0,0 +1,316 @@
+
+# This class provides an extension to the CAST node class, which
+# is a parent class for all other CAST classes. The extension
+# consists of three different types of methods:
+# * Methods starting with +transform_+, handling the major code transformations.
+# * Methods to obtain information on variables, such as their direction and whether they are defined or not.
+# * Helper methods, among others those that indicate whether a node is of a certain class.
+class C::Node
+	
+	# Pre-process method. It currently pre-processes a piece of
+	# code (typically the kernel code) to replace particular
+	# code structures with others, which can be handled (better)
+	# by Bones. For now, the pre-process method performs the
+	# following transformations:
+	# * Replaces all incrementors (i++) outside for loops with an assignment (i=i+1).
+	# * Replaces all decrementors (i--) outside for loops with an assignment (i=i-1).
+	def preprocess(conditional=true)
+		self.preorder do |node|
+			if node.postinc? || node.preinc?
+				node.replace_with(C::AssignmentExpression.parse(node.expr.to_s+' = '+node.expr.to_s+' + 1')) unless conditional && node.parent.for_statement?
+			elsif node.postdec? || node.predec?
+				node.replace_with(C::AssignmentExpression.parse(node.expr.to_s+' = '+node.expr.to_s+' - 1')) unless conditional && node.parent.for_statement?
+			end
+		end
+	end
+	
+	# Method to obtain a list of all functions in the code. If
+	# no functions can be found, an empty array is returned. For
+	# every function found, the function itself is pushed to the
+	# list. This method also makes sure that there is at least one
+	# function with the name 'main'. If this is not the case, an
+	# error is raised.
+	def get_functions
+		includes_main = false
+		function_list = []
+		self.preorder do |node|
+			if node.function_definition?
+				function_list.push(node)
+				includes_main = true if (node.name == 'main' || node.name == Bones::VARIABLE_PREFIX+'main')
+			end
+		end
+		raise_error('No "main"-function detected in the input file') if !includes_main
+		return function_list
+	end
+	
+	# This method returns the complexity of a piece of code in
+	# terms of the amount of ALU operations (multiplications,
+	# additions, etc.).
+	def get_complexity
+		count = 0
+		self.preorder do |node|
+			count += 1 if node.alu?
+		end
+		return count
+	end
+	
+	# This method returns the type of a variable (e.g. int, float).
+	# The method requires the name of a variable as an argument.
+	# It first tries to find a declaration for the variable in
+	# by walking through the node. If it cannot find it, it will
+	# search for a parameter definition from a function call. If
+	# that cannot be found either, the method will return 'nil',
+	# meaning that the variable is not defined at all in the
+	# current node.
+	def variable_type(variable_name)
+		self.preorder do |node|
+			if node.declarator? || node.parameter?
+				return node.type if node.name == variable_name
+			end
+		end
+		return nil
+	end
+	
+	# This method returns the sizes of a variable as defined
+	# at the initialization of the array. There are multiple
+	# possibilities:
+	# * Static arrays (e.g. int array[12])
+	# * Static arrays with defines (e.g. int input[N1][N2][N3])
+	# * Variable length arrays (e.g. float temp[n][m])
+	# * Dynamically allocated arrays (e.g. int *a = (int *)malloc(size*4))
+	def size(variable_name)
+		self.preorder do |node|
+			if node.declarator? && node.name == variable_name
+				if node.indirect_type
+					if node.indirect_type.array?
+						return node.indirect_type.lengths
+					elsif node.indirect_type.pointer?
+						node.preorder do |inner_node|
+							if inner_node.call? && inner_node.expr.name == 'malloc'
+								if !node.indirect_type.type # This is a check to ensure single-pointer only
+									string = '('+inner_node.args.to_s+'/sizeof('+node.type.to_s.gsub('*','').strip+'))'
+									string.gsub!(/sizeof\(int\)\/sizeof\(int\)/,'1')
+									string.gsub!(/sizeof\(unsigned int\)\/sizeof\(unsigned int\)/,'1')
+									string.gsub!(/sizeof\(char\)\/sizeof\(char\)/,'1')
+									string.gsub!(/sizeof\(unsigned char\)\/sizeof\(unsigned char\)/,'1')
+									string.gsub!(/sizeof\(double\)\/sizeof\(double\)/,'1')
+									string.gsub!(/sizeof\(float\)\/sizeof\(float\)/,'1')
+									return [string]
+								end
+							end
+						end
+					end
+				end
+			end
+		end
+		return []
+	end
+	
+	# This is a helper method which calls itself recursively,
+	# depending on the dimensions of the variable. It stores
+	# the resulting array sizes in an array 'result'.
+	def lengths(result = [])
+		found = '('+self.length.to_s+')'
+		result.push(found)
+		return (self.type && self.type.array?) ? self.type.lengths(result) : result
+	end
+	
+	# This method returns a list of undefined variables in the
+	# node. It walks the node tree until it finds a node that
+	# full-fills the following:
+	# * The node is a variable (+node.variable?+)
+	# * The variable is not in a function call (+!node.parent.call?+)
+	# * The variable is not defined in the code (+!self.variable_type(node.name)+)
+	def undefined_variables
+		variables = []
+		self.preorder do |node|
+			variables.push(node.name) if (node.variable?) && (!node.parent.call?) && (!self.variable_type(node.name))
+		end
+		return variables.uniq
+	end
+	
+	# This method finds the direction of a variable based on the
+	# node information. The direction of a variable can be either:
+	# * +in:+ - The variable is accessed read-only.
+	# * +out:+ - The variable is accessed write-only.
+	#
+	# The method takes the name of a variable and walks through
+	# the node to search for expressions (assignments and binary
+	# expressions). For each expression it takes the first and
+	# second part of the expression and stores it in a list.
+	# Afterwards, the expressions in the list are analysed for
+	# occurrences of the variable.
+	#
+	# The method raises an error if the variable does not appear
+	# at all: it is neither input nor output.
+	def direction(variable_name)
+		result = {:in => false, :out => false }
+		expressions = {:in => [], :out => []}
+		output_nodes = []
+		self.preorder do |node|
+			
+			# First find out if the current node actually contains the target variable somewhere
+			name_match = false
+			node.preorder do |match_node|
+				name_match = true if (match_node.variable?) && (match_node.name == variable_name)
+			end
+			
+			# If there is a match and the current node is of an assignment/binary/declarator type, we can start processing
+			if (name_match) && (node.assignment_expression? || node.binary_expression? || node.declarator?)
+				
+				# First find out if this node can be considered an input (see sum/acc/temp register variable problem - chunk/example1 vs chunk/example5)
+				possible_input = true
+				node.preorder do |test_node|
+					output_nodes.each do |output_node|
+						possible_input = false if test_node =~ output_node
+					end
+				end
+				
+				# Store the node's data in a list (input/output lists are separated)
+				if node.assignment_expression?
+					output_nodes << node.lval
+					expressions[:out] << node.lval.remove_index
+					expressions[:in] << node.rval                if possible_input
+					if !node.assign?
+						expressions[:in] << node.lval              if possible_input
+					end
+				elsif node.binary_expression?
+					expressions[:in] << node.expr1               if possible_input
+					expressions[:in] << node.expr2.remove_index  if possible_input
+				elsif node.declarator? && node.init
+					expressions[:in] << node.init                if possible_input
+				end
+			end
+		end
+		
+		# Set the result according to the list of nodes
+		expressions.each do |key,expression_list|
+			expression_list.each do |expression|
+				expression.preorder do |node|
+					if (node.variable?) && (node.name == variable_name)
+						result[key] = true
+					end
+				end
+			end
+		end
+		
+		# Return the result
+		return Bones::INOUT if result[:in] && result[:out]
+		return Bones::INPUT if result[:in]
+		return Bones::OUTPUT if result[:out]
+		raise_error('Variable "'+variable_name+'" is neither input nor output')
+	end
+	
+	# This method walks through the node and finds the first
+	# for-loop. If it is found, it returns the contents of the
+	# for-loop and the name of the loop variable. Obtaining the
+	# loop variable is conditional because it can either be an
+	# assignment ('k=0') or a variable definition ('int k=0').
+	#
+	# The method raises an error when no for-loop can be found.
+	# It also raises an error if the loop is not in canonical
+	# form.
+	def remove_loop(from,to)
+		self.preorder do |node|
+			if node.for_statement?
+				from_statement = (node.init.assign?) ? node.init.rval : node.init.declarators[0].init
+				from_loop = (from_statement.variable?) ? from_statement.name : from_statement.to_s
+				to_loop = (node.cond.expr2.variable?) ? node.cond.expr2.name : ((node.cond.expr2.intliteral?) ? node.cond.expr2.val.to_s : node.cond.expr2.to_s)
+				to_loop = to_loop.gsub(/\s/,'')
+				to_loop = '('+to_loop+')-1' if node.cond.less?
+				to_loop = simplify(to_loop)
+				from_loop = simplify(from_loop)
+				puts Bones::WARNING+'The loop iterator starts at: "'+from_loop+'" (expected "'+from+'")' if from_loop != from
+				puts Bones::WARNING+'The loop iterator ends at: "'+to_loop+'" (expected "'+to+'")' if to_loop != to
+				raise_error('The loop increment must be 1') if !(node.iter.unit_increment?)
+				name = (node.init.assign?) ? node.init.lval.name : node.init.declarators.first.name
+				return node.stmt, name
+			end
+		end
+		raise_error('Unexpected number of for-loops')
+	end
+	
+	# This method searches for a target node and checks whether it
+	# exists. The input to the method is the target node. The method
+	# walks through the node and checks whether:
+	# * The node's class is the same as the target class (+node.class == target.class+)
+	# * The node has a parent (+node.parent != nil+)
+	# * The node is equal to the target node (+node.match?(target)+)
+	# If all checks are successful, the method will return the value
+	# 'true' immediately. If the target node cannot be found, the
+	# method returns 'false'.
+	def node_exists?(target)
+		self.preorder do |node|
+			if (node.class == target.class) && (node.parent != nil) && (node.match?(target))
+				return true
+			end
+		end
+		return false
+	end
+	
+	# This method searches for a target function call and replaces
+	# it with another. Both the target and the replacement function
+	# call are given as arguments to the method. The method walks
+	# through the node and checks whether:
+	# * The node's class is the same as the target class (+node.class == target.class+)
+	# * The node has a parent which is a function call (+node.parent.call?+)
+	# * The node is equal to the target node (+node.match?(target)+)
+	# If all checks are successful, the node will be replaced with
+	# the replacement node. The method will continue searching for
+	# other occurrences of the function call.
+	#
+	# The method returns itself.
+	def search_and_replace_function_call(target,replacements)
+		self.preorder do |node|
+			if (node.class == target.class) && (node.parent.call?) && (node.match?(target))
+				node.replace_with(replacements)
+			end
+		end
+		return self
+	end
+	
+	# This method searches for a target function name and replaces
+	# it with another name. Both the target and the replacement
+	# name are given as arguments to the method. The method walks
+	# through the node and checks whether:
+	# * The node's class is a function definition or declaration
+	# * The node's name is equal to the target node's name
+	# If the checks are successful, the node's name will be replaced
+	# The method will continue searching for other occurrences of
+	# functions with the same name.
+	#
+	# The method returns itself.
+	def search_and_replace_function_definition(old_name,new_name)
+		self.preorder do |node|
+			if (node.function_definition? || node.function_declaration?) && (node.name == old_name)
+				node.name = new_name
+			end
+		end
+		return self
+	end
+	
+	# This method is a small helper function to remove index
+	# nodes from a node. It first clones to original node in
+	# order to not overwrite it, then walks the node and removes
+	# index nodes. Finally, it returns a new node.
+	def remove_index
+		node_clone = self.clone
+		node_clone.preorder do |node|
+			node.index.detach if node.index?
+		end
+		return node_clone
+	end
+	
+	# This method checks whether the given code has any conditional
+	# statements (if-statements)
+	def has_conditional_statements?
+		self.preorder do |node|
+			if node.if_statement?
+				return true
+			end
+		end
+		return false
+	end
+	
+end
+