basechip 0.0.1

data/lib/base_chip/cli.rb

@@ -0,0 +1,371 @@
+# Copyright 2011 Tommy Poulter
+#
+# This file is part of basechip.
+#
+# basechip is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 3 as
+# published by the Free Software Foundation.
+# 
+# basechip is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with basechip.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'ostruct'
+require 'reporting'
+class String
+  def titleize!
+    self.downcase!
+    self.gsub!(/_/, ' ')
+    self.gsub!(/(^| )([a-z])/) do 
+      $1+$2.upcase
+    end
+    self
+  end
+  def titleize
+    self.dup.titleize!
+  end
+  def modelize!
+    self[0] = self[0].downcase
+    self.gsub!(/([A-Z])/) do 
+      "_#{$1.downcase}"
+    end
+    self
+  end
+  def modelize
+    self.dup.modelize!
+  end
+end
+module BaseChip
+  module Cli
+    def self.included mod
+      mod.extend Cli::ClassMethods
+      mod.class_eval do
+        include BaseChip::Reporting
+        include Cli::InstanceMethods
+
+        @cli    = Cli::Data.new
+
+        desc    "Show usage information"
+        example ""
+        example " #{cli.tasks[1]}" if cli.tasks[1]
+        def help(command = nil,*subcommands)
+          puts ''
+          if command 
+            command = command.to_sym
+            if (sc = cli.sub_commands[command])
+              sc.new.help(*subcommands)
+              return
+            elsif t_cli = cli.tasks[command]
+              puts "#{cli.full_command(command)} #{t_cli.usage}:"
+            else
+              fault "could not find help topic \"#{command}\""
+            end
+          else
+            t_cli = cli
+
+            puts "#{cli.full_command(command,false)}: "
+          end
+
+          if t_cli.description
+            puts ''
+            puts "    #{t_cli.description}"
+          end
+          if t_cli.long_description
+            puts ''
+            puts "    #{t_cli.long_description}"
+          end
+          
+          unless command
+            array = []
+            cli.tasks.each_value do |t|
+              if t.full_usage 
+                array << [t.full_usage                                 ,t.description]
+              else
+                array << ["#{cli.full_command(t.name.to_s)} #{t.usage}",t.description]
+              end
+            end
+            cli.sub_commands.each do |name,sc|
+              array << ["#{sc.cli.full_command(nil,'false')} #{name} ...",sc.cli.description]
+            end
+            puts ''
+            puts "    Commands:"
+            cli.table(array,nil,"        ")
+
+          end
+
+          t_cli.options_table
+          puts ''
+        end
+      end
+    end
+    class TaskOrData
+      include BaseChip::Reporting
+
+      attr_accessor :name
+      attr_accessor :options
+      attr_accessor :description
+      attr_accessor :long_description
+      def initialize
+        @options  = {}
+      end
+      def s2o(arg)
+        arg = arg.to_s
+        arg = (arg.length > 1 ? '--' : '-') + arg
+        arg.gsub!(/_/,'-')
+        arg
+      end
+      def option(name,hash)
+        hash.merge! :name=>name
+        @options[s2o name] = hash
+        if hash[:alias]
+          hash[:alias].each do |a|
+            @options[s2o a] = hash
+          end
+        end
+      end
+      def option_usage(o)
+        name = s2o o[:name]
+        alt = o[:alias] ? " (#{ o[:alias].map{|a|s2o a}.join('|')  })" : ''
+        case o[:type]
+        when :boolean; return name + alt
+        else           return "#{name}#{alt} <#{o[:type]}>"
+        end
+      end
+      def options_table
+        return if self.options.size == 0
+        array = []
+        self.options.values.uniq.each do |t|
+          array << [self.option_usage(t),t[:description]]
+        end
+        puts ''
+        puts "    #{ self.name ? self.name.to_s.titleize : 'Global' } Options:"
+        table(array,nil,"        ")
+      end
+      def mine_options(ostruct, arguments, unknown_check = false)
+        found = true
+        while found
+          found = false
+          arguments.size.times do |i|
+            a = arguments[i]
+            case a
+            when *(self.options.keys.map{|k|k.to_s})
+              h = self.options[a]
+              case h[:type]
+              when :boolean; ostruct.send("#{h[:name]}=",true               )
+              when :string ; ostruct.send("#{h[:name]}=",arguments[i+1].to_s); arguments.delete_at(i+1) # TODO error if i+1 doesn't exist
+              when :integer; ostruct.send("#{h[:name]}=",arguments[i+1].to_i); arguments.delete_at(i+1) # TODO error if i+1 doesn't exist
+              end
+              arguments.delete_at(i)
+              found = true
+              break
+            end
+          end
+        end
+        if unknown_check
+          arguments.each do |a|
+            fault "#{self.name || 'base_chip'} didn't understand the option #{a}" if a =~ /^\-/
+          end
+        end
+      end
+      def table(array,delimiter='  : ',indent='')
+        delimiter ||= '  : '
+        widths = []
+        array.each do |array2|
+          array2.size.times do |i|
+            widths[i] ||= 0
+            array2[i] ||= ''
+            len = array2[i].length + 2
+            widths[i] = len if widths[i] < len
+          end
+        end
+        format = indent + widths.map{ |w| "%-#{w}s" }.join(delimiter)
+        array.each do |array2|
+          puts format % array2
+        end
+      end
+    end
+    class Task < TaskOrData
+      attr_accessor :usage
+      attr_accessor :full_usage
+      attr_accessor :examples
+      attr_accessor :required_argument_size
+      def initialize
+        super
+        @examples = []
+      end
+    end
+    class Data < TaskOrData
+      attr_accessor :map
+      attr_accessor :current_task
+      attr_accessor :default_task
+      attr_accessor :tasks
+
+      attr_accessor :parent_command
+      attr_accessor :sub_commands
+      def initialize
+        super
+        @map          = {}
+        @sub_commands = {}
+        @tasks        = {}
+        @current_task = self
+        @default_task = nil
+      end
+      def save_task(name,prc)
+        return if self == @current_task
+        @current_task.required_argument_size = 0
+        @current_task.usage ||= 
+          prc.parameters.map do |pa|
+            case pa[0]
+            when :req ; @current_task.required_argument_size += 1 ; "<#{pa[1]}>"  
+            when :opt                                             ; "[#{pa[1]}]"
+            when :rest                                            ; "[#{pa[1]}]+"
+            end
+          end.join(' ') + ' [options]'
+        @current_task.name = name
+        @tasks[name]       = @current_task
+        @current_task      = self
+      end
+      def sub_command(name,klass)
+        @sub_commands[name]        = klass
+        klass.cli.parent_command   = self
+        klass.cli.name             = name
+        klass.cli.description      = @current_task.description
+        klass.cli.long_description = @current_task.long_description
+        @current_task              = self
+      end
+      def full_command(task = nil, with_options=true)
+        task = task.to_s if task
+        n = if self.parent_command 
+          self.parent_command.full_command((task.nil? ? nil : self.name),with_options)
+        else
+          File.basename($0)
+        end
+        if task
+          n + ' ' + task
+        else
+          n
+        end
+      end
+    end
+    module ClassMethods
+      def cli=(a); @cli = a end; def cli; @cli end; @cli = Cli::Data.new
+      def options; BaseChip.options end
+
+      # documentation routines
+      def desc(description, usage=nil)
+        cli.current_task = Cli::Task.new
+        cli.current_task.description = description
+      end
+      def long(description)
+        cli.current_task.long_description = description
+      end
+      def usage       ( usage           ); cli.current_task.     usage = usage  end
+      def full_usage  ( usage           ); cli.current_task.full_usage = usage  end
+      def example     ( example         ); cli.current_task.examples << example end
+      def option      ( name, hash = {} ); cli.current_task.option(name, hash ) end
+      def sub_command ( name, klass     ); cli.sub_command(        name, klass) end
+      def default                        ; cli.default_task = cli.current_task  end
+
+      def map         ( name,rename     ); cli.map[name]             =  rename  end
+      def method_added(name)
+        cli.save_task(name,instance_method(name))
+      end
+      def first(function,hash = {})
+        puts "call #{function} first"
+      end
+
+    end
+    module InstanceMethods
+      def cli     ; self.class.cli     end 
+      def options ; self.class.options end 
+      def run_cli_no_command
+        puts "\nPlease specify a sub command" + ( cli.name ? " for #{cli.name}" : '' )
+        help
+        exit 1
+      end
+      def run_cli(arguments = ARGV)
+        run_cli_no_command if arguments.size == 0
+        pass_through              = nil
+        options. append_arguments = nil
+        options.replace_arguments = nil
+        arguments.keep_if do |a|
+          case a 
+          when '--'  ; pass_through = (options. append_arguments ||= []); false
+          when '---' ; pass_through = (options.replace_arguments ||= []); false
+          else 
+            if pass_through
+              pass_through << a
+              false
+            else
+              true
+            end
+          end
+        end
+        cli.options.each do |o,h|
+          if h[:value]
+            options.send("#{h[:name]}=",h[:value])
+          end
+        end
+        cli.mine_options(options,arguments)
+        arguments.size.times do |i|
+          case a = arguments[i].to_sym
+          when *(cli.sub_commands.keys) 
+            arguments.delete_at i
+            cli.sub_commands[a].new.run_cli(arguments)
+            exit
+          when *(cli.tasks.keys) 
+            arguments.delete_at i
+            task = cli.tasks[a]
+            task.mine_options(options,arguments,true)
+            if task.required_argument_size > arguments.size
+              help task.name
+              fault "\n#{task.name} is missing required arguments"
+            end
+            send a, *arguments
+            break
+          else
+            if a[0] == '-'
+              fault("Could not determine what to run from \"#{arguments.join(' ')}\".  Please consider placing dash options at the end of the command line.")
+            end
+            task = cli.default_task or fault("Could not determine what to run from \"#{arguments.join(' ')}\".")
+            task.mine_options(options,arguments,true)
+            if task.required_argument_size > arguments.size
+              puts "\n#{task.name} is missing required arguments"
+              help task.name
+              exit 1
+            end
+            send task.name, *arguments
+            break
+          end
+        end
+      end
+      def print_table(table, delimeter="\t")
+        column = 0
+        table2 = []
+        sizes  = []
+
+        # determine size
+        table.each do |row|
+          column = 0
+          table2 << row.map do |c|
+            tmp           = c.to_s
+            tmpsize       = tmp.size
+            sizes[column] = tmpsize if sizes[column].nil? or tmpsize > sizes[column]
+            column += 1
+            tmp
+          end
+        end
+
+        # map to sized columns
+        table2.each do |row|
+          column = 0
+          puts (row.map! { |c| "%-#{sizes[(column += 1) - 1]}s" % c }).join(" => ").strip
+        end
+      end
+    end
+  end
+end

data/lib/base_chip/cluster.rb

@@ -0,0 +1,93 @@
+# Copyright 2011 Tommy Poulter
+#
+# This file is part of basechip.
+#
+# basechip is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 3 as
+# published by the Free Software Foundation.
+# 
+# basechip is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with basechip.  If not, see <http://www.gnu.org/licenses/>.
+
+module BaseChip
+  class Cluster
+    include Dsl
+    include Base
+
+    define_settings({:foreground_allowed   => [ Integer               ],
+                     :background_allowed   => [ Integer               ],
+                     :maximum_jobs         => [ Integer               ],
+                     :default_jobs         => [ Integer               ],
+                     :id_regex             => [ Regexp                ],
+                     :id_variable          => [ String                ],
+                     :id_procedure         => [ Proc                  ],
+                     :submit_procedure     => [ Proc                  ],
+                     :submit_command       => [ String                ],
+                     :kill_procedure       => [ Proc                  ],
+                     :kill_command         => [ String                ],
+                     :cluster_args         => [ String                ]})
+
+    attr_accessor :ids
+    attr_accessor :slots
+    attr_accessor :slots_used
+
+    def initialize 
+      super 
+      @ids        = []
+      @slots      = 0
+      @slots_used = 0
+    end
+
+    def available_slots
+      @slots - @slots_used
+    end
+
+    def submit(command)
+      fault "Cluster submission requires a way to kill spawned jobs.  Please specify kill_procedure or kill_command for #{full_name}" unless @kill_procedure || @kill_command
+
+      if submit_procedure
+        return submit_procedure.call command
+      elsif submit_command
+        output = `#{submit_command} #{command}`
+        if id_regex
+          if result = id_regex.match(output)
+            captures = result[1..-1]
+            if id = (captures.select{|c| (c!=nil) && (c!='') }.first)
+              @ids << id
+              return id
+            else
+              fault "Regex /#{id_regex}/ matched '#{result}' but no useful capture was found in output of submit_command:\n#{output}"
+            end
+          else
+            fault "Regex /#{id_regex}/ could not be matched in output of submit_command:\n#{output}"
+          end
+        elsif id_procedure
+          return id_procedure.call(output)
+        else
+          fault "job id is required for job tracking.  Please specify id_regex, id_variable or id_procedure for cluster #{full_name}" unless id_variable or id_procedure
+        end
+      else
+        fault "No submit_procedure or submit_command defined for cluster #{full_name}"
+      end
+    end
+    def kill_all
+      @ids.each do |id|
+        kill id
+      end
+    end
+    def kill(id)
+      if kill_procedure
+        kill_procedure.call(id)
+      elsif kill_command
+        system "#{kill_command} #{id}"
+      else
+        fault "kill_procedure and kill_command for #{full_name} are both missing at time of kill.  This should have been flagged on submit." unless kill_procedure or kill_command
+      end
+    end
+  end
+end

data/lib/base_chip/cluster_type.rb

@@ -0,0 +1,45 @@
+# Copyright 2011 Tommy Poulter
+#
+# This file is part of basechip.
+#
+# basechip is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 3 as
+# published by the Free Software Foundation.
+# 
+# basechip is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with basechip.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'base_chip/cluster'
+
+module BaseChip
+  class ClusterType
+    include Dsl
+    include Base
+
+    define_children({:cluster => Cluster})
+
+    def dereference(name,jobs,passive)
+      configure
+      clusters = []
+      unless @clusters
+        fault "No clusters are specified for the cluster type '#{@name}'" unless passive
+        return clusters
+      end
+
+      if name == 'all' || name == ''
+        clusters = @clusters.values
+      elsif cluster = @clusters[name.to_s]
+        clusters << cluster
+      else
+        fault "No clusters could be found named '#{name}' of type '#{@name}'" unless passive
+      end
+
+      clusters
+    end
+  end
+end

data/lib/base_chip/code_area.rb

@@ -0,0 +1,30 @@
+# Copyright 2011 Tommy Poulter
+#
+# This file is part of basechip.
+#
+# basechip is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 3 as
+# published by the Free Software Foundation.
+# 
+# basechip is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with basechip.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'base_chip/source_type'
+
+module BaseChip
+  class CodeArea
+    include Dsl
+    include Base
+    define_children({:source_type=> SourceType})
+    def verilog(&blk); source_type(:verilog,blk); end
+    def inc(    &blk); source_type(:inc    ,blk); end
+    def class(  &blk); source_type(:class  ,blk); end
+    def vhdl(   &blk); source_type(:vhdl   ,blk); end
+    def systemc(&blk); source_type(:systemc,blk); end
+  end
+end