build-graph 0.1.0 → 0.3.0

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

@@ -0,0 +1,133 @@
+//
+//  main.cpp
+//  DictionarySort
+//
+//  Created by Samuel Williams on 31/10/11.
+//  Copyright, 2014, by Samuel G. D. Williams. <http://www.codeotaku.com>
+//
+
+#include <iostream>
+#include <algorithm>
+
+#include "Benchmark.h"
+#include "DictionarySort.h"
+
+// Print out vectors using a simple [item0, item1, ... itemn] format.
+template <typename AnyT>
+std::ostream& operator<< (std::ostream &o, const std::vector<AnyT> & v)
+{
+	bool first = true;
+    
+	o << "[";
+	for (typename std::vector<AnyT>::const_iterator i = v.begin(); i != v.end(); ++i) {
+		if (first)
+			first = false;
+		else
+			o << ", ";
+        
+		o << *i;
+	}
+	o << "]";
+    
+	return o;
+}
+
+static void test_parallel_merge ()
+{
+	typedef std::vector<long long> ArrayT;
+	typedef std::less<long long> ComparatorT;
+	ComparatorT comparator;
+
+	const long long data[] = {
+		2, 4, 6, 8, 12,
+		1, 3, 5, 10, 11
+	};
+    
+	ArrayT a(data, data+(sizeof(data)/sizeof(*data)));
+	ArrayT b(a.size());
+    
+	ParallelMergeSort::ParallelLeftMerge<ArrayT, ComparatorT> left_merge = {a, b, comparator, 0, a.size() / 2};
+	left_merge();
+    
+	std::cout << "After Left: " << b << std::endl;
+    
+	ParallelMergeSort::ParallelRightMerge<ArrayT, ComparatorT> right_merge = {a, b, comparator, 0, a.size() / 2, a.size()};
+	right_merge();
+    
+	std::cout << "After Right: " << b << std::endl;
+}
+
+static void test_sort ()
+{
+	typedef std::vector<long long> ArrayT;
+	typedef std::less<long long> ComparatorT;
+	ComparatorT comparator;
+    
+	const long long data[] = {
+		11, 2, 4, 6, 8, 10, 12, 1, 3, 5, 7, 9, 13
+	};
+    
+	std::vector<long long> v(data, data+(sizeof(data)/sizeof(*data)));
+    
+	std::cerr << "Sorting " << v << std::endl;
+
+	ParallelMergeSort::sort(v, comparator, 0);
+    
+	std::cerr << "Sorted  " << v << std::endl;   
+}
+
+static void test_dictionary ()
+{
+	// This defines a dictionary based on ASCII characters.
+	typedef DictionarySort::Dictionary<char, DictionarySort::IndexT[256]> ASCIIDictionaryT;
+    
+	// For unicode characters, you could use something like this:
+	// typedef DictionarySort::Dictionary<uint32_t, std::map<uint32_t, DictionarySort::IndexT>> UCS32DictionaryT;
+	// Be aware that 
+    
+	std::string s = "AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz";
+	ASCIIDictionaryT::WordT alphabet(s.begin(), s.end());
+	ASCIIDictionaryT dictionary(alphabet);
+    
+	ASCIIDictionaryT::WordsT words, sorted_words;
+	const std::size_t MAX_LENGTH = 25;
+	const std::size_t MAX_COUNT = 2500000;
+	for (std::size_t i = 0; i < MAX_COUNT; i += 1) {
+		ASCIIDictionaryT::WordT word;
+		for (std::size_t j = i; (j-i) <= (i ^ (i * 21)) % MAX_LENGTH; j += 1) {
+			word.push_back(alphabet[(j ^ (j << (i % 4))) % alphabet.size()]);
+		}
+		words.push_back(word);
+	}
+        
+	std::cerr << "Sorting " << words.size() << " words..." << std::endl;
+	std::cerr << "Sort mode = " << DictionarySort::SORT_MODE << std::endl;
+	
+	if (DictionarySort::SORT_MODE > 0)
+		std::cerr << "Parallel merge thread count: " << (1 << (DictionarySort::SORT_MODE+1)) - 2 << std::endl;
+
+	const int K = 4;
+	Benchmark::WallTime t;
+	Benchmark::ProcessorTime processor_time;
+
+	uint64_t checksum;
+	for (std::size_t i = 0; i < K; i += 1) {
+		checksum = dictionary.sort(words, sorted_words);
+	}
+	Benchmark::TimeT elapsed_time = t.total() / K;
+    
+	std::cerr << "Checksum: " << checksum << " ? " << (checksum == 479465310674138860) << std::endl;
+	std::cerr << "Total Time: " << elapsed_time << std::endl;
+
+	std::cerr << "Finished." << std::endl;
+}
+
+int main (int argc, const char * argv[])
+{   
+	//test_parallel_merge();
+	//test_sort();
+	test_dictionary();
+    
+	return 0;
+}
+

data/spec/build/graph/program/main.cpp.d

@@ -0,0 +1 @@
+main.cpp.o: main.cpp Benchmark.h DictionarySort.h ParallelMergeSort.h

metadata

@@ -1,83 +1,125 @@
 --- !ruby/object:Gem::Specification
 name: build-graph
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Samuel Williams
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-25 00:00:00.000000000 Z
+date: 2014-06-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: process-group
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.1
+- !ruby/object:Gem::Dependency
+  name: build-files
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 0.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: build-makefile
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 0.1.0
 - !ruby/object:Gem::Dependency
   name: system
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rainbow
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.0.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.0.rc1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.0.rc1
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: "\tBuild::Graph is a framework for managing file-system based build processes.
@@ -89,25 +131,30 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .travis.yml
+- ".gitignore"
+- ".travis.yml"
 - Gemfile
 - README.md
 - Rakefile
 - build-graph.gemspec
-- lib/build.rb
-- lib/build/edge.rb
-- lib/build/error.rb
-- lib/build/files.rb
-- lib/build/files/monitor.rb
-- lib/build/files/state.rb
 - lib/build/graph.rb
-- lib/build/node.rb
-- lib/build/version.rb
-- lib/build/walker.rb
-- test/program/main.cpp
-- test/test_files.rb
-- test/test_graph.rb
+- lib/build/graph/controller.rb
+- lib/build/graph/edge.rb
+- lib/build/graph/error.rb
+- lib/build/graph/node.rb
+- lib/build/graph/version.rb
+- lib/build/graph/walker.rb
+- spec/build/graph/graph_spec.rb
+- spec/build/graph/program/Benchmark.cpp
+- spec/build/graph/program/Benchmark.cpp.d
+- spec/build/graph/program/Benchmark.cpp.o
+- spec/build/graph/program/Benchmark.h
+- spec/build/graph/program/DictionarySort.h
+- spec/build/graph/program/ParallelMergeSort.h
+- spec/build/graph/program/dictionary-sort
+- spec/build/graph/program/main.cpp
+- spec/build/graph/program/main.cpp.d
+- spec/build/graph/program/main.cpp.o
 homepage: ''
 licenses:
 - MIT
@@ -118,22 +165,30 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Build::Graph is a framework for build systems, with specific functionality
   for dealing with file based processes.
 test_files:
-- test/program/main.cpp
-- test/test_files.rb
-- test/test_graph.rb
+- spec/build/graph/graph_spec.rb
+- spec/build/graph/program/Benchmark.cpp
+- spec/build/graph/program/Benchmark.cpp.d
+- spec/build/graph/program/Benchmark.cpp.o
+- spec/build/graph/program/Benchmark.h
+- spec/build/graph/program/DictionarySort.h
+- spec/build/graph/program/ParallelMergeSort.h
+- spec/build/graph/program/dictionary-sort
+- spec/build/graph/program/main.cpp
+- spec/build/graph/program/main.cpp.d
+- spec/build/graph/program/main.cpp.o

data/lib/build.rb

@@ -1,5 +0,0 @@
-require "build/version"
-
-module Build
-	
-end

data/lib/build/edge.rb

@@ -1,49 +0,0 @@
-
-require 'build/error'
-
-module Build
-	# Represents an input to a graph node, with count inputs.
-	class Edge
-		def initialize(count = 0)
-			@fiber = Fiber.current
-			@count = count
-			
-			@failed = []
-		end
-		
-		attr :failed
-		
-		attr :fiber
-		attr :count
-		
-		def wait
-			if @count > 0
-				Fiber.yield
-			end
-			
-			failed?
-		end
-		
-		attr :failed
-		
-		def failed?
-			@failed.size != 0
-		end
-		
-		def traverse(node)
-			@count -= 1
-			
-			if node.failed?
-				@failed << node
-			end
-			
-			if @count == 0
-				@fiber.resume
-			end
-		end
-		
-		def increment!
-			@count += 1
-		end
-	end
-end

data/lib/build/error.rb

@@ -1,18 +0,0 @@
-
-
-module Build
-	class TransientError < StandardError
-	end
-	
-	class CommandFailure < TransientError
-		def initialize(command, status)
-			super "Command #{command.inspect} failed with exit status #{status}!"
-		
-			@command = command
-			@status = status
-		end
-	
-		attr :command
-		attr :status
-	end
-end

data/lib/build/files.rb

@@ -1,286 +0,0 @@
-# Copyright, 2014, 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 'set'
-require 'pathname'
-
-module Build
-	module Files
-		class List
-			include Enumerable
-			
-			def +(list)
-				Composite.new([self, list])
-			end
-			
-			def intersects? other
-				other.any?{|path| include?(path)}
-			end
-			
-			def match(pattern)
-				all? {|path| path.match(pattern)}
-			end
-		end
-		
-		class RelativePath < String
-			# Both paths must be full absolute paths, and path must have root as an prefix.
-			def initialize(path, root)
-				raise ArgumentError.new("#{root} is not a prefix of #{path}") unless path.start_with?(root)
-			
-				super path
-			
-				@root = root
-			end
-		
-			attr :root
-		
-			def relative_path
-				self.slice(@root.length..-1)
-			end
-		end
-	
-		# A list which has a single root directory.
-		class DirectoryList < List
-			def initialize(root)
-				@root = root.to_s
-			end
-			
-			attr :root
-			
-			def roots
-				[@root]
-			end
-			
-			def rebase(root)
-				raise NotImplementedError
-			end
-			
-			def to_paths(root=@root)
-				relative_paths = self.each do |path|
-					path.relative_path
-				end
-			
-				return Paths.new(root, relative_paths)
-			end
-			
-			def process(root=@root)
-				self.collect do |path|
-					basename, _, filename = path.relative_path.rpartition(File::SEPARATOR)
-					
-					File.join(basename, yield(filename))
-				end
-				
-				Paths.new(root, self.collect)
-			end
-		end
-	
-		class Directory < DirectoryList
-			def initialize(root, path = "")
-				super(root)
-				
-				@path = path
-			end
-		
-			attr :path
-		
-			def full_path
-				File.join(@root, @path)
-			end
-		
-			def each(&block)
-				Dir.glob(full_path + "**/*") do |path|
-					yield RelativePath.new(path, @root)
-				end
-			end
-		
-			def eql?(other)
-				other.kind_of?(self.class) and @root.eql?(other.root) and @path.eql?(other.path)
-			end
-		
-			def hash
-				[@root, @path].hash
-			end
-		
-			def include?(path)
-				# Would be true if path is a descendant of full_path.
-				path.start_with?(full_path)
-			end
-		
-			def rebase(root)
-				self.class.new(root, @path)
-			end
-		end
-	
-		class Glob < DirectoryList
-			def initialize(root, pattern)
-				super(root)
-				
-				@pattern = pattern
-			end
-	
-			attr :root
-			attr :pattern
-		
-			def full_pattern
-				File.join(@root, @pattern)
-			end
-		
-			# Enumerate all paths matching the pattern.
-			def each(&block)
-				Dir.glob(full_pattern) do |path|
-					yield RelativePath.new(path, @root)
-				end
-			end
-			
-			def eql?(other)
-				other.kind_of?(self.class) and @root.eql?(other.root) and @pattern.eql?(other.pattern)
-			end
-		
-			def hash
-				[@root, @pattern].hash
-			end
-		
-			def include?(path)
-				File.fnmatch(full_pattern, path)
-			end
-		
-			def rebase(root)
-				self.class.new(root, @pattern)
-			end
-		end
-	
-		class Paths < DirectoryList
-			def initialize(root, paths)
-				super(root)
-				
-				@paths = Array(paths)
-			end
-	
-			attr :paths
-	
-			def each(&block)
-				@paths.each do |path|
-					full_path = File.join(@root, path)
-					yield RelativePath.new(full_path, @root)
-				end
-			end
-	
-			def eql? other
-				other.kind_of?(self.class) and @paths.eql?(other.paths)
-			end
-		
-			def hash
-				@paths.hash
-			end
-		
-			def include?(path)
-				# Compute a full relative path:
-				full_path = File.absolute_path(path, @root)
-				
-				# If the full path starts with @root, test it for inclusion:
-				if full_path.start_with? @root
-					# Compute the relative component:
-					relative_path = full_path[@root.length..-1]
-					
-					# Does this list of paths include it?
-					return @paths.include?(relative_path)
-				else
-					return false
-				end
-			end
-		
-			def rebase(root)
-				self.class.new(root, @paths)
-			end
-		
-			def to_paths
-				return self
-			end
-		end
-	
-		class Composite < List
-			def initialize(files = Set.new)
-				@files = files
-			end
-		
-			attr :files
-		
-			def each(&block)
-				@files.each do |files|
-					files.each &block
-				end
-			end
-		
-			def roots
-				@files.collect(&:roots).flatten.uniq
-			end
-		
-			def eql?(other)
-				other.kind_of?(self.class) and @files.eql?(other.files)
-			end
-		
-			def hash
-				@files.hash
-			end
-		
-			def merge(list)
-				if list.kind_of? Composite
-					@files += list.files
-				elsif list.kind_of? List
-					@files << list
-				else
-					raise ArgumentError.new("Cannot merge non-list of file paths.")
-				end
-			end
-		
-			def +(list)
-				if list.kind_of? Composite
-					Composite.new(@files + list.files)
-				else
-					Composite.new(@files + [list])
-				end
-			end
-		
-			def include?(path)
-				@files.any? {|list| list.include?(path)}
-			end
-		
-			def rebase(root)
-				self.class.new(@files.collect{|list| list.rebase(root)})
-			end
-		
-			def to_paths
-				Composite.new(@files.collect(&:to_paths))
-			end
-		
-			def self.[](files)
-				if files.size == 0
-					return None
-				elsif files.size == 1
-					files.first
-				else
-					self.class.new(files)
-				end
-			end
-		end
-	
-		NONE = Composite.new
-	end
-end