bones-compiler 1.1.0 → 1.3.1

data/lib/adarwin/fusion.rb

@@ -0,0 +1,174 @@
+
+# Determine whether kernel fusion is legal (see algorithm in paper/thesis)
+def fusion_is_legal?(a, b)
+	(a.writes + a.reads).each do |x|
+		(b.writes + b.reads).each do |y|
+			if (x.tN == y.tN) && (x.tA == 'write' || y.tA == 'write')
+				puts Adarwin::MESSAGE+"Evaluating #{x.to_arc} and #{y.to_arc} for fusion"
+				if x.tD.to_s != y.tD.to_s || x.tE.to_s != y.tE.to_s || x.tS.to_s != y.tS.to_s
+					puts Adarwin::MESSAGE+"Unable to fuse #{x.to_arc} and #{y.to_arc}"
+					return false
+				end
+			end
+		end
+	end
+	puts Adarwin::MESSAGE+"Applying fusion"
+	return true
+end
+
+
+# Perform the kernel fusion transformations
+def kernel_fusion(nests, settings)
+	
+	# Select
+	candidates = nests.select{ |n| n.has_species? }
+	
+	# Iterate
+	prev = nil
+	candidates.each_with_index do |nest,nest_index|
+		curr = nest
+		if prev
+			
+			# Get the loop details
+			loops_prev = prev.code.get_direct_loops
+			loops_curr = curr.code.get_direct_loops
+			if loops_prev.size != loops_curr.size
+				puts Adarwin::MESSAGE+"Unable to apply fusion, loop count does not match"
+				next
+			end
+			
+			# Only proceed if fusion is legal for this combination
+			if fusion_is_legal?(prev, curr)
+				fused_code = []
+			
+				# Get the bodies 
+				body_curr = get_body(loops_curr.size,curr.code.clone)
+				body_prev = get_body(loops_prev.size,prev.code.clone)
+				
+				# Fuse everything together: include if-statements for non-matching loop bounds
+				if settings == 1
+					
+					# Create new loops
+					loops_target = []
+					loops_prev.zip(loops_curr).each do |prevl,currl|
+						raise_error("Unequal step count #{prevl[:step]} versus #{currl[:step]}") if prevl[:step] != currl[:step]
+						minmin = exact_min(prevl[:min],currl[:min])
+						maxmax = exact_max(prevl[:max],currl[:max])
+						loop_datum = { :var => prevl[:var]+currl[:var], :min => minmin, :max => maxmax, :step => prevl[:step]}
+						loops_target.push(loop_datum)
+						
+						# Replace all occurances of the fused loop variable in the current/previous codes
+						body_prev = body_prev.replace_variable(prevl[:var],loop_datum[:var])
+						body_curr = body_curr.replace_variable(currl[:var],loop_datum[:var])
+						
+						# Set minimum if-statement conditions
+						body_prev = create_if(loop_datum[:var],minmin,prevl[:min],body_prev,'>=')
+						body_curr = create_if(loop_datum[:var],minmin,currl[:min],body_curr,'>=')
+						
+						# Set maximum if-statement conditions
+						body_prev = create_if(loop_datum[:var],maxmax,prevl[:max],body_prev,'<=')
+						body_curr = create_if(loop_datum[:var],maxmax,currl[:max],body_curr,'<=')
+					end
+					
+					# Generate the new code
+					fused_code.push(code_from_loops(loops_target,[body_prev,body_curr]))
+				
+				# Create a prologue in case of mismatching loop bounds (experimental)
+				elsif settings == 2
+					
+					# Generate the loop body
+					loops_target = []
+					loops_prev.zip(loops_curr).each do |prevl,currl|
+						raise_error("Unequal step count #{prevl[:step]} versus #{currl[:step]}") if prevl[:step] != currl[:step]
+						body_prev = body_prev.replace_variable(prevl[:var],prevl[:var]+currl[:var])
+						body_curr = body_curr.replace_variable(currl[:var],prevl[:var]+currl[:var])
+					end
+					
+					# Create the main loop nest
+					loops_target = []
+					loops_prev.zip(loops_curr).each do |prevl,currl|
+						minmin = exact_min(prevl[:min],currl[:min])
+						minmax = exact_min(prevl[:max],currl[:max])
+						loop_datum = { :var => prevl[:var]+currl[:var], :min => minmin, :max => minmax, :step => prevl[:step]}
+						loops_target.push(loop_datum)
+					end
+					fused_code.push(code_from_loops(loops_target,[body_prev,body_curr]))
+					
+					# Create the epilogue
+					body = []
+					loops_target = []
+					loops_prev.zip(loops_curr).each do |prevl,currl|
+						minmax = exact_min(prevl[:max],currl[:max])
+						maxmax = exact_max(prevl[:max],currl[:max])
+						loop_datum = { :var => prevl[:var]+currl[:var], :min => minmax, :max => maxmax, :step => prevl[:step]}
+						loops_target.push(loop_datum)
+						if prevl[:max] != currl[:max]
+							body = (prevl[:max] == maxmax) ? [body_curr] : [body_prev]
+						end
+					end
+					fused_code.push(code_from_loops(loops_target,body))
+				end
+				
+				# Add the newly created code to the original code
+				fused_code.each_with_index do |fused_codelet,nest_id|
+					puts fused_codelet
+					prev.code.insert_prev(fused_codelet)
+				
+					# Create a new nest
+					nest = Adarwin::Nest.new(prev.level, fused_codelet, prev.id, prev.name.gsub(/_k(\d+)/,'_fused')+nest_id.to_s, prev.verbose, 1)
+					nests.push(nest)
+				end
+
+				
+				# Set the other nests as to-be-removed
+				prev.removed = true
+				curr.removed = true
+			end
+		end
+	
+		# Next nest
+		prev = nest
+	end
+end
+
+# Return the body of a loop nest
+def get_body(num_loops,code)
+	return code if num_loops == 0
+	if code.first.for_statement? && code.first.stmt
+		code = code.first
+	end
+	if code.for_statement? && code.stmt
+		return get_body(num_loops-1,code.stmt.stmts)
+	end
+	raise_error("Not a perfect nested loop")
+end
+
+# Create an if-statement in front of a statement
+def create_if(loop_var,reference_bound,loop_bound,code,condition)
+	if reference_bound != loop_bound
+		return C::Statement.parse("if(#{loop_var} #{condition} #{loop_bound}) { #{code.to_s} }")
+	end
+	return code
+end
+
+# Generate code from a combination of loops and statements (the body)
+def code_from_loops(loops,statements)
+	code = ""
+	
+	# Start of the loops
+	definition = "int "
+	loops.each do |loop_datum|
+		increment = (loop_datum[:step] == '1') ? "#{loop_datum[:var]}++" : "#{loop_datum[:var]}=#{loop_datum[:var]}+#{loop_datum[:step]}"
+		code += "for(#{definition}#{loop_datum[:var]}=#{loop_datum[:min]}; #{loop_datum[:var]}<=#{loop_datum[:max]}; #{increment}) {"
+	end
+	
+	# Loop body
+	statements.each do |statement|
+		code += statement.to_s
+	end
+	
+	# End of the loops
+	loops.size.times{ |i| code += "}" }
+	
+	C::Statement.parse(code)
+end

data/lib/adarwin/interval.rb

@@ -0,0 +1,57 @@
+
+module Adarwin
+	
+	# This class represents an interval [a..b] including a and b. The class has
+	# the following methods:
+	# * Initialise the interval (+initialize+)
+	# * Print the interval (+to_s+)
+	# * Merge an interval with another interval (+merge+)
+	# * Return the length of the interval (+length+)
+	class Interval
+		attr_accessor :a, :b
+		
+		# Initialise the interval. This method performs a comparison to see whether
+		# a or b is the upper-bound. This comparison is based on guesses made by the
+		# +compare+ method. This method uses loop information if needed.
+		# FIXME: Uses the +compare+ method which might be based on a guess
+		def initialize(a,b,loops)
+			@loops = loops
+			a = simplify(a.to_s)
+			b = simplify(b.to_s)
+			case compare(a,b,@loops)
+				when 'lt' || 'eq' then @a = a; @b = b
+				when 'gt' then @a = b; @b = a
+				else @a = a; @b = b
+			end
+		end
+		
+		# Print the interval as a string (e.g. [4..9]).
+		def to_s
+			@a+RANGE_SEP+@b
+		end
+		
+		# Merge this interval with another interval. This is based on a comparison
+		# made by the +compare+ method, which is an approximation based on loop
+		# information.
+		# FIXME: Uses the +compare+ method which might be based on a guess
+		def merge(other_interval)
+			@a = case compare(@a,other_interval.a,@loops)
+				when 'gt' || 'eq' then other_interval.a
+				when 'lt' then @a
+				else other_interval.a
+			end
+			@b = case compare(@b,other_interval.b,@loops)
+				when 'gt' || 'eq' then @b
+				when 'lt' then other_interval.b
+				else @b
+			end
+		end
+		
+		# Method to compute the length of the interval. For example, the length of
+		# [a..b] is equal to (b-a+1).
+		def length
+			simplify("(#{@b})-(#{a})+1")
+		end
+	end
+	
+end

data/lib/adarwin/memorycopies.rb

@@ -0,0 +1,153 @@
+
+
+# Recursive copy optimisations
+def recursive_copy_optimisations(nests,options)
+	perform_copy_optimisations1(nests,options)
+	perform_copy_optimisations2(nests,options)
+	nests.each do |nest|
+		children = get_children(nest)
+		recursive_copy_optimisations(children,options) if !children.empty?
+	end
+	perform_copy_optimisations3(nests,options)
+	perform_copy_optimisations3(nests,options)
+end
+
+# First set of copyin/copyout optimisations (recursive)
+def perform_copy_optimisations1(nests,options)
+	previous = nil
+	nests.each_with_index do |nest,nest_index|
+		current = nest
+		if previous
+	
+			# Remove spurious copies (out/in)
+			if options[:mem_remove_spurious]
+				previous.copyouts.each do |copyout|
+					current.copyins.each do |copyin|
+						if copyout.tN.to_s == copyin.tN.to_s && copyout.tD.to_s == copyin.tD.to_s
+							current.copyins.delete(copyin)
+							return perform_copy_optimisations1(nests,options)
+						end
+					end
+				end
+			end
+	
+			# Remove spurious copies (out/out)
+			if options[:mem_remove_spurious]
+				previous.copyouts.each do |copyout|
+					current.copyouts.each do |other_copyout|
+						if copyout.tN.to_s == other_copyout.tN.to_s && copyout.tD.to_s == other_copyout.tD.to_s
+							previous.copyouts.delete(copyout)
+							return perform_copy_optimisations1(nests,options)
+						end
+					end
+				end
+			end
+		
+			# Move copyins to the front
+			if options[:mem_copyin_to_front]
+				current.copyins.each do |copyin|
+					if previous.writes && !previous.writes.map{ |w| w.tN }.include?(copyin.tN)
+						previous.copyins.push(copyin)
+						current.copyins.delete(copyin)
+						return perform_copy_optimisations1(nests,options)
+					end
+				end
+			end
+		
+		end
+		
+		# Next nest
+		previous = nest
+	end
+end
+
+# Second set of copyin/copyout optimisations (non-recursive)
+def perform_copy_optimisations2(nests,options)
+	nests.each_with_index do |nest,nest_index|
+		current = nest
+			
+		# Move copyouts to the back
+		if options[:mem_copyout_to_back]
+			current.copyouts.each do |copyout|
+				nests.each_with_index do |other_nest,other_nest_index|
+					if other_nest.id > nest.id && other_nest.depth == nest.depth
+						if other_nest.writes && !other_nest.writes.map{ |w| w.tN }.include?(copyout.tN)
+							copyout.id = copyout.id+1
+						else
+							break
+						end
+					end
+				end
+			end
+		end
+		
+		# Remove spurious copies (double in)
+		if options[:mem_remove_spurious]
+			current.copyins.each_with_index do |copyin,index|
+				current.copyins.each_with_index do |other_copyin,other_index|
+					if index != other_index
+						if copyin.tN.to_s == other_copyin.tN.to_s && copyin.tD.to_s == other_copyin.tD.to_s
+							if copyin.id > other_copyin.id
+								current.copyins.delete(copyin)
+							else
+								current.copyins.delete(other_copyin)
+							end
+						end
+					end
+				end
+			end
+		end
+		
+	end
+end
+
+# Third set of copyin/copyout optimisations (inter-level)
+def perform_copy_optimisations3(nests,options)
+	nests.each do |nest|
+		current = nest
+		children = get_children(nest)
+		if !children.empty?
+			
+			# Inter-level loop optimisations (move to outer loop)
+			if options[:mem_to_outer_loop]
+				
+				# Move copyouts to outer loops
+				max_id = children.map{ |c| 2*c.id+1 }.max
+				children.each do |child|
+					child.copyouts.each do |copyout|
+						to_outer_loop = true
+						nest.outer_loops.map{ |l| l[:var] }.each do |var|
+							to_outer_loop = false if copyout.depends_on?(var)
+						end
+						children.each do |other_child|
+							to_outer_loop = false if other_child.copyins.map{ |c| c.tN }.include?(copyout.tN)
+						end
+						to_outer_loop = false if copyout.get_sync_id < max_id
+						if to_outer_loop
+							copyout.id = nest.id
+							nest.copyouts.push(copyout)
+							child.copyouts.delete(copyout)
+						end
+					end
+				end
+			
+				# Move copyins to outer loops
+				children.first.copyins.each do |copyin|
+					to_outer_loop = true
+					nest.outer_loops.map{ |l| l[:var] }.each do |var|
+						to_outer_loop = false if copyin.depends_on?(var)
+					end
+					children.drop(1).each do |child|
+						to_outer_loop = false if child.copyins.map{ |c| c.tN }.include?(copyin.tN)
+						to_outer_loop = false if child.copyouts.map{ |c| c.tN }.include?(copyin.tN) && child != children.last
+					end
+					if to_outer_loop
+						nest.copyins.push(copyin)
+						children.first.copyins.delete(copyin)
+					end
+				end
+				
+			end
+		end
+	end
+end

data/lib/adarwin/nest.rb

@@ -0,0 +1,225 @@
+
+module Adarwin
+	
+	# This class represents a loop nest. The end goal is to annotate the loop nest
+	# with the corresponding species information. If the loop nest cannot be
+	# parallelised (if there are dependences), the species information is not
+	# printed.
+	#
+	# This class contains methods to perform among others the following:
+	# * Find all array references in the loop nest
+	# * Merge found array references into another array reference
+	# * Translate array references into species
+	# * Perform dependence tests to check for parallelism
+	# 
+	class Nest
+		attr_accessor :code, :species, :name, :verbose
+		attr_accessor :fused, :removed
+		attr_accessor :copyins, :copyouts
+		attr_accessor :depth, :level, :id
+		attr_accessor :reads, :writes
+		attr_accessor :outer_loops
+		
+		# Method to initialise the loop nest. The loop nest is initialised with the
+		# following variables:
+		# * An identifier for the order/depth in which the nest appears (+level+)
+		# * The loop nest body in AST form (+code+)
+		# * A unique identifier for this loop nest (+id+)
+		# * A human readable name for this loop nest (+name+)
+		# * Whether or not verbose information should be printed (+verbose+)
+		def initialize(level, code, id, name, verbose, fused=0)
+			@depth = level.length
+			@level = level
+			@code = code
+			@id = id
+			@name = name+'_k'+(@id+1).to_s
+			@verbose = verbose
+			
+			# Set the default values in case there are dependences
+			@species = ''
+			@fused = fused
+			@removed = false
+			@copyins = []
+			@copyouts = []
+			
+			# Get all loops from the loop body and subtract the outer loops from all
+			# loops to obtain the set of inner loops (loops in the body).
+			@all_loops = @code.get_all_loops()
+			@outer_loops = @code.get_direct_loops()
+			@inner_loops = @all_loops - @outer_loops
+			
+			# Process the read/write nodes in the loop body to obtain the array
+			# reference characterisations. The references also need to be aware of all
+			# loop data and of any if-statements in the loop body.
+			@references = @code.clone.get_accesses().map do |reference|
+				Reference.new(reference,@id,@inner_loops,@outer_loops,@verbose)
+			end
+		
+			# Perform the dependence test. The result can be either true or false.
+			# Proceed only if there are no dependences.
+			# Don't perform the dependence test if this is a fused loopnest
+			@has_dependences = (@fused > 0) ? false : has_dependences?
+			if !@has_dependences && !@references.empty?
+			
+				# Merge array reference characterisations into other array references
+				merge_references()
+				
+				# Translate array reference characterisations into species and ARC
+				translate_into_species()
+				translate_into_arc()
+				
+				# Set the copyin/copyout data from the array references
+				@copyins = @references.select{ |r| r.tA == 'read' }
+				@copyouts = @references.select{ |r| r.tA == 'write' }
+			end
+		end
+		
+		# Perform the algorithm to merge array reference characterisations into
+		# merged array references. This method is a copy of the merging algorithm
+		# as found in the scientific paper.
+		# TODO: Complete this algorithm to match the scientific paper version.
+		def merge_references
+			@references.each do |ref1|
+				@references.each do |ref2|
+					if ref1 != ref2
+					
+						# Perform the checks to see if merging is valid
+						if ref1.tN == ref2.tN && ref1.tA == ref2.tA && ref1.tS == ref2.tS
+							
+							# Merge the domain (ref2 into ref1)
+							ref1.tD.each_with_index do |tD,i|
+								tD.merge(ref2.tD[i])
+							end
+							
+							# Merge the number of elements (ref2 into ref1)
+							ref1.tE.each_with_index do |tE,i|
+								tE.merge(ref2.tE[i])
+							end
+							
+							# Delete ref2
+							@references.delete(ref2)
+							
+							# Something has changed: re-run the whole algorithm again
+							merge_references()
+							return
+						end
+					end
+				end
+			end
+		end
+		
+		# Method to translate the array reference characterisations into species.
+		# The actual logic is performed within the Reference class. In this method,
+		# only the combining of the separate parts is performed.
+		def translate_into_species
+
+			# Obtain the reads and writes
+			@reads = @references.select{ |r| r.tA == 'read' }
+			@writes = @references.select{ |r| r.tA == 'write' }
+			
+			# Create a 'void' access pattern in case there is no read or no write.
+			# Else, set the species for the individual accesses.
+			read_names = (@reads.empty?) ? ['0:0|void'] : @reads.map{ |r| r.to_species }
+			write_names = (@writes.empty?) ? ['0:0|void'] : @writes.map{ |r| r.to_species }
+			
+			# Combine the descriptions (using Reference's +to_s+ method) into species
+			species_in = read_names.uniq.join(' '+WEDGE+' ')
+			species_out = write_names.uniq.join(' '+WEDGE+' ')
+			@species = species_in+' '+ARROW+' '+species_out
+		end
+		
+		# Method to translate the array reference characterisations into a string.
+		def translate_into_arc
+			@arc = @references.map{ |r| r.to_arc }.join(' , ')
+		end
+		
+		# Perform the dependence test for the current loop nest. This method gathers
+		# all pairs of array references to test and calls the actual dependence
+		# tests. Currently, the dependence tests are a combination of the GCD test
+		# and the Banerjee test.
+		def has_dependences?
+			
+			# Gather all the read/write and write/write pairs to test
+			to_test = []
+			writes = @references.select{ |r| r.tA == 'write' }
+			writes.each do |ref1|
+				@references.each do |ref2|
+					
+					# Only if the array names are the same and they are not tested before
+					if ref1.tN == ref2.tN && !to_test.include?([ref2,ref1])
+						
+						# Only if the array references are different (e.g. don't test
+						# A[i][j+4] and A[i][j+4]).
+						if (ref1.get_references != ref2.get_references)
+							to_test << [ref1,ref2]
+						end
+					end
+				end
+			end
+			
+			# Test all pairs using the GCD and Banerjee tests
+			#p to_test.map{ |t| t.map{ |r| r.to_arc }}
+			to_test.uniq.each do |pair|
+				dependence_test = Dependence.new(pair[0],pair[1],@verbose)
+				if dependence_test.result
+					return true
+				end
+			end
+			return false
+		end
+		
+		# Perform a check to see if the loop nest has species that are not just
+		# formed from shared or full patterns. If so, there is no parallelism.
+		def has_species?
+			return false if @removed
+			return false if @has_dependences
+			return false if @species == ''
+			only_full = (@reads) ? @reads.select{ |a| a.pattern != 'full' }.empty? : false
+			only_shared = (@writes) ? @writes.select{ |a| a.pattern != 'shared' }.empty? : false
+			return !(only_full && only_shared)
+		end
+		
+		# Method to print the start pragma of a species.
+		def print_species_start
+			PRAGMA_DELIMITER_START+PRAGMA_SPECIES+' kernel '+@species+PRAGMA_DELIMITER_END
+		end
+		
+		# Method to print the end pragma of a species.
+		def print_species_end
+			PRAGMA_DELIMITER_START+PRAGMA_SPECIES+' endkernel '+@name+PRAGMA_DELIMITER_END
+		end
+		
+		# Method to print the start of an array reference characterisation (ARC).
+		def print_arc_start
+			PRAGMA_DELIMITER_START+PRAGMA_ARC+' kernel '+@arc+PRAGMA_DELIMITER_END
+		end
+		
+		# Method to print the end of an array reference characterisation (ARC).
+		def print_arc_end
+			PRAGMA_DELIMITER_START+PRAGMA_ARC+' endkernel '+@name+PRAGMA_DELIMITER_END
+		end
+		
+		# Method to print the copyin pragma.
+		def print_copyins
+			copys = @copyins.map{ |a| a.to_copy(2*a.id) }
+			PRAGMA_DELIMITER_START+PRAGMA_SPECIES+' copyin '+copys.join(' '+WEDGE+' ')+PRAGMA_DELIMITER_END
+		end
+		
+		# Method to print the copyout pragma.
+		def print_copyouts
+			copys = @copyouts.map{ |a| a.to_copy(2*a.id+1) }
+			PRAGMA_DELIMITER_START+PRAGMA_SPECIES+' copyout '+copys.join(' '+WEDGE+' ')+PRAGMA_DELIMITER_END
+		end
+		
+		# Method to check if the loop nest has copyins.
+		def has_copyins?
+			return !(copyins.empty?) && !(copyins.select{ |r| r.tD if !r.tD.empty? }.empty?)
+		end
+		
+		# Method to check if the loop nest has copyouts.
+		def has_copyouts?
+			return !(copyouts.empty?) && !(copyouts.select{ |r| r.tD if !r.tD.empty? }.empty?)
+		end
+	end
+	
+end