bones-compiler 1.1.0 → 1.3.1

data/lib/bones/copy.rb

@@ -0,0 +1,26 @@
+
+module Bones
+	
+	# Class copyin/out
+	class Copy
+		attr_accessor :name, :domain, :deadline, :direction, :id
+		
+		def initialize(name,domain,deadline,direction,id)
+			@name = name
+			@domain = domain
+			@deadline = deadline
+			@direction = direction
+			@id = id
+		end
+		
+		def get_definition(array_definition,type)
+			array_definition = '' if type == 'free' || type == 'alloc'
+			'void bones_'+type+'_'+@id+'_'+@name+'('+array_definition+');'
+		end
+		
+		def get_function_call(type)
+			'bones_'+type+'_'+@id+'_'+@name+'();'
+		end
+	end
+	
+end

data/lib/bones/engine.rb

@@ -17,13 +17,17 @@ module Bones
 		# A list of timer files to be found in the skeleton library.
 		TIMER_FILES = ['timer_1_start','timer_1_stop','timer_2_start','timer_2_stop']
 		# A list of files to be found in the common directory of the skeleton library (excluding timer files).
-		COMMON_FILES = ['prologue','epilogue','mem_prologue','mem_copy_H2D','mem_copy_D2H','mem_epilogue']
+		COMMON_FILES = ['prologue','epilogue','mem_prologue','mem_copy_H2D','mem_copy_D2H','mem_epilogue','mem_global']
 		# The name of the file containing the globals as found in the skeleton library
 		COMMON_GLOBALS = 'globals'
 		# The name of the file containing the header file for the original C code as found in the skeleton library
 		COMMON_HEADER = 'header'
 		# The name of the file containing the globals for the kernel files as found in the skeleton library
 		COMMON_GLOBALS_KERNEL = 'globals_kernel'
+		# The name of the file containing the scheduler code
+		COMMON_SCHEDULER = 'scheduler'
+		# Global timers
+		GLOBAL_TIMERS = 'timer_globals'
 		
 		# The extension of a host file in the skeleton library. See also SKELETON_DEVICE.
 		SKELETON_HOST = '.host'
@@ -54,13 +58,15 @@ module Bones
 		#             --help, -h:   Show this message
 		#
 		def initialize
-			@result = {:original_code          => [],
-			           :header_code            => [],
-			           :host_declarations      => [],
-			           :host_code_lists        => [],
-			           :algorithm_declarations => [],
-			           :algorithm_code_lists   => [],
-			           :verify_code            => []}
+			@result = {:original_code            => [],
+			           :header_code              => [],
+			           :host_declarations        => [],
+			           :host_code_lists          => [],
+			           :algorithm_declarations   => [],
+			           :algorithm_code_lists     => [],
+			           :verify_code              => [],
+			           :host_device_mem_globals  => []}
+			@state = 0
 			
 			# Provides a list of possible targets (e.g. GPU-CUDA, 'CPU-OPENCL-INTEL').
 			targets = []
@@ -86,6 +92,9 @@ module Bones
 				opt :verify,          'Verify correctness of the generated code',             :short => 'c', :default => false
 				opt :only_alg_number, 'Only generate code for the x-th species (99 -> all)',  :short => 'o', :type => Integer, :default => 99
 				opt :merge_factor,    'Thread merge factor, default is 1 (==disabled)',       :short => 'f', :type => Integer, :default => 1
+				opt :register_caching,'Enable register caching: 1:enabled (default), 0:disabled',      :short => 'r', :type => Integer, :default => 1
+				opt :zero_copy       ,'Enable OpenCL zero-copy: 1:enabled (default), 0:disabled',      :short => 'z', :type => Integer, :default => 1
+				opt :skeletons       ,'Enable non-default skeletons: 1:enabled (default), 0:disabled', :short => 's', :type => Integer, :default => 1
 			end
 			Trollop::die 'no input file supplied (use: --application)'              if !@options[:application_given]
 			Trollop::die 'no target supplied (use: --target)'                       if !@options[:target_given]
@@ -103,6 +112,12 @@ module Bones
 			# Set a prefix for functions called from the original file but defined in a host file
 			@prefix = (@options[:target] == 'GPU-CUDA') ? '' : ''
 			
+			# Setting to include the scheduler (CUDA only)
+			@scheduler = (@options[:target] == 'GPU-CUDA') ? true : false
+			
+			# Skip analyse passes for certain targets
+			@skiptarget = false #(@options[:target] == 'PAR4ALL') ? true : false
+			
 			# Set the location for the skeleton library
 			@dir = {}
 			@dir[:library] = File.join(BONES_DIR_SKELETONS,@options[:target])
@@ -125,7 +140,7 @@ module Bones
 		def process
 			
 			# Run the preprocessor
-			preprocessor = Bones::Preprocessor.new(@source,File.dirname(@options[:application]),@basename)
+			preprocessor = Bones::Preprocessor.new(@source,File.dirname(@options[:application]),@basename,@scheduler)
 			preprocessor.process
 			@result[:header_code] = preprocessor.header_code
 			@result[:device_header] = preprocessor.device_header
@@ -137,11 +152,20 @@ module Bones
 			parser.type_names << 'size_t'
 			ast = parser.parse(preprocessor.target_code)
 			ast.preprocess
+
+			# Add the scheduler's global code
+			if @scheduler
+				@result[:host_code_lists].push(File.read(File.join(@dir[:common_library],COMMON_SCHEDULER+@extension)))
+			end
 			
 			# Set the algorithm's skeleton and generate the global code
 			one_time = true
 			preprocessor.algorithms.each_with_index do |algorithm,algorithm_number|
 				algorithm.species.set_skeleton(File.join(@dir[:library],SKELETON_FILE))
+				if @options[:skeletons] == 0
+					algorithm.species.skeleton_name = 'default'
+					algorithm.species.settings.gsub!('10','00').gsub!('20','00').gsub!('30','00')
+				end
 				if algorithm.species.skeleton_name && one_time
 					@result[:host_code_lists].push(File.read(File.join(@dir[:common_library],COMMON_GLOBALS+@extension)))
 					@result[:algorithm_code_lists].push(File.read(File.join(@dir[:common_library],COMMON_GLOBALS_KERNEL+@extension)))
@@ -149,24 +173,60 @@ module Bones
 				end
 			end
 			
-			# Perform code generation
+			# Perform code generation (per-species code)
 			@result[:original_code] = ast
+			arrays = []
 			preprocessor.algorithms.each_with_index do |algorithm,algorithm_number|
 				if @options[:only_alg_number] == 99 || algorithm_number == [@options[:only_alg_number],preprocessor.algorithms.length-1].min
 					puts MESSAGE+'Starting code generation for algorithm "'+algorithm.name+'"'
 					if algorithm.species.skeleton_name
 						algorithm.merge_factor = @options[:merge_factor] if (@options[:target] == 'GPU-CUDA')
+						algorithm.register_caching_enabled = @options[:register_caching]
 						algorithm.set_function(ast)
-						algorithm.populate_variables(ast,preprocessor.defines)
+						algorithm.populate_variables(ast,preprocessor.defines) if !@skiptarget
 						algorithm.populate_lists()
-						algorithm.populate_hash()
+						algorithm.populate_hash() if !@skiptarget
 						generate(algorithm)
 						puts MESSAGE+'Code generated using the "'+algorithm.species.skeleton_name+'" skeleton'
+						arrays.concat(algorithm.arrays)
 					else
 						puts WARNING+'Skeleton "'+algorithm.species.name+'" not available'
 					end
 				end
 			end
+			
+			# Only if the scheduler is included
+			if @scheduler
+			
+				# Perform code generation (sync statements)
+				@result[:host_declarations].push('void bones_synchronize(int bones_task_id);')
+				
+				# Perform code generation (memory allocs)
+				allocs = []
+				preprocessor.copies.each do |copy|
+					if !allocs.include?(copy.name)
+						generate_memory('alloc',copy,arrays,0)
+						allocs << copy.name
+					end
+				end
+				
+				# Perform code generation (memory copies)
+				preprocessor.copies.each_with_index do |copy,index|
+					#puts MESSAGE+'Generating copy code for array "'+copy.name+'"'
+					generate_memory('copy',copy,arrays,index)
+				end
+				
+				# Perform code generation (memory frees)
+				frees = []
+				preprocessor.copies.each do |copy|
+					if !frees.include?(copy.name)
+						generate_memory('free',copy,arrays,0)
+						frees << copy.name
+					end
+				end
+			
+			end
+			
 		end
 
 		# This method writes the output code to files. It creates
@@ -202,7 +262,7 @@ module Bones
 				end
 			end
 			
-			# Populate the verification file4
+			# Populate the verification file
 			if @options[:verify]
 				File.open(File.join(directory,@options[:name]+OUTPUT_VERIFICATION+@extension),'w') do |verification|
 					verification.puts @result[:header_code]
@@ -212,15 +272,22 @@ module Bones
 				end
 			end
 			
-			# Populate the target file
+			# Populate the target file (host)
 			File.open(File.join(directory,@options[:name]+OUTPUT_HOST+@extension),'w') do |target|
+				target.puts '#include <cuda_runtime.h>'+NL if @options[:target] == 'GPU-CUDA'
+				target.puts "#define ZEROCOPY 0"+NL if @options[:zero_copy] == 0 && @options[:target] == 'CPU-OPENCL-INTEL'
+				target.puts "#define ZEROCOPY 1"+NL if @options[:zero_copy] == 1 && @options[:target] == 'CPU-OPENCL-INTEL'
 				target.puts @result[:header_code]
-				target.puts @result[:algorithm_declarations]
 				target.puts
+				target.puts @result[:host_device_mem_globals]
+				target.puts
+				target.puts @result[:algorithm_declarations]
 				target.puts @result[:host_code_lists]
+				target.puts
+				target.puts File.read(File.join(@dir[:common_library],GLOBAL_TIMERS+@extension))
 			end
 			
-			# Populate the algorithm file
+			# Populate the algorithm file (device)
 			File.open(File.join(directory,@options[:name]+OUTPUT_DEVICE+@algorithm_extension),'w') do |algorithm|
 				algorithm.puts @result[:device_header]
 				algorithm.puts @result[:algorithm_code_lists]
@@ -251,7 +318,7 @@ module Bones
 			             :device => File.read(file_name_device+@algorithm_extension)}
 			
 			# Perform the transformations on the algorithm's code
-			algorithm.perform_transformations(algorithm.species.settings)
+			algorithm.perform_transformations(algorithm.species.settings) if !@skiptarget
 			
 			# Load the common skeletons from the skeleton library
 			COMMON_FILES.each do |skeleton|
@@ -291,13 +358,19 @@ module Bones
 				minihash = { :array               => array.name,
 				             :type                => array.type_name,
 				             :flatten             => array.flatten,
-				             :variable_dimensions => array.size.join('*')}
+				             :variable_dimensions => array.size.join('*'),
+				             :state               => @state.to_s}
+				@state += 1
 				
 				# Apply the mini-search-and-replace hash to create the memory allocations, memory copies (if input only), etc.
 				processed[:mem_prologue] += search_and_replace(minihash,skeletons[:mem_prologue])
 				processed[:mem_copy_H2D] += search_and_replace(minihash,skeletons[:mem_copy_H2D]) if array.input? || array.species.shared?
 				processed[:mem_epilogue] += search_and_replace(minihash,skeletons[:mem_epilogue])
+			
+				# Add the device declarations
+				@result[:host_device_mem_globals].push(search_and_replace(minihash,skeletons[:mem_global]))
 			end
+			
 			# Iterate over all the array variables and create a mini-search-and-replace hash for each array (output arrays)
 			algorithm.arrays.select(OUTPUT).each_with_index do |array, num_array|
 				hash = algorithm.hash["out#{num_array}".to_sym]
@@ -305,7 +378,9 @@ module Bones
 				             :type                => array.type_name,
 				             :flatten             => array.flatten,
 				             :offset              => '('+hash[:dimension0][:from]+')',
-				             :variable_dimensions => '('+hash[:dimensions]+')'}
+				             :variable_dimensions => '('+hash[:dimensions]+')',
+				             :state               => @state.to_s}
+				@state += 1
 				
 				# Perform selective copy for arrays with 2 dimensions (uses a for-loop over the memory copies)
 				if array.dimensions == 2 && @options[:target] == 'GPU-CUDA' && false
@@ -346,11 +421,17 @@ module Bones
 			search_and_replace!(algorithm.hash,skeletons[:epilogue])
 			
 			# Construct the final host function, inluding the timers and memory copies
-			host = skeletons[:prologue     ] + skeletons[:timer_1_start] +
-			       processed[:mem_prologue ] + processed[:mem_copy_H2D ] +
-			       skeletons[:timer_2_start] + skeletons[:host         ] + skeletons[:timer_2_stop ] +
-			       processed[:mem_copy_D2H ] + processed[:mem_epilogue ] +
-			       skeletons[:timer_1_stop ] + skeletons[:epilogue     ]
+			if @scheduler
+				host = skeletons[:prologue     ] + 
+				       skeletons[:timer_2_start] + skeletons[:host         ] + skeletons[:timer_2_stop ] +
+				       skeletons[:epilogue     ]
+			else
+				host = skeletons[:prologue     ] + 
+				       skeletons[:timer_1_start] + processed[:mem_prologue ] + processed[:mem_copy_H2D ] +
+				       skeletons[:timer_2_start] + skeletons[:host         ] + skeletons[:timer_2_stop ] +
+				       processed[:mem_copy_D2H ] + processed[:mem_epilogue ] + skeletons[:timer_1_stop ] + 
+				       skeletons[:epilogue     ]
+			end
 			
 			# Generate code to replace the original code, including verification code if specified by the option flag
 			verify_skeleton = File.read(File.join(@dir[:verify_library],'verify_results.c'))
@@ -362,24 +443,59 @@ module Bones
 			# Add a performance model to the original code
 			#replacement_code.insert(0,algorithm.performance_model_code('model'))
 			
-			# Replace mallocs and frees in the original code with aligned memory allocations (only for CPU-OpenCL targets)
-			if @options[:target] == 'CPU-OPENCL-INTEL'
-				@result[:original_code].seach_and_replace_function_call(C::Variable.parse('malloc'),C::Variable.parse(VARIABLE_PREFIX+'malloc_128'))
-				@result[:original_code].seach_and_replace_function_call(C::Variable.parse('free'),C::Variable.parse(VARIABLE_PREFIX+'free_128'))
+			# Replace mallocs and frees in the original code with aligned memory allocations (only for CPU-OpenCL targets with zero-copy)
+			if @options[:zero_copy] == 1 && @options[:target] == 'CPU-OPENCL-INTEL'
+				@result[:original_code].search_and_replace_function_call(C::Variable.parse('malloc'),C::Variable.parse(VARIABLE_PREFIX+'malloc_128'))
+				@result[:original_code].search_and_replace_function_call(C::Variable.parse('free'),C::Variable.parse(VARIABLE_PREFIX+'free_128'))
 			end
 			
 			# Give the original main function a new name
-			@result[:original_code].seach_and_replace_function_definition('main',VARIABLE_PREFIX+'main')
+			@result[:original_code].search_and_replace_function_definition('main',VARIABLE_PREFIX+'main')
 			
 			# Replace the original code with a function call to the newly generated code
-			@result[:original_code].seach_and_replace_node(algorithm.code,replacement_code)
+			@result[:original_code].search_and_replace_node(algorithm.code,replacement_code)
 			
 			# The host code is generated, push the data to the output hashes
 			accelerated_definition = 'void '+algorithm.name+'_accelerated('+algorithm.lists[:host_definition]+')'
-			@result[:host_code_lists].push(@prefix+accelerated_definition+' {'+NL+host+NL+'}')
+			@result[:host_code_lists].push(@prefix+accelerated_definition+' {'+NL+host+NL+'}'+NL+NL)
 			@result[:host_declarations].push(@prefix+accelerated_definition+';'+NL+@prefix+original_definition+';')
 		end
 		
+		
+		def generate_memory(type,copy,arrays,index)
+			
+			# Find the corresponding array
+			arrays.each do |array|
+				if array.name == copy.name && (array.direction == copy.direction || array.direction == INOUT)
+					
+					# Load the skeleton from the skeleton library
+					type += copy.direction if type == 'copy'
+					skeleton = File.read(File.join(@dir[:common_library],'mem_async_'+type+@extension))
+					
+					# Create the find-and-replace hash
+					minihash = { :array               => copy.name,
+					             :id                  => copy.id,
+					             :index               => index.to_s,
+					             :direction           => copy.direction,
+					             :definition          => array.definition,
+					             :type                => array.type_name,
+					             :flatten             => array.flatten,
+					             :offset              => '0',
+					             :variable_dimensions => array.size.join('*'),
+					             :state               => copy.deadline}
+					
+					# Instanstiate the skeleton and add it to the final result
+					@result[:host_code_lists].push(search_and_replace(minihash,skeleton))
+					
+					# Add a forward declaration of this function
+					@result[:host_declarations].push(copy.get_definition(array.definition,type))
+					
+					# Done
+					return
+				end
+			end
+		end
+		
 	end
 	
 end

data/lib/bones/preprocessor.rb

@@ -9,7 +9,7 @@ module Bones
 	# * +algorithms+ -  An array of identified algorithms, each of class Bones::Algorithm.
 	# * +target_code+ - The processed code containing no Bones directives nor other pre-processor directives (such as includes and defines).
 	class Preprocessor < Common
-		attr_reader :header_code, :algorithms, :target_code, :device_header, :defines
+		attr_reader :header_code, :algorithms, :target_code, :device_header, :defines, :scop, :copies
 		
 		# Denotes the start of an algorithmic species.
 		IDENTIFIER = '#pragma species'
@@ -18,9 +18,22 @@ module Bones
 		WHITESPACE = '\s*'
 		
 		# This directive denotes the start of a algorithm. It is based on the IDENTIFIER constant.
-		PRIMITIVE_START = IDENTIFIER+' kernel'
+		SPECIES_START = IDENTIFIER+' kernel'
 		# This directive denotes the end of a algorithm. It is based on the IDENTIFIER constant.
-		PRIMITIVE_END = IDENTIFIER+' endkernel'
+		SPECIES_END = IDENTIFIER+' endkernel'
+	
+		# Start of the scop
+		SCOP_START = '#pragma scop'
+		# Enf of the scop
+		SCOP_END = '#pragma endscop'
+		
+		# Synchronise directive.
+		SYNC = IDENTIFIER+' sync'
+		
+		# Copy in directive.
+		COPYIN = IDENTIFIER+ ' copyin'
+		# Copy out directive.
+		COPYOUT = IDENTIFIER+ ' copyout'
 		
 		# A regular expression captures a prefix in a algorithm (e.g. unordered/multiple).
 		REGEXP_PREFIX = /^[a-z]+ /
@@ -31,16 +44,18 @@ module Bones
 		# 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,directory,filename)
+		def initialize(source_code,directory,filename,scheduler)
 			@source_code = source_code
-			@target_code = ''
+			@target_code = []
 			@header_code = ''
 			@device_header = ''
 			@directory = directory
 			@filename = filename
 			@algorithms = Array.new
+			@copies = Array.new
 			@defines = {}
 			@found_algorithms = 0
+			@scheduler = scheduler
 		end
 		
 		# This is the method to perform the actual preprocessing.
@@ -51,6 +66,7 @@ module Bones
 			algorithm_code = ''
 			species = nil
 			found = 0
+			alloc_index, free_index = 0, 0
 			
 			# Process the file line by line
 			@source_code.each_line.with_index do |line,index|
@@ -71,7 +87,7 @@ module Bones
 						@defines[match.first[0].to_sym] = match.first[1]
 					
 					# Found the start of algorithm marker
-					elsif line =~ /^#{WHITESPACE}#{PRIMITIVE_START}/
+					elsif line =~ /^#{WHITESPACE}#{SPECIES_START}/
 						if found == 0
 							line = replace_defines(line,@defines)
 							prefix, input, output = marker_to_algorithm(line)
@@ -80,28 +96,92 @@ module Bones
 							@found_algorithms = @found_algorithms + 1
 						end
 						found = found + 1
+						#@target_code << "int bones_temp_species_start = '#{line.gsub(NL,'')}';"+NL
 					
 					# Found the end of algorithm marker
-					elsif line =~ /^#{WHITESPACE}#{PRIMITIVE_END}/
+					elsif line =~ /^#{WHITESPACE}#{SPECIES_END}/
 						if found == 1
-							name = line.strip.scan(/^#{WHITESPACE}#{PRIMITIVE_END} (.+)/).join
+							name = line.strip.scan(/^#{WHITESPACE}#{SPECIES_END} (.+)/).join
 							name = DEFAULT_NAME if name == ''
 							@algorithms.push(Bones::Algorithm.new(name,@filename,index.to_s,species,algorithm_code))
 							algorithm_code = ''
 						end
 						found = found - 1
+						#@target_code << "int bones_temp_species_end = '#{line.gsub(NL,'')}';"+NL
+						
+					# Found a sync marker
+					elsif @scheduler && line =~ /^#{WHITESPACE}#{SYNC}/
+						sync = line.strip.scan(/^#{WHITESPACE}#{SYNC} (.+)/).join
+						@target_code << "bones_synchronize(#{sync});"+NL
+						
+					# Found a copyin marker
+					elsif @scheduler && line =~ /^#{WHITESPACE}#{COPYIN}/
+						copies = line.strip.scan(/^#{WHITESPACE}#{COPYIN} (.+)/).join.split(WEDGE).map{ |c| c.strip }
+						copies.each_with_index do |copy,copynum|
+							name = copy.split('[').first
+							domain = copy.scan(/\[(.+)\]/).join.split(DIM_SEP)
+							deadline = copy.split('|').last
+							@copies.push(Bones::Copy.new(name,domain,deadline,'in',"#{index*100+copynum}"))
+							@target_code << "bones_copyin_#{index*100+copynum}_#{name}(#{name});"+NL
+						end
+						
+					# Found a copyout marker
+					elsif @scheduler && line =~ /^#{WHITESPACE}#{COPYOUT}/
+						copies = line.strip.scan(/^#{WHITESPACE}#{COPYOUT} (.+)/).join.split(WEDGE).map{ |c| c.strip }
+						copies.each_with_index do |copy,copynum|
+							name = copy.split('[').first
+							domain = copy.scan(/\[(.+)\]/).join.split(DIM_SEP)
+							deadline = copy.split('|').last
+							@copies.push(Bones::Copy.new(name,domain,deadline,'out',"#{index*100+copynum}"))
+							@target_code << "bones_copyout_#{index*100+copynum}_#{name}(#{name});"+NL
+						end
+					end
+					
+					# Check if it was a 'pragma scop' / 'pragma endscop' line
+					if line =~ /^#{WHITESPACE}#{SCOP_START}/
+						alloc_index = index
+					elsif line =~ /^#{WHITESPACE}#{SCOP_END}/
+						free_index = @target_code.length
 					end
+					
 				else
 					if found > 0
 						algorithm_line = replace_defines(line,@defines)
-						@target_code += algorithm_line
+						@target_code << algorithm_line
 						algorithm_code += algorithm_line if line !~ /^#{WHITESPACE}#/
 					else
-						@target_code += line
+						@target_code << line
 					end
 				end
 			end
-			puts WARNING+'Begin/end kernel mismatch ('+@found_algorithms.to_s+' versus '+@algorithms.length.to_s+'), probably missing a "'+PRIMITIVE_END+'"' unless @algorithms.length == @found_algorithms
+			puts WARNING+'Begin/end kernel mismatch ('+@found_algorithms.to_s+' versus '+@algorithms.length.to_s+'), probably missing a "'+SPECIES_END+'"' unless @algorithms.length == @found_algorithms
+			
+			# Add frees and mallocs
+			if @scheduler
+				alloc_code, free_code = '', ''
+				included_copies = []
+				copies.each do |copy|
+					if !included_copies.include?(copy.name)
+						alloc_code += copy.get_function_call('alloc')+NL
+						free_code += copy.get_function_call('free')+NL
+						included_copies << copy.name
+					end
+				end
+			end
+			
+			# Add timers (whole scop timing) and frees/mallocs to the code
+			offset = @header_code.lines.count
+			@target_code.insert(alloc_index-offset, 'bones_timer_start();'+NL)
+			if @scheduler
+				@target_code.insert(alloc_index-offset+1, alloc_code)
+				@target_code.insert(free_index+2, free_code)
+				@target_code.insert(free_index+3, 'bones_timer_stop();'+NL)
+			else
+				@target_code.insert(free_index+2, 'bones_timer_stop();'+NL)
+			end
+			
+			# Join the array
+			@target_code = @target_code.join('')
 		end
 		
 		# This is the method to preprocess a header file. Currently,
@@ -143,7 +223,7 @@ module Bones
 		
 		# Method to extract the algorithm details from a marker found in code.
 		def marker_to_algorithm(marker)
-			algorithm = marker.strip.scan(/^#{WHITESPACE}#{PRIMITIVE_START} (.+)/).join
+			algorithm = marker.strip.scan(/^#{WHITESPACE}#{SPECIES_START} (.+)/).join
 			prefix = ''
 			if algorithm =~ REGEXP_PREFIX
 				split = algorithm.partition(' ')