compute_unit 0.1.0

data/lib/compute_unit/gpus/nvidia_gpu.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+require 'compute_unit/gpu'
+require 'csv'
+module ComputeUnit
+  class NvidiaGpu < ComputeUnit::Gpu
+    VENDOR_ID = '10de'
+    MAKE = 'Nvidia'
+    SUBTYPE = 'nvidia'
+    NVIDIA_SMI = '/usr/bin/nvidia-smi'
+
+    def initialize(device_path, opts = {})
+      data = self.class.read_information_file(device_path).merge(opts)
+      data[:pci_loc] = device_path
+      data[:busid] = data[:bus_location]
+      data[:bios] = data[:video_bios].upcase if data[:video_bios]
+      data[:uuid] = data[:gpu_uuid]
+      super(device_path, data)
+    end
+
+    def subtype
+      SUBTYPE
+    end
+
+    def reset_metadata
+      @meta = nil
+    end
+
+    # @return [Hash] the metadata from the nvidia-smi tool
+    # return cached data or fetch new data
+    def meta
+      if expired_metadata?
+        logger.debug("Expired Nvidia Data for #{uuid} ")
+        @meta = metadata
+      else
+        @meta ||= metadata
+      end
+    end
+
+    def self.blank_data
+      @blank_data ||= {
+        'memory.used [MiB]' => '0',
+        'memory.free [MiB]' => '0',
+        'memory.total [MiB]' => '0',
+        'utilization.gpu [%]' => '0',
+        'temperature.gpu' => '0',
+        'power.draw [W]' => '0',
+        'power.limit [W]' => '0',
+        'power.max_limit [W]' => '0',
+        'pstate' => 7,
+        'fan.speed [%]' => '0',
+        'clocks.current.memory [MHz]' => '0',
+        'clocks.current.sm [MHz]' => '0'
+      }
+    end
+
+    # @note data returned from nvidia-smi
+    # @return [Hash]
+    #          "name": "GeForce GTX 1070 Ti",
+    #          "vbios_version": "86.04.85.00.63",
+    #          "uuid": "GPU-a583cb04-f9b5-68f3-50b9-2b4ba1c7d14e",
+    #         "memory.used [MiB]": "2578 MiB",
+    #         "memory.free [MiB]": "5534 MiB",
+    #         "memory.total [MiB]": "8112 MiB",
+    #         "utilization.gpu [%]": "100",
+    #         "temperature.gpu": "53",
+    #         "power.draw [W]": "129.21",
+    #         "power.limit [W]": "130.00",
+    #         "power.max_limit [W]": "217.00",
+    #         "pstate": 2,
+    #         "fan.speed [%]": "75"
+    def metadata
+      logger.debug("Calling #{NVIDIA_SMI}")
+      data = `#{NVIDIA_SMI} --query-gpu=gpu_name,vbios_version,uuid,memory.used,memory.free,memory.total,utilization.gpu,temperature.gpu,power.draw,power.limit,power.max_limit,fan.speed,pstate,clocks.current.memory,clocks.current.sm -i #{index} --format=csv,nounits 2>&1`
+      unless $CHILD_STATUS.success?
+        # error code 15
+        logger.error(data.delete("\n"))
+        return self.class.blank_data
+      end
+      cards = if data
+                CSV.parse(data, headers: true, header_converters: ->(f) { f.strip },
+                                converters: ->(f) { f ? f.strip : nil }).map(&:to_h)
+              end
+      cards.first
+    end
+
+    # @return [Integer] the current memory clock speed
+    def memory_clock
+      meta['clocks.current.memory [MHz]'].to_i
+    end
+
+    # @return [Integer] the current core clock speed
+    def core_clock
+      meta['clocks.current.sm [MHz]'].to_i
+    end
+
+    # @return [Integer] the fan speed
+    def fan
+      meta['fan.speed [%]'].to_i
+    end
+
+    # @return [Float] the power being used by the gpu
+    def power
+      meta['power.draw [W]'].strip.to_f + power_offset
+    end
+
+    def temp
+      meta['temperature.gpu'].to_i
+    end
+
+    def pstate
+      meta['pstate'].to_i
+    end
+
+    def power_limit
+      meta['power.limit [W]'].strip.to_f
+    end
+
+    def power_max_limit
+      meta['power.max_limit [W]'].strip.to_f
+    end
+
+    # @param value [Numeric] power in watts to set the gpu limit to
+    def power_limit=(value)
+      # in the correct format and above 10 watts
+      raise ArgumentError.new("Power value #{value.to_i} cannot exceed #{power_max_limit}") unless value.to_i.between?(1, power_max_limit.to_i)
+
+      output = `#{NVIDIA_SMI} -i #{index} -pl #{value}`
+      if $CHILD_STATUS.success?
+        logger.info("GPU#{index} power set to #{value} Watts")
+      else
+        logger.warn("GPU#{index} failed setting power to #{value}\n#{output}")
+      end
+      value.to_i
+    end
+
+    # @param value [Numeric] - the fan limit that should be applied to the gpu as a percentage
+    # @return [Numeric] - original passed in value after being set
+    def set_fan_limit(_value, _type = 'current')
+      raise NotImplementedError.new('Not implemented for Nvidia')
+    end
+
+    def memory_total
+      meta['memory.total [MiB]']
+    end
+
+    def memory_used
+      meta['memory.used [MiB]']
+    end
+
+    def memory_free
+      meta['memory.free [MiB]']
+    end
+
+    def utilization
+      meta['utilization.gpu [%]'].sub(/%/, '').to_i
+    end
+
+    def information_file
+      @information_file ||= begin
+        device_name = File.basename(device_path)
+        File.join('/proc/driver/nvidia/gpus', device_name, 'information')
+      end
+    end
+
+    # @return [Array] - returns a list of device paths of all devices specific to the vendor id
+    def self.devices
+      ComputeUnit::Gpu.devices.find_all { |f| device_vendor(f) == VENDOR_ID }
+    end
+
+    # @param device_path [String] - the device path of the device
+    # @param index [Integer] -  the index of the device relative to other devices of the same class ie. GPU0
+    def self.create_from_path(device_path, index, use_opencl = false)
+      opts = {
+        device_class_id: device_class(device_path),
+        device_id: device(device_path),
+        device_vendor_id: device_vendor(device_path),
+        subsystem_vendor_id: subsystem_vendor(device_path),
+        subsystem_device_id: subsystem_device(device_path),
+        use_opencl: use_opencl,
+        index: index
+      }
+      new(device_path, opts)
+    end
+
+    # @return [Array] - returns and array of gpu instances of NVIDIA type only
+    def self.find_all(use_opencl = false)
+      devices.map.with_index do |device_path, _index|
+        found_index = ComputeUnit::Gpu.found_devices.index(device_path)
+        create_from_path(device_path, found_index, use_opencl)
+      end
+    end
+
+    def set_mem_clock_and_vddc(_mem_clock, _mem_volt)
+      return unless experimental_on?
+
+      logger.warn('Feature not enabled for nvidia')
+    end
+
+    # @return [Hash] - hash of card info given by the kernel
+    # {:model=>"GeForce GTX 1070",
+    #  :irq=>"130",
+    #  :gpu_uuid=>"GPU-0116fb5c-66f4-1cba-c216-97f4600a8152",
+    #  :video_bios=>"86.04.50.40.4a",
+    #  :bus_type=>"PCIe",
+    #  :dma_size=>"47 bits",
+    #  :dma_mask=>"0x7fffffffffff",
+    #  :bus_location=>"0000:0d:00.0",
+    #  :device_minor=>"7"}
+    def self.read_information_file(device_path)
+      device_name = File.basename(device_path)
+      information_file = "/proc/driver/nvidia/gpus/#{device_name}/information"
+      File.open(information_file, 'r') do |file|
+        content = file.read
+        content.scan(/\n?([\w\s]*):\s+(.*)/).map { |key, value| [key.downcase.tr(' ', '_').to_sym, value] }.to_h
+      end
+    end
+
+    # more information can be found here: /sys/bus/pci/devices/0000:05:00.0
+
+    # index|misc|busid|model|bios|dpm|cor|cor_offset|default_cor|max_cor|mem_clock|mem_offset|default_mem|temp|temp_throttle|shut_throttle|fan|fan_rpm|pwr|pwr_limit|default_pwr_limit|throttle_reason|sysfs_path
+  end
+end

data/lib/compute_unit/logger.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module ComputeUnit
+  module Logger
+    def self.log_file
+      if ENV['LOG_FILENAME'] && File.exist?(ENV['LOG_FILENAME'])
+        ENV['LOG_FILENAME']
+      else
+        STDOUT
+      end
+    end
+
+    def self.logger
+      @logger ||= begin
+        log = ::Logger.new(Logger.log_file)
+        log.level = log_level
+        log.progname = 'ComputeUnit'
+        log.formatter = proc do |severity, datetime, progname, msg|
+          if Logger.log_file == STDOUT
+            "#{severity} - #{progname}: #{msg}\n".send(color(severity))
+          else
+            "#{datetime} #{severity} - #{progname}: #{msg}\n".send(color(severity))
+          end
+        end
+        log
+      end
+    end
+
+    def logger
+      @logger ||= Logger.logger
+    end
+
+    def self.color(severity)
+      case severity
+      when ::Logger::Severity::WARN, 'WARN'
+        :yellow
+      when ::Logger::Severity::INFO, 'INFO'
+        :green
+      when ::Logger::Severity::FATAL, 'FATAL'
+        :fatal
+      when ::Logger::Severity::ERROR, 'ERROR'
+        :fatal
+      when ::Logger::Severity::DEBUG, 'DEBUG'
+        :green
+      else
+        :green
+      end
+    end
+
+    def self.log_level
+      level = ENV['LOG_LEVEL'].downcase if ENV['LOG_LEVEL']
+      case level
+      when 'warn'
+        ::Logger::Severity::WARN
+      when 'fatal'
+        ::Logger::Severity::FATAL
+      when 'debug'
+        ::Logger::Severity::DEBUG
+      when 'info'
+        ::Logger::Severity::INFO
+      when 'error'
+        ::Logger::Severity::ERROR
+      else
+        ::Logger::Severity::INFO
+      end
+    end
+  end
+end

data/lib/compute_unit/monkey_patches.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+class File
+  # @param path [String] - the path to the file
+  # @param n [Integer] - the number of lines to read from the path
+  # @summary Reads N lines from the end of file, without reading the entire file into memory
+  # @return [String] -  the data read from the file
+  def self.tail(path, n = 1)
+    return '' unless File.exist?(path)
+
+    File.open(path, 'r') do |file|
+      buffer_s = 512
+      line_count = 0
+      file.seek(0, IO::SEEK_END)
+
+      offset = file.pos # we start at the end
+
+      while line_count <= n && offset > 0
+        to_read = if (offset - buffer_s) < 0
+                    offset
+                  else
+                    buffer_s
+                  end
+
+        file.seek(offset - to_read)
+        data = file.read(to_read)
+
+        data.reverse.each_char do |c|
+          if line_count > n
+            offset += 1
+            break
+          end
+          offset -= 1
+          line_count += 1 if c == "\n"
+        end
+      end
+      file.seek(offset)
+      file.read
+    end
+  end
+end
+
+class String
+  def colorize(color_code)
+    "\e[#{color_code}m#{self}\e[0m"
+  end
+
+  def red
+    colorize(31)
+  end
+
+  def green
+    colorize(32)
+  end
+
+  def fatal
+    red
+  end
+
+  def yellow
+    colorize(33)
+  end
+end
+
+class Hash
+  def stringify_keys
+    each_with_object({}) do |(key, value), hash|
+      value = value.stringify_keys if value.is_a?(Hash)
+      hash[key.to_s] = value
+    end
+  end
+
+  def symbolize_keys(&select)
+    dup.symbolize_keys!(&select)
+  end
+
+  def symbolize_keys!(&select)
+    if select
+      keys.each do |key|
+        next unless select[key]
+
+        new_key = (begin
+          key.to_sym
+                   rescue StandardError
+                     key.to_s.to_sym
+        end)
+        self[new_key] = delete(key)
+      end
+    else
+      keys.each do |key|
+        new_key = (begin
+          key.to_sym
+                   rescue StandardError
+                     key.to_s.to_sym
+        end)
+        self[new_key] = delete(key)
+      end
+    end
+    self
+  end
+end

data/lib/compute_unit/utils.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'compute_unit/exceptions'
+require 'etc'
+module ComputeUnit
+  module Utils
+    # @return [Boolean] - return true if the current user is root
+    def self.root?
+      ::Etc.getpwuid.name == 'root'
+    end
+
+    # @return [Boolean] - return true if the current user is root
+    def root?
+      root?
+    end
+
+    # @return [Boolean] - returns true if user is root
+    # @raises [Crossbelt::Exceptions::NoPermission] if user does not have permission
+    def check_for_root
+      raise Exceptions::NoPermission.new('Please run this command as root or with sudo') unless root?
+
+      root?
+    end
+    module_function :check_for_root
+  end
+end

data/lib/compute_unit/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ComputeUnit
+  VERSION = '0.1.0'
+end

metadata

@@ -0,0 +1,142 @@
+--- !ruby/object:Gem::Specification
+name: compute_unit
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Corey Osman
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-05-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: opencl_ruby_ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: |2+
+
+  A ruby library that searches uses the linux sysfs file system for compute unit devices such as
+  CPUS, GPUs and other ASIC compute devices. Allows programmatic access collect real time metrics from the kernel or relatated driver toolchain.
+  Is meant to be used as a toolchain to future build tooling on. This library also makes use of opencl toolchain and requires
+  the opencl_ruby_ffi gem.
+
+email:
+- opselite@blockops.party
+executables:
+- list_computes
+- update_pcidb
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".gitlab-ci.yml"
+- ".rspec"
+- ".rubocop.yml"
+- ".rubocop_todo.yml"
+- ".ruby_version"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- compute_unit.gemspec
+- exe/list_computes
+- exe/update_pcidb
+- lib/compute_unit.rb
+- lib/compute_unit/asic.rb
+- lib/compute_unit/cache_store.rb
+- lib/compute_unit/compute_base.rb
+- lib/compute_unit/cpu.rb
+- lib/compute_unit/device.rb
+- lib/compute_unit/exceptions.rb
+- lib/compute_unit/formatters.rb
+- lib/compute_unit/gpu.rb
+- lib/compute_unit/gpus/amd_gpu.rb
+- lib/compute_unit/gpus/nvidia_gpu.rb
+- lib/compute_unit/logger.rb
+- lib/compute_unit/monkey_patches.rb
+- lib/compute_unit/utils.rb
+- lib/compute_unit/version.rb
+homepage: https://gitlab.com/blockops/compute_unit
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://gitlab.com/blockops/compute_unit
+  source_code_uri: https://gitlab.com/blockops/compute_unit
+  changelog_uri: https://gitlab.com/blockops/compute_unit/CHANGELOG
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.5'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: A ruby library for compute unit devices
+test_files: []