bones-compiler 1.1.0 → 1.3.1

data/examples/neighbourhood/example05.c

@@ -0,0 +1,44 @@
+//
+// This file is part of the Bones source-to-source compiler examples. This C-code
+// example is meant to illustrate the use of Bones. For more information on Bones
+// use the contact information below.
+//
+// == More information on Bones
+// Contact............Cedric Nugteren <c.nugteren@tue.nl>
+// Web address........http://parse.ele.tue.nl/bones/
+//
+// == File information
+// Filename...........neighbourhood/example05.c
+// Author.............Cedric Nugteren
+// Last modified on...07-May-2013
+//
+
+#include <stdio.h>
+
+// This is 'example05', an unrolled one-sided neighbourhood
+int main(void) {
+	int i;
+	int N = 256;
+	
+	// Declare input/output arrays
+	int A[N];
+	int B[N];
+	
+	// Set the input data
+	for(i=0;i<N;i++) {
+		A[i] = i;
+		B[i] = i+5;
+	}
+	
+	// Perform the computation
+	#pragma species kernel A[2:N]|neighbourhood(0:1) -> B[2:N-1]|element
+	for (i=2; i<N; i++) {
+		B[i] = A[i] + A[i+1];
+	}
+	#pragma species endkernel example05
+	
+	// Clean-up and exit the function
+	fflush(stdout);
+	return 0;
+}
+

data/lib/adarwin.rb

@@ -0,0 +1,62 @@
+
+# Include the common part between Bones and A-Darwin
+require 'common.rb'
+
+# We define a custom error class for code generation related
+# errors (any error raised).
+class CodeGenError < StandardError #:nodoc:
+end
+def raise_error(message) #:nodoc:
+	puts Adarwin::ERROR+message
+	raise CodeGenError, 'Error encountered, stopping execution of A-Darwin'
+end
+
+# The module keeps all the classes and constants
+# together. It contains the classes:
+# * Engine: The main component of the tool, providing the high-level flow.
+# * Preprocessor: C-preprocessor, extracting defines/includes from source code.
+# * Nest:
+# * Interval:
+# * Dependence:
+# * Reference:
+# 
+# The module also contains a list of inter-class constants.
+module Adarwin
+	
+	# A string given as a start of an informative message.
+	MESSAGE = '[A-Darwin] ### Info   : '
+	# A string given as a start of an warning message.
+	WARNING = '[A-Darwin] ### Warning: '
+	# A string given as a start of an error message.
+	ERROR   = '[A-Darwin] ### Error  : '
+	
+	# Start of the scop
+	SCOP_START = '#pragma scop'
+	# Enf of the scop
+	SCOP_END = '#pragma endscop'
+	
+	# Species pragma
+	PRAGMA_SPECIES = '#pragma species'
+	
+	# Array reference characterisation (ARC) pragma
+	PRAGMA_ARC = '#pragma ARC'
+	
+	# Create a string from a pragma because pragma's are unsupported by CAST.
+	PRAGMA_DELIMITER_START = '"PRAGMA '
+	PRAGMA_DELIMITER_END = ' PRAGMA"'
+	
+	# This class is created to be a parent class of all classes.
+	class Common
+	end
+	
+end
+
+# This list of require's makes sure all classes are included.
+require 'adarwin/interval.rb'
+require 'adarwin/dependences.rb'
+require 'adarwin/preprocessor.rb'
+require 'adarwin/memorycopies.rb'
+require 'adarwin/fusion.rb'
+require 'adarwin/engine.rb'
+require 'adarwin/reference.rb'
+require 'adarwin/nest.rb'

data/lib/adarwin/dependences.rb

@@ -0,0 +1,268 @@
+module Adarwin
+	
+	# This class represents the dependence tests. The dependence tests are not
+	# objects as such, the use of a class might therefore be a bit out of place.
+	# Instead, the class rather holds all methods related to dependence tests.
+	#
+	# For an M-dimensional access, the problem of dependence testing is reduced to
+	# that of determining whether a system of M linear equations of the form
+	# >>> a_1*I_1 + a_2*I_2 + ... + a_n*I_n = a_0
+	# has a simultaneous integer solution satisfying the loop/if bounds given as
+	# >>> min_k <= I_k <= max_k
+	#
+	# Currently, the following conservative tests are implemented:
+	# * The GCD (greatest common divisor) test
+	# * The Banerjee test
+	#
+	# In case the accesses are multi-dimensional, we perform a subscript-by-
+	# subscript checking. In other words, we test each dimension separately
+	# using the two tests. If we find a possible dependence in one dimension, we
+	# conclude that there is a dependence.
+	class Dependence
+		attr_accessor :result
+		
+		# Method to initialise the dependence tests. This method actually already
+		# computes all the dependence tests and stores the result in a class
+		# variable. It takes as input the pair of accesses it needs to check for
+		# dependences.
+		def initialize(access1,access2,verbose)
+			@verbose = verbose
+			bounds = [access1.bounds,access2.bounds]
+			
+			# Iterate over the dimensions of the array reference
+			results = []
+			dimensions = [access1.indices.size,access2.indices.size].min
+			for dim in 1..dimensions
+				ref1 = access1.indices[dim-1]
+				ref2 = access2.indices[dim-1]
+				loop_vars = [access1.all_loops.map{ |l| l[:var] },access2.all_loops.map{ |l| l[:var] }]
+				
+				# Conclude directly that there is no dependence if the references are
+				# exactly the same.
+				if ref1 == ref2
+					results << false
+					next
+				end
+				
+				# TODO: Include the step in the dependence tests
+				#p access1.tS[dim-1]
+				
+				# Get all variables, a linear equation, and the corresponding conditions
+				all_vars, equation, conditions = get_linear_equation(ref1,ref2,bounds,loop_vars)
+				
+				# Conclude directly that there is no dependence if the variables are not
+				# dependent on the loops.
+				if equation[:ak].empty?
+					results << false
+					next
+				end
+			
+				# Perform the GCD test
+				gcd_result = gcd_test(all_vars,equation)
+				
+				# End if the GCD test concludes that there are no dependences
+				if gcd_result == false
+					results << false
+					
+				# Continue with Banerjee if GCD concludes there might be dependences
+				else
+					ban_result = ban_test(all_vars,equation,conditions)
+					results << ban_result
+				end
+			end
+			
+			# Combine the results for all dimensions
+			if results.include?(true)
+				@result = true
+			else
+				@result = false
+			end
+		end
+
+		# This method implements the GCD test. The test is based on the computation
+		# of the greatest common divisor, giving it its name. The GCD test is based
+		# on the fact that a linear equation in the form of
+		# >>> a_1*I_1 + a_2*I_2 + ... + a_n*I_n = a_0
+		# has an integer solution if and only if the greatest common divisor of a_1,
+		# a_2,...,a_n  is a divisor of a_0. The GCD test checks for this
+		# divisability by performing the division and checking if the result is
+		# integer.
+		#
+		# This method returns true if there is an integer solution, not necessarily
+		# within the loop bounds. Thus, if the method returns true, there might be a
+		# dependence. If the method returns false, there is definitely no dependence.
+		#
+		# TODO: If the result (+division+) is symbolic, can we conclude anything?
+		def gcd_test(all_vars,equation)
+			
+			# Gather all the data to perform the test. Here, base represents a_0 and
+			# data represents a_1,a_2,...,a_n.
+			base = equation[:a0]
+			data = equation[:ak]
+			
+			# Perform the greatest common divisor calculation and perform the division
+			result = gcd(data)
+			division = base/result.to_f
+			
+			# See if the division is integer under the condition that we can test that
+			if result == 0
+				gcd_result = false
+			elsif division.class != Float
+				gcd_result = true
+			else
+				gcd_result = (division.to_i.to_f == division)
+			end
+			
+			# Display and return the result
+			puts MESSAGE+"GCD-test '#{gcd_result}' ---> (#{base})/(#{result}) = #{division}, gcd(#{data})" if @verbose
+			return gcd_result
+		end
+
+		# This method implements the Banerjee test. This test takes loop bounds into
+		# consideration. The test is based on a linear equation in the form of
+		# >>> a_1*I_1 + a_2*I_2 + ... + a_n*I_n = a_0
+		# and loop bounds in the form of
+		# >>> min_k <= I_k <= max_k
+		#
+		# The test proceeds as follows. First, the values a_k+ and a_k- are
+		# computed. Also, the bounds min_k and max_k are calculated from the loop
+		# conditions. Following, the test computes the extreme values 'low' and
+		# 'high'. Finally, the test computes whether the following holds:
+		# >>> low <= a_0 <= high
+		# If this holds, there might be a dependence (method returns true). If this
+		# does not hold, there is definitely no dependence (method returns false).
+		def ban_test(all_vars,equation,conditions)
+			
+			# Pre-process the data to obtain the a_k+, a_k-, and lower-bounds and
+			# upper-bounds for a_k (min_k and max_k).
+			values = []
+			equation[:ak].each_with_index do |a,index|
+				values << {
+					:ak_plus => (a >= 0) ? a : 0,
+					:ak_min => (a <= 0) ? -a : 0,
+					:min_k => conditions[index][:min],
+					:max_k => conditions[index][:max]
+				}
+			end
+			
+			# Compute the extreme values 'low' and 'high'. This is done symbolically.
+			low, high = "0", "0"
+			values.each do |v|
+				partial_low = simplify("
+					(#{v[:ak_plus]}) * (#{v[:min_k]}) -
+					(#{v[:ak_min]}) * (#{v[:max_k]})
+				")
+				low = simplify("(#{low}) + (#{partial_low})")
+				partial_high = simplify("
+					(#{v[:ak_plus]}) * (#{v[:max_k]}) -
+					(#{v[:ak_min]}) * (#{v[:min_k]})
+				")
+				high = simplify("(#{high}) + (#{partial_high})")
+			end
+			
+			# Perform the actual test: checking if low <= a_0 <= high holds. This is
+			# implemented as two parts: check the lower-bound and check the upper-
+			# bound.
+			# FIXME: This method uses the +max+ which might make a guess.
+			base = equation[:a0]
+			test1 = (base.to_s == max(low,base.to_s))
+			test2 = (high == max(base.to_s,high))
+			ban_result = (test1 && test2)
+			
+			# Display and return the results
+			puts MESSAGE+"Banerjee '#{ban_result}' ---> (#{test1},#{test2}), '(#{low} <= #{base} <= #{high})'" if @verbose
+			return ban_result
+		end
+
+		# This method retrieves a linear equation from a pair of access. Accesses
+		# are transformed into a linear equation of the form
+		# >>> a_1*I_1 + a_2*I_2 + ... + a_n*I_n = a_0
+		# Additionally, this method returns a list of all variables and a list of
+		# loop bounds corresponding to the linear equation's variables.
+		def get_linear_equation(access1,access2,bounds,all_loop_vars)
+			equation = { :a0 => 0, :ak => [] }
+			all_vars = []
+			conditions = []
+			hash = {}
+			
+			# Loop over the two accesses
+			[access1,access2].each_with_index do |access,index|
+				access = simplify(access.to_s)
+				
+				# Get the variables (I_1 ... I_n) and modify the access expression
+				vars = get_vars(access).uniq
+				loop_vars = get_loop_vars(vars,all_loop_vars[index])
+				all_vars = (all_vars + vars).uniq
+				vars.each do |var_name|
+					access = access.gsub(/\b#{var_name}\b/,"hash[:#{var_name}]")
+				end
+				
+				# Create a hash of all the variables. For now, this is just the name of
+				# the variable. The values will be set later. This uses the 'symbolic'
+				# library.
+				vars.each do |var_name|
+					if !hash[var_name.to_sym]
+						hash[var_name.to_sym] = var :name => var_name
+					end
+					hash[var_name.to_sym].value = hash[var_name.to_sym]
+				end
+				
+				# Find the constant term (a_0). This uses the +eval+ method together
+				# with the 'symbolic' gem to compute the term.
+				loop_vars.each do |var_name|
+					hash[var_name.to_sym].value = 0
+				end
+				base = eval(access).value
+				val = (index == 0) ? base : -base
+				equation[:a0] = equation[:a0] + val
+				
+				# Find the other terms (a_1, a_2, ... a_n). This uses the +eval+ method
+				# together with the 'symbolic' gem to compute the terms.
+				loop_vars.each do |var_name|
+					hash[var_name.to_sym].value = 1
+					val = eval(access).value - base
+					val = (index == 0) ? val : -val
+					equation[:ak] << val
+					hash[var_name.to_sym].value = 0
+				end
+				
+				# Get the loop bound conditions corresponding to the linear equation's
+				# variables.
+				loop_vars.each do |var_name|
+					conditions << bounds[index].select{ |c| c[:var] == var_name }.first
+				end
+			end
+			return all_vars, equation, conditions
+		end
+
+		# Implementation of a GCD method with any number of arguments. Relies on
+		# Ruby's default GCD method. In contrast to the normal gcd method, this
+		# method does not act on a number, but instead takes an array of numbers as
+		# an input.
+		def gcd(args)
+			val = args.first
+			args.drop(1).each do |argument|
+				val = val.gcd(argument)
+			end
+			return val
+		end
+		
+		# Method to obtain all variables in an array reference that are also loop
+		# variables.
+		def get_loop_vars(vars,all_loop_vars)
+			return vars & all_loop_vars
+		end
+
+		# Method to combine an array of integers in the form of a subtraction. For
+		# example, given the input [a,b,c,d], the output will be (a-b-c-d).
+		# TODO: Remove this method
+		#def merge_subtract(args)
+		#	val = args.first
+		#	args.drop(1).each do |argument|
+		#		val = val - argument
+		#	end
+		#	return val
+		#end
+		
+	end
+end

data/lib/adarwin/engine.rb

@@ -0,0 +1,277 @@
+
+module Adarwin
+	
+	# This is the main 'engine' for the A-darwin algorithmic species extraction
+	# tool. It contains methods to parse the command-line arguments, to run the
+	# pre-processor, to insert the annotations, and to pretty print the final
+	# output.
+	# TODO: Add a syntax check by a normal compiler first (e.g. gcc)
+	class Engine < Common
+		
+		# Initializes the engine and processes the command line arguments. This
+		# method uses the 'trollop' gem to parse the arguments and to create a
+		# nicely formatted help menu. This method additionally initializes a result-
+		# hash and reads the contents of the source file from disk.
+		#
+		# ==== Command-line usage:
+		#    adarwin --application <input> [OPTIONS]
+		#
+		# ==== Options:
+		#        --application, -a <s>:   Input application file
+		#  --no-memory-annotations, -m:   Disable the printing of memory annotations
+		#    --mem-remove-spurious, -s:   Memcopy optimisation: remove spurious copies
+		#    --mem-copyin-to-front, -f:   Memcopy optimisation: move copyins to front
+		#    --mem-copyout-to-back, -b:   Memcopy optimisation: move copyouts to back
+		#      --mem-to-outer-loop, -l:   Memcopy optimisation: move copies to outer loops
+		#    --only-alg-number, -o <i>:   Only generate code for the x-th species (99 -> all) (default: 99)
+		#                --version, -v:   Print version and exit
+		#                   --help, -h:   Show this message
+		#
+		def initialize
+			@result = {:original_code            => [],
+			           :species_code             => []}
+			
+			# Parse the command line options using the 'trollop' gem.
+			@options = Trollop::options do
+				version 'A-darwin, part of Bones version '+File.read(ADARWIN_DIR+'/VERSION').strip+' (c) 2013 Cedric Nugteren, Eindhoven University of Technology'
+				banner  NL+'A-darwin is an algorithmic species extraction tool. ' +
+				        'For more information, see the README.rdoc file or visit the Bones/A-darwin website at http://parse.ele.tue.nl/bones/.' + NL + NL +
+				        'Usage:' + NL +
+				        '    adarwin --application <input> [OPTIONS]' + NL +
+				        'using the following flags:'
+				opt :application,           'Input application file',                                           :short => 'a', :type => String
+				opt :no_memory_annotations, 'Disable the printing of memory annotations',                       :short => 'm', :default => false
+				opt :mem_remove_spurious,   'Memcopy optimisation: remove spurious copies',                     :short => 'r', :default => false
+				opt :mem_copyin_to_front,   'Memcopy optimisation: move copyins to front',                      :short => 'f', :default => false
+				opt :mem_copyout_to_back,   'Memcopy optimisation: move copyouts to back',                      :short => 'b', :default => false
+				opt :mem_to_outer_loop,     'Memcopy optimisation: move copies to outer loops',                 :short => 'l', :default => false
+				opt :fusion,                'Type of kernel fusion to perform (0 -> disable)',                  :short => 'k', :type => Integer, :default => 0
+				opt :print_arc,             'Print array reference characterisations (ARC) instead of species', :short => 'c', :default => false
+				opt :silent,                'Become silent (no message printing)',                              :short => 's', :default => false
+				opt :only_alg_number,       'Only generate code for the x-th species (99 -> all)',              :short => 'o', :type => Integer, :default => 99
+			end
+			Trollop::die 'no input file supplied (use: --application)'              if !@options[:application_given]
+			Trollop::die 'input file "'+@options[:application]+'" does not exist'   if !File.exists?(@options[:application])
+			@options[:name] = @options[:application].split('/').last.split('.').first
+			@options[:no_memory_annotations] = true if @options[:print_arc]
+			
+			# Obtain the source code from file
+			@source = File.open(@options[:application],'r'){|f| f.read}
+			@basename = File.basename(@options[:application],'.c')
+		end
+		
+		# Method to process a file and to output target code. This method calls all
+		# the other methods, it is the main engine.
+		#
+		# ==== Tasks:
+		# * Run the preprocessor to obtain algorithm information.
+		# * Use the 'CAST' gem to parse the source into an AST.
+		# * Call the code generator to perform the real work and produce output.
+		def process
+			
+			# Run the preprocessor
+			preprocessor = Adarwin::Preprocessor.new(@source)
+			preprocessor.process
+			@result[:header_code] = preprocessor.header_code
+			
+			# Set-up the CAST gem to include certain types
+			# FIXME: What about other (user-defined?) types?
+			parser = C::Parser.new
+			parser.type_names << 'FILE'
+			parser.type_names << 'size_t'
+			
+			# Parse the original source code into AST form (using CAST)
+			original_ast = parser.parse(preprocessor.parsed_code)
+			
+			# Create an AST of the SCoP (using CAST) and save a backup
+			scop_ast = C::Block.parse('{'+preprocessor.scop_code+'}')
+			original_scop_ast = scop_ast.clone
+			
+			# Process the scop to identify the loop nests of interest and to find the
+			# corresponding species. This is the method performing most of the work.
+			@nests = []
+			@id = 0
+			populate_nests(scop_ast)
+			
+			# Remove inner-loop (nested) species. This removes all species that are
+			# found within another species. For completeness, this might be desired in
+			# some cases.
+			# TODO: Make this an option
+			@nests.each do |nest|
+				if nest.has_species?
+					remove_inner_species(get_children(nest))
+				end
+			end
+			@nests.delete_if{ |n| n.removed }
+			
+			# Iterate over the nests/statements to optimize the copies. Currently, 
+			# this will only look at loop nests with a depth of 1. Re-call the memory
+			# copy optimisations method every time a change is made.
+			# TODO: Investigate what the depth should be.
+			basenests = @nests.select{ |n| n.depth == 1 }
+			recursive_copy_optimisations(basenests,@options)
+			
+			# Kernel fusion is enabled (1,2,3,4) or disabled (0)
+			if @options[:fusion] > 0
+				# Test if fusion is legal and perform the actual transformation
+				kernel_fusion(@nests, @options[:fusion])
+			end
+			
+			# Delete the to-be-removed code (because of fusion)
+			@nests.each do |nest|
+				if nest.removed
+					scop_ast.remove_once(nest.code)
+				end
+			end
+			@nests.delete_if{ |n| n.removed }
+			
+			# Insert the species and memory copy annotations into the original code.
+			# Don't do this if the user specified that he is not interested in the
+			# memory copy annotations.
+			insert_copies(scop_ast) unless @options[:no_memory_annotations]
+			insert_species(scop_ast)
+			
+			# Create the modified SCoP and remove the quotes from the pragma's
+			# FIXME: This is a hack for now, this has conflicts with strings in code
+			modified_scop = INDENT+SCOP_START+NL+scop_ast.to_s+NL+INDENT+SCOP_END+NL
+			modified_scop = modified_scop.gsub(PRAGMA_DELIMITER_START,'')
+			modified_scop = modified_scop.gsub(PRAGMA_DELIMITER_END,'')
+			
+			# Print the result SCoP
+			puts modified_scop if !@options[:silent]
+			
+			# Store the result
+			@result[:species_code] = preprocessor.target_code.gsub(preprocessor.scop_code,modified_scop)
+		end
+		
+		# This method writes the output code to a file.
+		def write_output
+			
+			# Populate the species file
+			# TODO: The filename is fixed, make this an optional argument
+			File.open(File.join(@options[:application].split('.').first+'_species'+'.c'),'w') do |target|
+				target.puts @result[:species_code]
+			end
+		end
+		
+		# This method populates the Nest datastructure (recursively). It is the main
+		# method to process the loop nests and fine the species information. It is
+		# called recursively.
+		def populate_nests(ast,level=[])
+			
+			# Only proceed if it is a loop
+			if ast.block?
+				
+				# Create the new loop nests for the current depth level
+				ast.stmts.each_with_index do |nest,index|
+					new_level = level.clone.push(index)
+					
+					# Push the loop nest, but only if it is not disabled by options
+					if @options[:only_alg_number].to_i == 99 || @options[:only_alg_number].to_i == (@id+1)
+						
+						# Only continue if the nest is an actual loop nest
+						if nest.for_statement?
+							@nests.push(Nest.new(new_level,nest,@id,@basename,!@options[:silent]))
+						end
+					end
+					@id += 1
+				end
+				
+				# Proceed to the next depth level.
+				# TODO: Make it an option to only investigate the outer most level(s).
+				ast.stmts.each_with_index do |nest,index|
+					new_level = level.clone.push(index)
+					if nest.stmt # && new_level == 0
+						populate_nests(nest.stmt,new_level)
+					end
+				end
+			end
+		end
+		
+		# This method removes all species in the current loop nest (called
+		# recursively). It assumes these species should be removed.
+		def remove_inner_species(nests)
+			nests.each do |nest|
+				nest.copyins = []
+				nest.copyouts = []
+				nest.species = ''
+				nest.removed = true
+				children = get_children(nest)
+				remove_inner_species(children) if children
+			end
+		end
+		
+		# Method to obtain the children of a nest
+		def get_children(parent)
+			children = []
+			@nests.map do |nest|
+				if parent.depth+1 == nest.depth
+					if parent.level == nest.level.reverse.drop(1).reverse
+						children << nest
+					end
+				end
+			end
+			return children
+		end
+		
+		# This method iterates over the loop nests and inserts the species into the
+		# original AST. It also inserts the synchronisation barries when needed, and
+		# only if the user is interested in the memory copy annotations.
+		def insert_species(scop_ast)
+			
+			# Find out where the synchronisation statements are needed
+			sync_needed = []
+			@nests.each do |nest|
+				sync_needed << nest.copyins.map{ |c| c.get_sync_id }
+				sync_needed << nest.copyouts.map{ |c| c.get_sync_id }
+			end
+			sync_needed = sync_needed.flatten.uniq
+			
+			# Insert the annotations into the code
+			sync = 0
+			@nests.each do |nest|
+				sync = 2*nest.id
+				
+				# Insert the pre-kernel synchronisation barrier
+				if sync_needed.include?(sync) && !@options[:no_memory_annotations]
+					nest.code.insert_prev(C::StringLiteral.parse(PRAGMA_DELIMITER_START+PRAGMA_SPECIES+' sync '+(sync).to_s+PRAGMA_DELIMITER_END))
+				end
+				
+				# Insert the pre-kernel species (start of species)
+				if nest.has_species?
+					to_print = (@options[:print_arc]) ? nest.print_arc_start : nest.print_species_start
+					nest.code.insert_prev(C::StringLiteral.parse(to_print))
+				end
+				
+				# Insert the post-kernel synchronisation barrier
+				if sync_needed.include?(sync+1) && !@options[:no_memory_annotations]
+					node = (nest.code.next && nest.code.next.string? && nest.code.next.val =~ /pragma species copyout/) ? nest.code.next : nest.code
+					node.insert_next(C::StringLiteral.parse(PRAGMA_DELIMITER_START+PRAGMA_SPECIES+' sync '+(sync+1).to_s+PRAGMA_DELIMITER_END))
+				end
+				
+				# Insert the post-kernel species (end of species)
+				if nest.has_species?
+					to_print = (@options[:print_arc]) ? nest.print_arc_end : nest.print_species_end
+					location = nest.code
+					location.insert_next(C::StringLiteral.parse(to_print))
+				end
+			end
+		end
+		
+		# Iterate over the loop nests and insert the memory copy annotations into
+		# the original AST.
+		def insert_copies(scop_ast)
+			@nests.each do |nest|
+				if nest.has_copyins?
+					nest.code.insert_prev(C::StringLiteral.parse(nest.print_copyins))
+				end
+				if nest.has_copyouts?
+					nest.code.insert_next(C::StringLiteral.parse(nest.print_copyouts))
+				end
+			end
+		end
+		
+	end
+	
+end
+