build-graph 1.0.3 → 1.0.4

data/spec/build/graph/call_stack_spec.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/env rspec
+# Copyright, 2012, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+require 'build/graph/call_stack'
+
+module Build::Graph::CallStackSpec
+	describe Build::Graph::CallStack do
+		it "should merge state" do
+			outer_state = nil
+			inner_state = nil
+			
+			subject.with(x: 10) do
+				outer_state = subject.last
+				
+				subject.with(x: 20, y: 30) do
+					inner_state = subject.last
+				end
+			end
+			
+			expect(outer_state).to include(:x)
+			expect(inner_state).to include(:x, :y)
+		end
+	end
+end

data/{lib/build/graph/error.rb → spec/build/graph/edge_spec.rb}

@@ -1,4 +1,6 @@
-# Copyright, 2014, by Samuel G. D. Williams. <http://www.codeotaku.com>
+#!/usr/bin/env rspec
+
+# Copyright, 2012, by Samuel G. D. Williams. <http://www.codeotaku.com>
 # 
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -18,21 +20,20 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-module Build
-	module Graph
-		class TransientError < StandardError
-		end
+require_relative 'process_graph'
+
+RSpec.describe Build::Graph::Edge do
+	let(:failed_task) {double(:failed? => true)}
 	
-		class CommandFailure < TransientError
-			def initialize(command, status)
-				super "Command #{command.inspect} failed with exit status #{status}!"
+	it "should fail if failed task is added" do
+		subject.traverse(failed_task)
 		
-				@command = command
-				@status = status
-			end
+		expect(subject.failed?).to be_truthy
+	end
 	
-			attr :command
-			attr :status
-		end
+	it "should fail if failed task is skipped" do
+		subject.skip!(failed_task)
+		
+		expect(subject.failed?).to be_truthy
 	end
 end

data/spec/build/graph/graph_spec.rb

@@ -25,13 +25,16 @@ module Build::Graph::GraphSpec
 	include ProcessGraph
 	
 	describe Build::Graph do
+		let(:group) {Process::Group.new}
+		
+		let(:logger) {Logger.new($stderr).tap{|logger| logger.level = Logger::DEBUG}}
+		
 		it "shouldn't update mtime" do
 			test_glob = Glob.new(__dir__, "*.rb")
 			listing_output = Paths.directory(__dir__, ["listing.txt"])
 			
 			FileUtils.rm_f listing_output.to_a
 			
-			group = Process::Group.new
 			walker = Walker.for(ProcessTask, group)
 			
 			top = ProcessNode.top do
@@ -40,13 +43,15 @@ module Build::Graph::GraphSpec
 				end
 			end
 			
-			walker.update(top)
-			group.wait
+			group.wait do
+				walker.update(top)
+			end
 			
 			first_modified_time = listing_output.first.modified_time
 			
-			walker.update(top)
-			group.wait
+			group.wait do
+				walker.update(top)
+			end
 			
 			# The output file shouldn't have been changed because already exists and the input files haven't changed either:
 			second_modified_time = listing_output.first.modified_time
@@ -60,8 +65,9 @@ module Build::Graph::GraphSpec
 			# The granularity of modification times isn't that great, so we use >= below.
 			# sleep 1
 			
-			walker.update(top)
-			group.wait
+			group.wait do
+				walker.update(top)
+			end
 			
 			expect(listing_output.first.modified_time).to be >= first_modified_time
 			
@@ -73,7 +79,6 @@ module Build::Graph::GraphSpec
 			code_glob = Glob.new(program_root, "*.cpp")
 			program_path = Path.join(program_root, "dictionary-sort")
 			
-			group = Process::Group.new
 			walker = Walker.for(ProcessTask, group)
 			
 			#FileUtils.touch(code_glob.first)
@@ -110,8 +115,9 @@ module Build::Graph::GraphSpec
 				end
 			end
 			
-			walker.update(top)
-			group.wait
+			group.wait do
+				walker.update(top)
+			end
 			
 			expect(program_path).to be_exist
 			expect(code_glob.first.modified_time).to be <= program_path.modified_time
@@ -122,48 +128,48 @@ module Build::Graph::GraphSpec
 			files = Glob.new(program_root, "*.cpp")
 			destination = Path.new(__dir__) + "tmp"
 			
-			group = Process::Group.new
 			walker = Walker.for(ProcessTask, group)
 			
-			#FileUtils.touch(code_glob.first)
-			
 			top = ProcessNode.top files do
-				fs.mkpath destination
+				mkpath destination
 				
 				inputs.each do |source_path|
 					destination_path = source_path.rebase(destination)
 					
 					process source_path, destination_path do
-						fs.install inputs.first, outputs.first
+						$stderr.puts "Copying #{inputs.first} -> #{outputs.first}"
+						install inputs.first, outputs.first
 					end
 				end
 			end
 			
-			triggered = 0
-			trashed_files = false
+			mutex = Mutex.new
+			files_deleted = false
 			
 			thread = Thread.new do
-				while triggered == 0 or trashed_files == false
-					sleep 0.1 if trashed_files
-					
-					destination.glob("*.cpp").each{|path| path.delete}
+				sleep 1
+				
+				mutex.synchronize do
+					destination.glob("*.cpp").delete
 					
-					trashed_files = true
+					files_deleted = true
 				end
 			end
 			
 			walker.run do
-				triggered += 1
-				
-				walker.update(top)
-				group.wait
+				mutex.synchronize do
+					group.wait do
+						walker.update(top)
+					end
+				end
 				
-				break if trashed_files
+				break if files_deleted
 			end
 			
 			thread.join
 			
 			expect(destination).to be_exist
+			# This line failed, may still be a race condition:
 			expect(destination.glob("*.cpp").count).to be == 2
 			
 			destination.delete

data/spec/build/graph/process_graph.rb

@@ -58,12 +58,16 @@ module ProcessGraph
 			end
 		end
 		
-		def fs
-			if wet?
-				FileUtils::Verbose
-			else
-				FileUtils::Verbose::Dry
-			end
+		def mkpath(*args)
+			return unless wet?
+			
+			FileUtils.mkpath(*args)
+		end
+		
+		def install(*args)
+			return unless wet?
+			
+			FileUtils.install(*args)
 		end
 		
 		# This function is called to finish the invocation of the task within the graph.

data/spec/build/graph/program/Benchmark.cpp

@@ -18,16 +18,16 @@ namespace Benchmark
 		gettimeofday (&t, (struct timezone*)0);
 		return ((TimeT)t.tv_sec) + ((TimeT)t.tv_usec / 1000000.0);
 	}
-    
+
 	WallTime::WallTime () {
 		this->reset();
 	}
-    
+
 	void WallTime::reset () {
 		this->_last = system_time();
 		this->_total = 0.0;
 	}
-    
+
 	TimeT WallTime::total () const {
 		TimeT current = system_time();
 		this->_total += current - this->_last;

data/spec/build/graph/program/DictionarySort.h

@@ -28,20 +28,20 @@ namespace DictionarySort
 	//const int SORT_MODE = -1;
 	// Use ParallelMergeSort with 2^n threads
 	const int SORT_MODE = 3; // = n
-    
+
 	typedef std::uint64_t IndexT;
-    
+
 	template <typename CharT, typename MapT>
 	class Dictionary {
 	public:
 		typedef std::vector<CharT> WordT;
 		typedef std::vector<WordT> WordsT;
 		typedef std::vector<IndexT> OrderT;
-        
+
 		static const int ORDERED_LT = -1;
 		static const int ORDERED_EQ = 0;
 		static const int ORDERED_GT = 1;
-        
+
 		// Compare two order vectors to determine the relative nature of lhs compared to rhs.
 		// We assume that lhs and rhs have at least one element each.
 		// ORDERED_LT => (lhs < rhs)
@@ -50,155 +50,155 @@ namespace DictionarySort
 		static int compare(const OrderT & lhs, const OrderT & rhs)
 		{
 			std::size_t offset = 0;
-            
+
 			while (offset < lhs.size() && offset < rhs.size()) {
 				if (lhs[offset] < rhs[offset])
 					return ORDERED_LT;
 				else if (lhs[offset] > rhs[offset])
 					return ORDERED_GT;
-                
+
 				offset += 1;
 			}
-            
+
 			if (lhs.size() == rhs.size())
 				return ORDERED_EQ;
-            
-			// lhs was longer, 
+
+			// lhs was longer,
 			if (offset < lhs.size())
 				return ORDERED_GT;
-            
+
 			return ORDERED_LT;
 		}
-        
+
 		static int compare(Dictionary * dictionary, const WordT & lhs, const WordT & rhs) {
 			std::size_t offset = 0;
-            
+
 			while (offset < lhs.size() && offset < rhs.size()) {
 				IndexT left_order = dictionary->_characterOrder[lhs[offset]];
 				IndexT right_order = dictionary->_characterOrder[rhs[offset]];
-                
+
 				if (left_order < right_order)
 					return ORDERED_LT;
 				else if (left_order > right_order)
 					return ORDERED_GT;
-                
+
 				offset += 1;
 			}
-            
+
 			if (lhs.size() == rhs.size())
 				return ORDERED_EQ;
-            
+
 			if (offset < lhs.size())
 				return ORDERED_GT;
-            
+
 			return ORDERED_LT;
 		}
-        
+
 	private:
 		WordT _alphabet;
-        
+
 		MapT _characterOrder;
 		//int _characterOrder[256];
 		//std::map<CharT, IndexT> _characterOrder;
-        
+
 		IndexT width;
 		IndexT characters_per_segment;
-        
+
 		// This is a light weight wrapper over WordT which caches its OrderT, an integer representation of position based on the given dictionary.
 		struct OrderedWord {
 			WordT word;
-            
+
 			// We can generate this as part of the sorting process. Because the sort is parallel, generation of word order (which is relatively expensive) is distributed across multiple processors.
 			mutable OrderT order;
-            
+
 			// The first time this function is called, it must be guaranteed from a single thread.
 			// After that, it can be called from multiple threads at the same time.
 			// The parallel merge sort algorithm guarantees this.
 			const OrderT & fetch_order(Dictionary * dictionary) const {
 				if (order.size() == 0 && word.size() > 0)
 					order = dictionary->sum(word);
-                
+
 				return order;
 			}
 		};
-        
+
 		struct CompareWordsAscending {
 			Dictionary * dictionary;
-            
+
 			CompareWordsAscending (Dictionary * _dictionary)
 				: dictionary(_dictionary)
 			{
 			}
-            
+
 			bool operator()(const WordT * a, const WordT * b) const {
 				return compare(dictionary, a, b) == ORDERED_LT;
 			}
-            
+
 			bool operator()(const OrderedWord * a, const OrderedWord * b) const {
 				return compare(a->fetch_order(dictionary), b->fetch_order(dictionary)) == ORDERED_LT;
 			}
 		};
-        
+
 		struct UnorderedWord {
 			WordT word;
 			Dictionary * dictionary;
-            
+
 			UnorderedWord(const WordT & _word, Dictionary * _dictionary)
 			: word(_word), dictionary(_dictionary) {
-                
+
 			}
-            
+
 			bool operator<(const UnorderedWord & other) const {
 				return compare(dictionary, *this, other) == ORDERED_LT;
 			}
 		};
-        
+
 	public:
 		Dictionary(WordT alphabet)
 			: _alphabet(alphabet)
 		{
 			IndexT index = 1;
-            
+
 			// Build up the character order map
 			for (typename WordT::iterator i = _alphabet.begin(); i != _alphabet.end(); ++i) {
 				_characterOrder[*i] = index;
 				index += 1;
 			}
-            
+
 			width = std::ceil(std::log(alphabet.size()) / std::log(2));
-            
+
 			// Naturally floor the result by integer division/truncation.
 			characters_per_segment = (sizeof(IndexT) * 8) / width;
 		}
-        
+
 		OrderT sum(const WordT & word) {
 			OrderT order;
 			std::size_t index = 0;
-            
+
 			while (index < word.size()) {
 				IndexT count = characters_per_segment;
 				IndexT sum = 0;
-                
+
 				while (index < word.size()) {
 					count -= 1;
-                    
+
 					sum <<= width;
 					sum += _characterOrder[word[index]];
-                    
+
 					index += 1;
-                    
+
 					if (count == 0)
 						break;
 				}
-                
+
 				// Shift along any remaining count, since we are ordering using the left most significant character.
 				sum <<= (count * width);
 				order.push_back(sum);
 			}
-            
+
 			return order;
 		}
-                
+
 		// The words will be sorted in-place.
 		template <typename ToSortT>
 		void sort (ToSortT & words, int mode = 2)
@@ -210,7 +210,7 @@ namespace DictionarySort
 			if (mode == -1) {
 				// Sort the words using built-in sorting algorithm, for comparison:
 				std::sort(words.begin(), words.end(), comparator);
-			} else {                
+			} else {
 				ParallelMergeSort::sort(words, comparator, std::size_t(mode));
 			}
 
@@ -221,7 +221,7 @@ namespace DictionarySort
 			std::cerr << "	* Processor sort time: " << sample.processor_time_total << std::endl;
 			std::cerr << "	* Approximate processor usage: " << sample.approximate_processor_usage() << std::endl;
 		}
-        
+
 		// This function can be slow due to the large amount of memory required for large datasets.
 		uint64_t sort(const WordsT & input, WordsT & output)
 		{
@@ -229,41 +229,41 @@ namespace DictionarySort
 
 			// Allocate all words in one go:
 			OrderedWord * allocation = new OrderedWord[input.size()];
-            
+
 			// Copy pointers to intermediate list which will be used for sorting:
 			OrderedWordsT words(input.size());
-            
+
 			// Calculate order vector for each word in preparation for sort.
 			for (std::size_t i = 0; i < input.size(); i += 1) {
 				words[i] = &allocation[i];
-                
+
 				words[i]->word = input[i];
-                
+
 				// We can force generation of the order cache, but performance may be reduced by about 10%.
 				//words[i]->fetch_order(this);
 			}
-            
+
 			// Change the mode from -1 for std::sort, to 0..n for ParallelMergeSort where 2^n is the number of threads to use.
 			sort(words, SORT_MODE);
-            
+
 			// Prepare container for sorted output:
 			output.reserve(input.size());
 			output.resize(0);
-            
+
 			uint64_t checksum = 1, offset = 1;
 			// Copy sorted words to output vector.
 			for (typename OrderedWordsT::iterator i = words.begin(); i != words.end(); ++i) {
 				output.push_back((*i)->word);
-                
+
 				// Compute a very simple checksum for verifying sorted order.
 				const OrderT & order = (*i)->fetch_order(this);
 				for (typename OrderT::const_iterator j = order.begin(); j != order.end(); ++j) {
 					checksum ^= *j + (offset++ % checksum);
-				}                
+				}
 			}
-            
+
 			delete[] allocation;
-            
+
 			return checksum;
 		}
 	};