partitioner 0.1.0

data/.gitignore

@@ -0,0 +1,3 @@
+pkg/*
+*.gem
+.bundle

data/Gemfile

@@ -0,0 +1,3 @@
+source 'http://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,25 @@
+PATH
+  remote: .
+  specs:
+    partitioner (0.0.1)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.2)
+    rspec (2.5.0)
+      rspec-core (~> 2.5.0)
+      rspec-expectations (~> 2.5.0)
+      rspec-mocks (~> 2.5.0)
+    rspec-core (2.5.2)
+    rspec-expectations (2.5.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.5.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (>= 1.0.0)
+  partitioner!
+  rspec (>= 2.5.0)

data/README.md

@@ -0,0 +1,21 @@
+Partitioner
+=============
+
+The Partitioner can be used to evenly distribute sets of anything
+with a numeric cost to into buckets.
+
+Proposed usage and reason for existence is to distribute specs over
+multiple machines.
+
+Inputs
+-------
+
+At first, the knowledge base must be preseeded wih your data.
+The datastructure is an Array, where each element is a bi-tupel of
+
+    [ Identifier,  Costs ]
+
+Examples
+-------
+
+See specs for examples

data/lib/partitioner.rb

@@ -0,0 +1,56 @@
+require 'partitioner/bucket'
+class Partitioner
+  attr_accessor :kb, :bucket_count
+  def initialize(bucket_count = nil)
+    @kb = {}
+    @bucket_count = bucket_count
+    @prepared = false
+  end
+
+  def buckets
+    time_optimal_size! unless @bucket_count
+    fill_buckets unless @prepared
+    @buckets
+  end
+  alias subsets buckets
+
+  def smallest_bucket
+    cadidate = @buckets.detect(&:empty?)
+    candidate ||= @buckets.min {|a,b| a.value_sum <=> b.value_sum}
+    candidate
+  end
+
+  def biggest_bucket
+    @buckets.max {|a,b| a.value_sum <=> b.value_sum}
+  end
+
+  def fill_buckets
+    reset!
+    kb = @kb.dup
+    kb = kb.sort_by {|x| x.last}.reverse
+
+    while !kb.empty?
+      smallest_bucket << kb.shift
+    end
+    @prepared = true
+  end
+
+  def reset!
+    @buckets = Array.new(@bucket_count) { Bucket.new }
+    @prepared = false
+  end
+
+  # optimizes the bucketsize for time
+  # takes the longest critical path (biggest task)
+  # and calculates the amount of buckets of equal size
+  # needed that all other tasks can fit in them
+  def time_optimal_size
+    total_time = kb.inject(0){|a,b| a+b.last}
+    (total_time / kb.map(&:last).max.to_f).ceil
+  end
+
+  def time_optimal_size!
+    @bucket_count = time_optimal_size
+  end
+
+end

data/lib/partitioner/bucket.rb

@@ -0,0 +1,7 @@
+class Partitioner
+  class Bucket < Array
+    def value_sum
+      self.inject(0) {|a,b| a+b.last}
+    end
+  end
+end

data/partitioner.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name        = "partitioner"
+  s.version     = "0.1.0"
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = []
+  s.email       = []
+  s.homepage    = "http://rubygems.org/gems/partitioner"
+  s.summary     = "get all your tasks parallelized into even buckets."
+  s.description = "partitioner. solves the bin packing problem."
+
+  s.required_rubygems_version = ">= 1.3.6"
+  s.rubyforge_project         = "partitioner"
+
+  s.add_development_dependency "bundler", ">= 1.0.0"
+  s.add_development_dependency "rspec",  ">= 2.5.0"
+
+
+  s.files        = `git ls-files`.split("\n")
+  s.executables  = `git ls-files`.split("\n").map{|f| f =~ /^bin\/(.*)/ ? $1 : nil}.compact
+  s.require_path = 'lib'
+end

data/spec/partitioner_spec.rb

@@ -0,0 +1,61 @@
+require 'rspec'
+require 'partitioner'
+
+describe Partitioner do
+
+  def create_timings(array)
+    ret = []
+    array.each_with_index do |e,i|
+      ret << [i, e]
+    end
+    ret
+  end
+
+  before(:each) do
+    @partition = Partitioner.new(4)
+  end
+
+  it "should be able to just fit in 1" do
+    @partition.kb = create_timings([1])
+    @partition.subsets.map {|x| x.map(&:last)}.should include [1]
+    @partition.subsets.map {|x| x.map(&:last)}.should include []
+  end
+
+  it "should do the right thing with a 1..6 range" do
+    @partition.kb = create_timings([1,2,3,4,5,6])
+    @partition.subsets.map {|x| x.map(&:last)}.should include [6]
+    @partition.subsets.map {|x| x.map(&:last)}.should include [5]
+    @partition.subsets.map {|x| x.map(&:last)}.should include [4,1]
+    @partition.subsets.map {|x| x.map(&:last)}.should include [3,2]
+  end
+
+  it "should do the right thing with a 1..7 range" do
+    @partition.kb = create_timings([1,2,3,4,5,6,7])
+    @partition.subsets.map {|x| x.map(&:last)}.should include [7]
+    @partition.subsets.map {|x| x.map(&:last)}.should include [6,1]
+    @partition.subsets.map {|x| x.map(&:last)}.should include [5,2]
+    @partition.subsets.map {|x| x.map(&:last)}.should include [4,3]
+  end
+
+  describe "the optimization capability" do
+    describe "of time" do
+      describe "calculates the optimum for" do
+
+        it "a single element" do
+          @partition.kb = [[1,1]]
+          @partition.time_optimal_size.should == 1
+        end
+
+        it "an even kb" do
+          @partition.kb = create_timings([5,5,5,5])
+          @partition.time_optimal_size.should == 4
+        end
+
+        it "an extreme kb" do
+          @partition.kb = create_timings([5,1,1,1,1])
+          @partition.time_optimal_size.should == 2
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification 
+name: partitioner
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: []
+
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-13 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 2
+        - 5
+        - 0
+        version: 2.5.0
+  type: :development
+  version_requirements: *id002
+description: partitioner. solves the bin packing problem.
+email: []
+
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- README.md
+- lib/partitioner.rb
+- lib/partitioner/bucket.rb
+- partitioner.gemspec
+- spec/partitioner_spec.rb
+has_rdoc: true
+homepage: http://rubygems.org/gems/partitioner
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 23
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: partitioner
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: get all your tasks parallelized into even buckets.
+test_files: []
+