bones-compiler 1.1.0

data/lib/bones/species.rb

@@ -0,0 +1,196 @@
+
+module Bones
+	# The species class contains 'algorithm classes', or 'species'.
+	# Individual species contain a number of input and output
+	# structures and possibly a prefix.
+	#
+	# Examples of species are found below:
+	#
+	# 	0:9|element -> 0:0|shared
+	# 	0:31,0:31|neighbourhood(-1:1,-1:1) -> 0:31,0:31|element
+	# 	unordered 0:99,0:9|chunk(0:0,0:9) -> 0:99|element
+	#
+	# == Naming conventions
+	# The species class uses several naming conventions within
+	# functions. They are as follows for the example species
+	# '0:31,0:15|neighbourhood(-1:1,-1:1) ^ 0:31,0:15|element -> 0:31,0:15|element':
+	#
+	# input::        '0:31,0:15|neighbourhood(-1:1,-1:1) ^ 0:31,0:15|element'
+	# output::       '0:31,0:15|element'
+	# structures::   \['0:31,0:15|neighbourhood(-1:1,-1:1)', '0:31,0:15|element', '0:31,0:15|element']
+	# structure::    '0:31,0:15|neighbourhood(-1:1,-1:1)' or '0:31,0:15|element' (twice)
+	# pattern::      'neighbourhood' or 'element'
+	# ranges::       \['0:31', '0:15'] or ['-1:1', '-1:1']
+	# range::        '0:31' or '0:15' or '-1:1'
+	# from::         '0' or '-1'
+	# to::           '31' or '15' or '1'
+	# sum::          '32' or '16' or '3'
+	class Species < Common
+		attr_reader :name, :inputs, :outputs, :skeleton_name, :settings, :prefix
+		
+		# Initializes the species with a prefix, inputs and out-
+		# puts. It additionally verifies the correctness of the 
+		# provided raw data.
+		def initialize(prefix, input, output)
+			@prefix = prefix
+			@name = (input+' '+ARROW+' '+output)
+			@inputs = set_structures(input)
+			@outputs = set_structures(output)
+			@skeleton_name = nil
+			@settings = nil
+			self.verify_species
+		end
+		
+		# This method splits the raw data (a string) into seperate
+		# structures. The method returns an array of structures.
+		def set_structures(raw_data)
+			raw_data.split(WEDGE).map { |structure| Structure.new(structure) }
+		end
+		
+		# Method to return an array of structures in a given di-
+		# rection.
+		def structures(direction)
+			(direction == INPUT) ? @inputs : @outputs
+		end
+		
+		# Method to return an array of structures for both direc-
+		# tions.
+		def all_structures
+			@inputs + @outputs
+		end
+		
+		# Method to return an ordered array of structures in a
+		# given direction. The order is specified by an argument
+		# which contains a list of pattern names.
+		def ordered(direction,order)
+			ordered = []
+			order.each do |pattern_name|
+				self.structures(direction).each do |structure|
+					ordered.push(structure) if structure.pattern == pattern_name
+				end
+			end
+			
+			# Remove structures with a duplicate name (for matching only - and only if names are given)
+			if ordered.all? { |s| s.name != "" }
+				names = []
+				ordered.each do |structure|
+					ordered.delete(structure) if names.include?(structure.name)
+					names.push(structure.name)
+				end
+			end
+			return ordered
+		end
+		
+		# This method maps an algorithm species to a skeleton.
+		# This is done based on a mapping file provided as part
+		# of the skeleton library. If multiple skeletons match
+		# the current species, the first found match is taken.
+		# This method does not return any values, but instead
+		# sets the class variables +skeleton_name+ and +settings+.
+		def set_skeleton(mapping_file)
+			matches = []
+			File.read(mapping_file).each_line do |line|
+				next if line =~ /^#/
+				data = line.split(/\s:/)
+				matches.push(data) if match_species?(data[0].split(ARROW))
+			end
+			puts MESSAGE+'Multiple matches in skeleton file, selecting the first listed' if matches.length > 1
+			if matches.length != 0
+				@skeleton_name = matches[0][1].delete(':').strip
+				@settings = matches[0][2].delete(':').strip
+			end
+		end
+		
+		# This method is called by the +set_skeleton+ method. It
+		# performs a match between the current species and the
+		# species found in the mapping file. The matching is based
+		# on a fixed order of patterns. The method returns either
+		# true or false.
+		def match_species?(file_data)
+			DIRECTIONS.each_with_index do |direction,num_direction|
+				file_structures = file_data[num_direction].split(WEDGE)
+				counter = 0
+				search_structures = ordered(direction,['chunk','neighbourhood','element','shared','void'])
+				search_structures.each do |search_structure|
+					if !match?(file_structures[counter],search_structure)
+						if (counter != 0) && (file_structures[counter-1] =~ /\+/) && match?(file_structures[counter-1],search_structure)
+							counter = counter - 1
+						else
+							return false
+						end
+					end
+					counter = counter + 1
+				end
+				return false if counter != file_structures.length
+			end
+			return true
+		end
+		
+		# This method implements the match between a species'
+		# structure and a structure found in the mapping file.
+		# It is called from the +match_species+ method. It first
+		# checks for a pattern match, followed by a match of the
+		# dimensions. The method returns either true or false.
+		# TODO: Complete the matching (N-dimensional).
+		def match?(file,search)
+			if (file =~ /#{search.pattern}/)
+				condition = true
+				
+				# Check for parameters
+				if file.split('(').length == 2
+					parameters = file.split('(')[1].split(')')[0]
+					if (parameters == 'D') ||
+						 ((parameters == 'N') && (search.parameters.length == 1)) ||
+						 ((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(','))))
+						condition = condition && true
+					else
+						condition = false
+					end
+				end
+				
+				# Check for dimensions
+				dimensions = file.split(PIPE)[0].strip
+				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(','))))
+					condition = condition && true
+				else
+					condition = false
+				end
+				
+				# Return
+				return true if condition == true
+			end
+			return false
+		end
+		
+		# Method to verify whether this species is shared-based
+		# or not. The method either returns true (if 'shared' is
+		# included in the input or output) or false (if not).
+		def shared?
+			(@name =~ /shared/)
+		end
+		
+		# This method verifies if the species dimensions match
+		# with its parameters in terms of number of dimensions.
+		def verify_species
+			DIRECTIONS.each do |direction|
+				structures(direction).each do |structure|
+					if (structure.has_parameter?) && (structure.dimensions.length != structure.parameters.length)
+						puts WARNING+'Parameter dimension mismatch: '+structure.parameters.inspect+' versus '+structure.dimensions.inspect
+					end
+					structure.dimensions.each do |dimension|
+						puts WARNING+'Negative range given: '+dimension.inspect if (simplify(sum(dimension)).to_i < 1) && !(sum(dimension) =~ /[a-zA-Z]/)
+					end
+				end
+			end
+		end
+		
+	end
+	
+end
+

data/lib/bones/structure.rb

@@ -0,0 +1,94 @@
+
+module Bones
+	# This class represents a single structure in a species.
+	# Such a structure is a single input or output 'structure'.
+	# Stuctures can be set as part of array variables. Examples
+	# of structures are given below:
+	# 	0:9|element
+	# 	0:0|shared
+	# 	0:31,0:31|neighbourhood(-1:1,-1:1)
+	# 	0:99,0:9|chunk(0:0,0:9)
+	#
+	class Structure < Common
+		attr_reader :dimensions, :pattern, :parameters
+		attr_accessor :name
+		
+		# The structure is initialized by the full name given as
+		# a string. It is then analyzed and stored accordingly in
+		# a number of class variables.
+		def initialize(raw_data)
+			data = raw_data.split(PIPE)
+			pattern_data = data[1].split('(')
+			dimension_data = data[0].split('[')
+			@pattern = pattern_data[0].strip
+			@name = (dimension_data.length == 2) ? dimension_data[0].strip : ''
+			@dimensions = (dimension_data.length == 2) ? dimension_data[1].delete(']').split(DIM_SEP) : dimension_data[0].split(DIM_SEP)
+			@parameters = (pattern_data.length > 1) ? pattern_data[1].delete(')').split(DIM_SEP) : []
+		end
+		
+		# TODO: Implement the reverse function
+		def reverse?
+			true
+		end
+		
+		# Method to find out if the structure has a parameter.
+		# This is only the case if it is neighbourhood or chunk
+		# based.
+		def has_parameter?
+			return (@parameters != [])
+		end
+		
+		# Method to find out if the structure has a arrayname
+		# defined. This is optional for a structure.
+		def has_arrayname?
+			return (@name != '')
+		end
+		
+		# Method to get the start of a range given a dimension 'n'.
+		# The method returns the proper simplified result, taking
+		# chunk-sizes into account.
+		def from_at(n)
+			return simplify(from(@dimensions[n]))
+		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.
+		def to_at(n)
+			return (chunk?) ? simplify('((('+to(@dimensions[n])+'+1)/('+to(@parameters[n])+'+1))-1)') : simplify(to(@dimensions[n]))
+		end
+		
+		# Method to verify if a structure is empty or not (e.g. if
+		# it is based on the 'void' pattern.
+		def empty?
+			return @pattern =~ /void/
+		end
+		
+		# Method to check whether a structure is element-based.
+		def element?
+			return @pattern =~ /element/
+		end
+		
+		# Method to check whether a structure is neighbourhood-based.
+		def neighbourhood?
+			return @pattern =~ /neighbourhood/
+		end
+		
+		# Method to check whether a structure is chunk-based.
+		def chunk?
+			return @pattern =~ /chunk/
+		end
+		
+		# Method to check whether a structure is shared-based.
+		def shared?
+			return @pattern =~ /shared/
+		end
+		
+		# Method to check whether a structure is full-based.
+		def full?
+			return @pattern =~ /full/
+		end
+		
+	end
+	
+end

data/lib/bones/variable.rb

@@ -0,0 +1,169 @@
+
+module Bones
+	# This class represents individual variables. Variables have a
+	# name, a type, a direction and an id. They might also have an
+	# algorithmic species coupled if they represent an array. The 
+	# variable type is in AST form and holds information which can
+	# be extracted through methods implemented for the Type class.
+	# 
+	# The provided methods are able to obtain information from the
+	# variables, such as the number of dimensions and the definition.
+	# Other methods query variables for properties, such as whether
+	# a variable is an array or not. Several methods should only be
+	# executed if the variable is an array - this is not checked
+	# within the methods itself.
+	class Variable < Common
+		attr_reader :name, :type, :factors, :direction
+		attr_accessor :species, :size, :guess
+		
+		# Method to initilize the variable class with a name, type
+		# and a direction.
+		def initialize(name,type,size,direction,id,shared)
+			@name      = name
+			@type      = type
+			@size      = size
+			@direction = direction
+			@id        = id
+			@shared    = shared
+			@guess     = false
+			@species   = nil
+		end
+		
+		# This method returns the device name of the variable.
+		def device_name
+			DEVICE+@name
+		end
+		
+		# This method returns the 'golden' name of a variable.
+		# This is used to generate verification code.
+		def golden_name
+			GOLDEN + '_' + @name + '_' + @id
+		end
+		
+		# Method to find out whether a variable is used as an in-
+		# put. If the current algorithm uses the 'shared' pattern,
+		# then the variable must be input only, otherwise it can
+		# be both input or inout to be considered input. The return
+		# value is boolean.
+		def input?
+			return (@shared) ? (@direction == INPUT) : (@direction == INPUT || @direction == INOUT)
+		end
+		
+		# Method to find out whether a variable is used as an out-
+		# put. The variable can be both output or inout to be con-
+		# sidered input. The return value is boolean.
+		def output?
+			return (@direction == OUTPUT || @direction == INOUT)
+		end
+		
+		# Method to obtain the type of a variable, omitting any
+		# information about arrays or pointers. Examples of out-
+		# puts are: +int+, +float+ or +char+. This functionality
+		# is implemented as a recursive search in the Type class,
+		# since the type is in AST form.
+		def type_name
+			@type.type_name.to_s
+		end
+		
+		# Method to obtain the number of dimensions of a variable.
+		# This method returns a positive integer. The functionality
+		# is implemented as a recursive search in the Type class.
+		def dimensions
+			@type.dimensions
+		end
+		
+		# Method to return the device version of a variable's
+		# definition. This includes the variable's type, zero or
+		# more stars and the variable's name, all returned as a
+		# single string.
+		def device_definition
+			type_name + device_pointer + ' ' + @name
+		end
+		
+		# Method to obtain the full defintion of a variable. This
+		# includes the variable type, the variable name, and the
+		# dimensions and/or pointers. Example return values are:
+		# 	int example[10]
+		# 	char **variable
+		# 	unsigned int* example[N]
+		# 	float array[][]
+		def definition
+			definition_prefix + ' ' + @name + definition_suffix
+		end
+		
+		# This method returns a star ('*') if the variable is an
+		# array or an empty string if it is not. It will not be
+		# able to return more than a single star, as device varia-
+		# bles are assumed to be flattened.
+		def device_pointer
+			(@type.array_or_pointer?) ? '*' : ''
+		end
+		
+		# Method to flatten an array into a one dimensional array.
+		# If an array has multiple dimensions, the method will
+		# return a '[0]' for each additional dimension. This method
+		# assumes that the variable is an array.
+		def flatten
+			''+'[0]'*(dimensions-1)
+		end
+		
+		# This method returns the initialization code for a varia-
+		# ble, formatted as a string. This is used to generate the
+		# verification code.
+		def initialization
+			(dynamic?) ? " = (#{definition_prefix})malloc(#{@size.join('*')}*sizeof(#{type_name}));"+NL : ';'+NL
+		end
+		
+		# This method detects whether the variable is dynamically
+		# allocated or not. It returns either true or false.
+		def dynamic?
+			(definition_prefix.count('*') > 0)
+		end
+		
+		# Method to return an array of multiplication factors for
+		# multi-dimensional arrays that need to be flattened. For
+		# every dimension, one factor is generated.
+		def set_factors
+			raise_error("Species dimensions (#{@species.dimensions.length}) and array dimensions (#{@size.length}) mismatch for array '#{@name}'") if @species.dimensions.length != @size.length
+			sizes, @factors = [], []
+			@species.dimensions.each_with_index do |dimension,num_dimension|
+				(sizes.empty?) ? @factors.push('') : @factors.push('*'+sizes.join('*'))
+				sizes.push(simplify(@size[dimensions-num_dimension-1]))
+			end
+		end
+		
+		# Method to return the full flattened address.
+		def flatindex
+			indices = []
+			@species.dimensions.each_with_index do |dimension,num_dimension|
+				index_reverse = !(@species.reverse?) ? num_dimension : @species.dimensions.length-num_dimension-1 # FIXME: REVERSED
+				if (from(dimension) != to(dimension))
+					data = "#{GLOBAL_ID}_#{index_reverse}"
+				else
+					data = from(dimension)
+				end
+				indices.push(data + @factors[index_reverse])
+			end
+			return indices.join(' + ')
+		end
+		
+	# Start of the class's private methods.
+	private
+		
+		# Method to obtain the prefix of a variable's definition,
+		# formatted as a string. The string contains the variable's
+		# type and zero or more stars ('*').
+		def definition_prefix
+			@type.to_s.partition('[')[0].strip
+		end
+		
+		# Method to obtain the suffix of a variable's definition,
+		# formatted as a string. The string is either empty or
+		# contains one or more brackets (e.g. [N][M] or [10]).
+		def definition_suffix
+			@type.to_s.partition('[')[1]+@type.to_s.partition('[')[2]
+		end
+		
+	end
+	
+end