bones-compiler 1.1.0 → 1.3.1

data/lib/adarwin/preprocessor.rb

@@ -0,0 +1,76 @@
+
+module Adarwin
+	
+	# This is the C99 pre-processor for Adarwin. It has the following tasks:
+	# * Extract the SCoP part from the code (the region of interest)
+	# * Extract the header code (defines, includes, etc.)
+	# * Output the original code without pre-processor directives
+	# * Output the original code minus the SCoP (SCoP to be filled in later)
+	class Preprocessor < Common
+		attr_reader :source_code, :header_code, :parsed_code, :scop_code, :target_code
+		
+		# Regular expression to identify whitespaces (tabs, spaces).
+		WHITESPACE = '\s*'
+		
+		# This is the method which initializes the preprocessor. Initialization
+		# requires the target source code to process, which is then set as the class
+		# variable +@source_code+.
+		def initialize(source_code)
+			@source_code = source_code
+			@header_code = ''
+			@parsed_code = ''
+			@target_code = ''
+			@scop_code = ''
+		end
+		
+		# This is the method to perform the actual preprocessing. This method takes
+		# care of all the pre-processor tasks. The output is stored in the two
+		# attributes +header_code+, and +scop+.
+		# FIXME: What about multi-line statements? For example, a multi-line comment
+		# could have a commented-out SCoP or define or include.
+		def process
+			scop = false
+			scop_in_code = false
+			
+			# Process the file line by line
+			@source_code.each_line.with_index do |line,index|
+				if line =~ /^#{WHITESPACE}#/
+					
+					# Keep 'include' statements as header code
+					if line =~ /^#{WHITESPACE}#include/
+						@header_code += line
+						@target_code += line
+					
+					# Process 'define' statements
+					elsif line =~ /^#{WHITESPACE}#define/
+						@header_code += line
+						@target_code += line
+					
+					# Found the start of a SCoP
+					elsif line =~ /^#{WHITESPACE}#{SCOP_START}/
+						scop = true
+						scop_in_code = true
+						@parsed_code += '{'+NL
+						
+					# Found the end of a SCoP
+					elsif line =~ /^#{WHITESPACE}#{SCOP_END}/
+						scop = false
+						@parsed_code += '}'+NL
+					end
+					
+				# Nothing special in the code going on here
+				else
+					@scop_code += line if scop
+					@parsed_code += line
+					@target_code += line
+				end
+			end
+			
+			# Exit if there is no SCoP found
+			if !scop_in_code
+				raise_error('No "#pragma scop" found in the source code')
+			end
+		end
+	end
+end
+

data/lib/adarwin/reference.rb

@@ -0,0 +1,261 @@
+
+module Adarwin
+	
+	# This class represents an array reference characterisation. This reference is
+	# constructed as a 5-tuple (tN,tA,tD,tE,tS) with the following information:
+	# * tN: The name of the reference.
+	# * tA: The access direction (read or write).
+	# * tD: The full domain accessed.
+	# * tE: The number of elements accessed each iteration (the size).
+	# * tS: The step of a accesses among iterations.
+	# To be able to compute the 5-tuple, the reference also stores information
+	# about the loops and conditional statements to which the original array
+	# reference is subjected.
+	#
+	# This class contains methods to perform among others the following:
+	# * Initialise the class and sets the 5-tuple (N,A,D,E,S)
+	# * Retrieve information on array indices
+	# * Print in different forms (species, ARC, copy/sync pragma's)
+	class Reference
+		attr_accessor :tN, :tA, :tD, :tE, :tS
+		attr_accessor :bounds, :indices, :pattern, :id
+		attr_accessor :all_loops
+		
+		# This method initialises the array reference class. It takes details of the
+		# reference itself and details of the loop nest it belongs to. The method
+		# performs among others the following:
+		# * It initialises the 5-tuple (N,A,D,E,S)
+		# * It constructs the sets of loops (all,inner,outer) for this reference
+		# * It computes the bounds based on loop data and on if-statements
+		# * It computes the domain (D), number of elements (E), and step (S)
+		def initialize(reference,id,inner_loops,outer_loops,verbose)
+			@id = id
+			
+			# Initialise the 5-tuple (already fill in N and A)
+			@tN = reference[:name]
+			@tA = reference[:type]
+			@tD = []
+			@tE = []
+			@tS = []
+			
+			# Set the inner loops as the loop nest's inner loop intersected with all
+			# loops found for this statement. Beware of the difference between loops
+			# of a loop nest and loops of a statement.
+			@all_loops = reference[:loop_data]
+			@inner_loops = inner_loops & @all_loops
+			@outer_loops = outer_loops
+			
+			# Set the indices of the array reference (e.g. 2*i+4). The size of this
+			# array is equal to the number of dimensions of the array.
+			@indices = reference[:indices]
+			
+			# Set the if-statements for the reference. Process them together with the
+			# loop start/end conditions to obtain a final set of conditions/bounds.
+			@bounds = []
+			loop_vars = @all_loops.map{ |l| l[:var]}
+			@all_loops.each do |loop_data|
+				conditions = [loop_data[:min],loop_data[:max]]
+				reference[:if_statements].each do |if_statement|
+					condition_if = if_statement.map{ |c| solve(c,loop_data[:var],loop_vars) }
+					conditions = [
+						max(conditions[0],condition_if[0]),
+						min(conditions[1],condition_if[1])
+					]
+				end
+				@bounds << { :var => loop_data[:var], :min => conditions[0], :max => conditions[1] }
+			end
+			
+			# Compute the domain (D) based on the bounds. The bounds are derived from
+			# the if-statements and for-loops.
+			@tD = @indices.map do |i|
+				index_to_interval(i,@bounds)
+			end
+			
+			# Compute the number of elements (E) accessed every iteration (the size).
+			# TODO: Clean-up this method.
+			@tE = @indices.map do |i|
+				#if !dependent?(i,@all_loops)
+				#	puts "independent"
+				#	index_to_interval(i,@inner_loops)
+				#else
+					#puts "dependent"
+					get_base_offset(i)
+				#end
+			end
+			
+			# Compute the step taken. There are 3 cases considered the index is: 1)
+			# dependent on the outer loops, 2) dependent on the inner loops, or 3)
+			# indepdent of any loops.
+			@tS = @indices.map do |i|
+				if dependent?(i,@inner_loops)
+					index_to_interval(i,@inner_loops).length
+				elsif dependent?(i,@outer_loops)
+					get_step(i,@outer_loops)
+				else
+					'0'
+				end
+			end
+			
+			# If the step and the domain are equal in size, the step can also be set
+			# to zero to reflect accessing the full array.
+			@tS.each_with_index do |tS,index|
+				if (tS == @tD[index].length) || (@tD[index].length == '1')
+					@tS[index] = '0'
+				end
+			end
+			
+			# Print the result
+			puts MESSAGE+"Found: #{to_arc}" if verbose
+		end
+		
+		# This method replaces loop variables for a given set of loops with 0. This
+		# basically gives us the offset of array references with respect to the loop
+		# variable. For example, A[2*i+4] and A[i+j+3] will give us [4,j+3] with
+		# repsect to an i-loop.
+		def get_base_offset(index)
+			index = index.clone
+			@outer_loops.each do |for_loop|
+				search = C::Variable.parse(for_loop[:var])
+				replace = C::Expression.parse('0')
+				index = index.search_and_replace_node(search,replace)
+			end
+			return index_to_interval(index,@inner_loops)
+		end
+		
+		# Method to fill in the ranges for an array reference. This is based on
+		# information of the loop nests. The output is an interval.
+		def index_to_interval(index,loops)
+			access_min = find_extreme(:min,index,loops)
+			access_max = find_extreme(:max,index,loops)
+			return Interval.new(access_min,access_max,@all_loops)
+		end
+		
+		# Substitute loop data with the upper-bound or lower-bound of a loop to find
+		# the minimum/maximum of an array reference. The body is executed twice,
+		# because a loop bound can be based on another loop variable.
+		def find_extreme(position,index,loops)
+			index = index.clone
+			2.times do
+				loops.each do |for_loop|
+					search = C::Variable.parse(for_loop[:var])
+					replace = C::Expression.parse(for_loop[position])
+					index = index.search_and_replace_node(search,replace)
+				end
+			end
+			return simplify(index.to_s.gsub(';','').gsub(' ','').gsub("\t",''))
+		end
+		
+		# Method to check whether the an index is dependent on a given set of loops.
+		# For example, A[i+3] is independent of j, but dependent on i.
+		def dependent?(index,loops)
+			index.preorder do |node|
+				if node.variable?
+					loops.each do |for_loop|
+						return true if (node.name == for_loop[:var])
+					end
+				end
+			end
+			return false
+		end
+		
+		# Method to retrieve the step for a given array index and loops. The method
+		# returns the difference between two subsequent iterations: one with the
+		# loop variable at 0 and one after the first increment.
+		def get_step(index,loops)
+			
+			# Replace the loop indices with 0
+			index1 = index.clone
+			loops.each do |for_loop|
+				search = C::Variable.parse(for_loop[:var])
+				replace = C::Expression.parse('0')
+				index1 = index1.search_and_replace_node(search,replace)
+			end
+			
+			# Replace the loop indices with the loop step
+			index2 = index.clone
+			loops.each do |for_loop|
+				search = C::Variable.parse(for_loop[:var])
+				replace = C::Expression.parse(for_loop[:step])
+				index2 = index2.search_and_replace_node(search,replace)
+			end
+			
+			# Return the difference
+			return abs(simplify("(#{index2})-(#{index1})"))
+		end
+		
+		# Method to output the result as algorithmic species. This reflects the
+		# algorithm as presented in the scientific paper.
+		def to_species
+			if @tS.reject{ |s| s == "0"}.empty?
+				if (@tA == 'read') # Full (steps length 0 and read)
+					@pattern = 'full'
+				else # Shared (steps length 0 and write)
+					@pattern = 'shared'
+				end
+			elsif @tE.reject{ |s| s.length == "1"}.empty? # Element (sizes length 1)
+				@pattern = 'element'
+			elsif step_smaller_than_num_elements? # Neighbourhood (tS < tE)
+				@pattern = 'neighbourhood('+@tE.join(DIM_SEP)+')'
+			else # Chunk (tS >= tE)
+				@pattern = 'chunk('+@tE.join(DIM_SEP)+')'
+			end
+			
+			# Fill in the name and the domain and return the result
+			return @tN+'['+@tD.join(DIM_SEP)+']'+PIPE+@pattern
+		end
+		
+		# Method to output the result as an array reference characterisation (ARC).
+		def to_arc
+			return "(#{tN},#{tA},#{tD},#{tE},#{tS})".gsub('"','').gsub(' ','')
+		end
+		
+		# Method to output a copyin/copyout statement. This indicates the name (N),
+		# the domain (D), and a unique identifier.
+		def to_copy(id)
+			@tN+'['+@tD.join(DIM_SEP)+']'+'|'+id.to_s
+		end
+		
+		# Method to print the unique identifier of the loop nest in terms of
+		# synchronisation statements to be printed. This is a per-reference id
+		# instead of a per-loop id, because it depends on the type of access (read
+		# or write).
+		def get_sync_id
+			(@tA == 'write') ? 2*@id+1 : 2*@id
+		end
+		
+		# Helper method for the +to_species+ method. This method compares the step
+		# with the number of elements accessed to determine which one is smaller.
+		# FIXME: This is based on the +compare+ method which might take a guess.
+		def step_smaller_than_num_elements?
+			@tS.each_with_index do |step,index|
+				if step != '0'
+					comparison = compare(step,@tE[index].length,@all_loops)
+					if (comparison == 'lt')
+						return true
+					end
+				end
+			end
+			return false
+		end
+		
+		# Method to print out a human readable form of the array references (e.g.
+		# [4*i+6][j]). This is basically what the +puts+ method also does.
+		def get_references
+			return @indices.to_ary.map{ |i| i.to_s }
+		end
+		
+		# Method to find out if the reference is dependent on a variable. It is
+		# used by the copy optimisations.
+		def depends_on?(var)
+			@indices.each do |index|
+				index.preorder do |node|
+					if node.variable?
+						return true if (node.name == var)
+					end
+				end
+			end
+			return false
+		end
+		
+	end
+end

data/lib/bones.rb

@@ -1,10 +1,6 @@
 
-# Bones requires 'fileutils' from the Ruby standard library.
-require 'fileutils'
-
-# Bones uses the 'trollop' gem to parse command line options.
-require 'rubygems'
-require 'trollop'
+# Include the common part between Bones and Aset
+require 'common.rb'
 
 # We define a custom error class for code generation related
 # errors (any error raised by Bones).
@@ -16,20 +12,9 @@ def raise_error(message) #:nodoc:
 end
 
 # Extending the Ruby standard string class to support some
-# addition methods. They include a hack of the gsub! command,
-# and two methods related to comma removal.
+# additional methods: two methods related to comma removal.
 class String #:nodoc:
 	
-	# Extend the Ruby string class to be able to chain 'gsub!'
-	#-commands. This code is taken from the web.
-	meth = 'gsub!'
-	orig_meth = "orig_#{meth}"
-	alias_method orig_meth, meth
-	define_method(meth) do |*args|
-		self.send(orig_meth, *args)
-		self
-	end
-	
 	# Replace double comma's in a string with a single comma.
 	# This method is useful for function-argument lists.
 	def remove_double_commas
@@ -213,43 +198,6 @@ module Bones
 			return code
 		end
 		
-		# Helper method to evaluate mathematical expressions, possibly containing
-		# symbols. This method is only used for readability, without it the code
-		# is functionally correct, but expressions might be larger than needed.
-		# This method is only tested on integers.
-		def simplify(expr)
-			raise_error('Invalid expression to simplify') if !expr
-			done = false
-			while !done do
-				old_expr = expr
-				case expr
-					when /^\(([^\(\)]*)\)$/           then expr = $1                                   # Remove outer brackets
-					when /(.*)\((-?\w*)\)(.*)/        then expr = $1+$2+$3                             # Remove brackets with one constant or variable inside
-					when /(.*)\(\(([^\(\)]*)\)\)(.*)/ then expr = $1+'('+$2+')'+$3                     # Substitute double brackets into single brackets
-					when /(.*)(\-\d+)\*(\d+)\b(.*)/   then expr = $1+'+'+(($2.to_i)*($3.to_i)).to_s+$4 # Perform multiplications on constants (starting with a '-')
-					when /(.*)(\-\d+)\+(\d+)\b(.*)/   then expr = $1+'+'+(($2.to_i)+($3.to_i)).to_s+$4 # Perform additions on constants (starting with a '-')
-					when /(.*)(\-\d+)\-(\d+)\b(.*)/   then expr = $1+'+'+(($2.to_i)-($3.to_i)).to_s+$4 # Perform subtractions on constants (starting with a '-')
-					when /(.*)\b(\d+)\*(\d+)\b(.*)/   then expr = $1+(($2.to_i)*($3.to_i)).to_s+$4     # Perform multiplications on constants
-					when /(.*)\b(\d+)\+(\d+)\b(.*)/   then expr = $1+(($2.to_i)+($3.to_i)).to_s+$4     # Perform additions on constants
-					when /(.*)\b(\d+)\-(\d+)\b(.*)/   then expr = $1+(($2.to_i)-($3.to_i)).to_s+$4     # Perform subtractions on constants
-					when /(.*)\b(\w+)\-(\2)\b(.*)/    then expr = $1+'0'+$4                            # Perform subtractions of variables to zero (e.g. 'a-a=0')
-					when /(.*)\/1\b(.*)/              then expr = $1+$2                                # Remove divisions by 1
-					when /(.*)(\+0\b|\b0\+)(.*)/      then expr = $1+$3                                # Remove additions with 0
-					when /(.*[\+\(])\(([^\(\)\*\/\%]+)\)([\+\-\)].*)/ then expr = $1+$2+$3             # Remove brackets that are not needed (e.g. '(a+b)+c')
-				end
-				expr.gsub!(/\s/,'')                   # Remove whitespaces
-				expr.gsub!(/\-\-/,'+')                # Substitute double minusses for a plus
-				expr.gsub!(/\+\-/,'-')                # Substitute plus-minus for a minus
-				expr.gsub!(/(^|\()\+/,'')             # Remove plus signs at the start of a line or after an opening bracket
-				if expr =~ /(.*)\b(\d+)\/(\d+)\b(.*)/ # Perform divisions on constants...
-					division = ($2.to_i)/($3.to_i)      # ...but first check whether the result will be correct (integer division)
-					expr = $1+division.to_s+$4 if division*$3.to_i == $2.to_i
-				end
-				done = true if old_expr == expr
-			end
-			return expr
-		end
-		
 	end
 	
 end
@@ -261,6 +209,7 @@ require 'bones/species.rb'
 require 'bones/algorithm.rb'
 require 'bones/variablelist.rb'
 require 'bones/variable.rb'
+require 'bones/copy.rb'
 require 'bones/preprocessor.rb'
 require 'bones/engine.rb'
 

data/lib/bones/algorithm.rb

@@ -10,7 +10,7 @@ module Bones
 	# and lists of input/output array variables.
 	class Algorithm < Common
 		attr_reader :name, :species, :code, :lists, :arrays, :id, :function_name
-		attr_accessor :hash, :merge_factor
+		attr_accessor :hash, :merge_factor, :register_caching_enabled
 		
 		# Constant to set the name of the algorithm's accelerated version
 		ACCELERATED = '_accelerated'
@@ -31,14 +31,25 @@ module Bones
 			@original_name = @name+ORIGINAL
 			@accelerated_name = @name+ACCELERATED
 			@species = species
-			@code = C::Statement.parse(code).preprocess
+			begin
+				@code = C::Statement.parse(code).preprocess
+			rescue
+				@code = C::Statement.parse('{'+code+'}').preprocess
+			end
 			@hash = {}
 			@lists = {:host_name => [],:host_definition => [], :argument_name => [], :argument_definition => [], :golden_name => []}
 			@arrays = Variablelist.new()
 			@constants = Variablelist.new()
-			@merge_factor = 1
+			@merge_factor = nil
+			@register_caching_enabled = 1
 			@function_code = ''
 			@function_name = ''
+			
+			# Set the initial hash
+			@hash = {:algorithm_id        => @id,
+			         :algorithm_name      => @name,
+			         :algorithm_basename  => @basename,
+			         :algorithm_filename  => @filename}
 		end
 		
 		# This method sets the code and name for the function in
@@ -119,15 +130,17 @@ module Bones
 					new_code.transform_flatten(array)
 				end
 				
-				# Perform array substitution (conditionally do this)
-				@arrays.outputs.each do |array|
-					if array.species.element?
-						if @arrays.inputs.include?(array)
-							new_code.transform_substitution(array,true)
-						else
-							new_code.transform_substitution(array,false)
+				# Perform array substitution a.k.a. register caching (conditionally do this)
+				if @register_caching_enabled == 1
+					@arrays.outputs.each do |array|
+						if array.species.element?
+							if @arrays.inputs.include?(array)
+								new_code.transform_substitution(array,true)
+							else
+								new_code.transform_substitution(array,false)
+							end
+							extra_indent = INDENT
 						end
-						extra_indent = INDENT
 					end
 				end
 				
@@ -138,23 +151,35 @@ module Bones
 				
 				# Perform thread-merging (experimental)
 				# TODO: Solve the problem related to constants (e.g chunk/example1.c)
-				if @merge_factor == 1 && transformation[0,1] == '4'
-					@merge_factor = 4
+				if @merge_factor == nil
+					if transformation[0,1] == '4' && @hash[:parallelism].to_i >= 1024*1024
+						@merge_factor = 4
+					else
+						@merge_factor = 1
+					end
 				end
 				if @merge_factor > 1
-					puts MESSAGE+'Merging threads by a factor '+@merge_factor.to_s+'.'
-					
-					# Update the hash
-					@hash[:ids] = @hash[:ids].split(NL).map { |line|
-						C::parse(line).transform_merge_threads(@merge_factor,[GLOBAL_ID]+@constants.map{ |c| c.name }).to_s.split(NL).each_with_index.map do |id,index|
-							id.gsub(/\b#{GLOBAL_ID}\b/,"(#{GLOBAL_ID}+gridDim.x*blockDim.x*#{index})")
-						end
-					}.join(NL+INDENT*2)
-					@hash[:parallelism] = (@hash[:parallelism].to_i / @merge_factor).to_s
-					
-					# Transform the code
-					excludes = (@constants+@arrays).map { |c| c.name }
-					new_code.transform_merge_threads(@merge_factor,excludes)
+					puts @hash[:parallelism]
+					if new_code.has_conditional_statements?
+						puts MESSAGE+'Not coarsening ('+@merge_factor.to_s+'x) because of conditional statements in kernel body.'
+					# TODO: Fix this temporary hack for multiple loops with mismatching bounds
+					elsif ((@hash[:parallelism].to_i % @merge_factor) != 0) || (@hash[:parallelism].to_i == 4192256)
+						puts MESSAGE+'Not coarsening ('+@merge_factor.to_s+'x) because of mismatching amount of parallelism ('+@hash[:parallelism]+').'
+					else
+						puts MESSAGE+'Coarsening threads by a factor '+@merge_factor.to_s+'.'
+						
+						# Update the hash
+						@hash[:ids] = @hash[:ids].split(NL).map { |line|
+							C::parse(line).transform_merge_threads(@merge_factor,[GLOBAL_ID]+@constants.map{ |c| c.name }).to_s.split(NL).each_with_index.map do |id,index|
+								id.gsub(/\b#{GLOBAL_ID}\b/,"(#{GLOBAL_ID}+gridDim.x*blockDim.x*#{index})")
+							end
+						}.join(NL+INDENT*2)
+						@hash[:parallelism] = (@hash[:parallelism].to_i / @merge_factor).to_s
+						
+						# Transform the code
+						excludes = (@constants+@arrays).map { |c| c.name }
+						new_code.transform_merge_threads(@merge_factor,excludes)
+					end
 				end
 				
 				# Obtain the complexity in terms of operations for the resulting code
@@ -215,12 +240,8 @@ module Bones
 		# kernel_argument_list
 		#
 		def populate_hash
-			@hash = {:algorithm_id        => @id,
-			         :algorithm_name      => @name,
-			         :algorithm_basename  => @basename,
-			         :algorithm_filename  => @filename,
-			         :argument_name       => @lists[:argument_name],
-			         :argument_definition => @lists[:argument_definition]}
+			@hash[:argument_name] = @lists[:argument_name]
+			@hash[:argument_definition] = @lists[:argument_definition]
 			
 			# Obtain the necessary data for the hash per array
 			parallelisms = []
@@ -278,11 +299,15 @@ module Bones
 						
 						# Generate the index expressions
 						divider = (array.species.chunk?) ? '/'+sum(array.species.parameters[index]) : ''
-						minihash = {:dimensions => (index == dimensions.length-1) ? '1' : dimensions.drop(index+1).map { |d| sum(d) }.join('*'),
-						            :modulo     => (index_reverse != dimensions.length-1) ? '%('+sum(dimension)+divider+')' : '',
-						            :offset     => from(dimension)}
-						expr_global = simplify(search_and_replace(minihash,"((#{GLOBAL_ID}/(<dimensions>))<modulo>)+<offset>"))
-						expr_local  = simplify(search_and_replace(minihash,"((#{LOCAL_ID }/(<dimensions>))<modulo>)+<offset>"))
+						dimensions_hash = (index == dimensions.length-1) ? '1' : dimensions.drop(index+1).map { |d| sum(d) }.join('*')
+						dimensions_hash = simplify(dimensions_hash)
+						dimensions_division = (dimensions_hash == '1') ? '' : '/('+dimensions_hash+')'
+						minihash = {:dimensions1 => "#{GLOBAL_ID}#{dimensions_division}",
+						            :dimensions2 => "#{LOCAL_ID }#{dimensions_division}",
+						            :modulo      => (index_reverse != dimensions.length-1) ? '%('+simplify(sum(dimension)+divider)+')' : '',
+						            :offset      => simplify(from(dimension))}
+						expr_global = search_and_replace(minihash,"((<dimensions1>)<modulo>)+<offset>")
+						expr_local  = search_and_replace(minihash,"((<dimensions2>)<modulo>)+<offset>")
 						
 						# Selectively push the ID definitions to the result array
 						from = array.species.from_at(index)
@@ -342,6 +367,7 @@ module Bones
 		def update_hash(loop_variable)
 			names = @hash[:argument_name].split(', ')
 			definitions = @hash[:argument_definition].split(', ')
+			# TODO: The following two lines give problems with correlation-k4
 			names.delete(loop_variable.to_s)
 			definitions.each { |definition| definitions.delete(definition) if definition =~ /\b#{loop_variable}\b/ }
 			@hash[:argument_name] = names.join(', ')
@@ -387,10 +413,12 @@ module Bones
 						array_names = arrays.map { |a| a.name }.join('","')
 						raise_error(direction.capitalize+'put array count mismatch (expected '+species.length.to_s+', found '+arrays.length.to_s+' ["'+array_names+'"])')
 					end
-					
+
 					# Set the species for the arrays (distinguish between arrays with and without a name)
 					species.each do |structure|
-						array = arrays[0]
+						
+						# Loop over all found arrays and match it with a species
+						array = nil
 						arrays.each do |free_array|
 							if !free_array.species
 								if structure.has_arrayname?
@@ -404,8 +432,17 @@ module Bones
 								end
 							end
 						end
+						
+						# Still haven't found anything, assign the species to an array of equal name
+						if !array
+							arrays.each do |free_array|
+								array = free_array if structure.name == free_array.name
+							end
+						end
+						
+						# Process the assignment
 						array.species = structure
-						#structure.name = array.name
+						raise_error("Species of '#{array.species.name}' is mismatched with array '#{array.name}'") if array.species.name != array.name
 						
 						# Check if the array size was set, if not, it will be set to the species' size
 						if array.size.empty?