compute_unit 0.1.0

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/compute_unit.gemspec

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'compute_unit/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'compute_unit'
+  spec.version       = ComputeUnit::VERSION
+  spec.authors       = ['Corey Osman']
+  spec.email         = ['opselite@blockops.party']
+  spec.required_ruby_version = '>= 2.5'
+  spec.summary       = 'A ruby library for compute unit devices'
+  spec.description   = <<~EOF
+
+    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.
+
+  EOF
+
+  spec.homepage      = 'https://gitlab.com/blockops/compute_unit'
+  spec.license       = 'MIT'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = spec.homepage
+  spec.metadata['changelog_uri'] = "#{spec.homepage}/CHANGELOG"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'opencl_ruby_ffi', '~> 1.3.0'
+  spec.add_development_dependency 'bundler', '~> 2.0'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+end

data/exe/list_computes

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+require 'compute_unit'
+require 'compute_unit/gpu'
+require 'json'
+
+begin
+  opencl = !!ARGV.first
+  puts JSON.pretty_generate(ComputeUnit.find_all_with_database(opencl))
+rescue Errno::EACCES => e
+  puts e.message
+end
+

data/exe/update_pcidb

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require 'compute_unit'
+
+begin
+  path = ComputeUnit.refresh_pci_database
+  puts "#{path} udpated to latest pci database."
+rescue Errno::EACCES => e
+  puts e.message
+end
+

data/lib/compute_unit.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'compute_unit/utils'
+require 'compute_unit/version'
+require 'compute_unit/exceptions'
+require 'compute_unit/monkey_patches'
+
+module ComputeUnit
+  CACHE_DIR = File.join('/var', 'run', 'compute_unit_cache')
+  SYSFS_PATH = ENV['SYSFS_PATH'] || '/sys'
+  SYS_DEVICE_PATH = File.join(SYSFS_PATH, 'bus/pci/devices')
+  PCI_DATABASE_PATH = File.join(File.dirname(__dir__), 'pci.ids')
+  PCI_DATABASE_URL = 'http://pci-ids.ucw.cz/v2.2/pci.ids'
+
+  def self.find_all(use_opencl = false)
+    require 'compute_unit/gpu'
+    require 'compute_unit/cpu'
+    require 'compute_unit/asic'
+    raise Exceptions::InvalidPCIDatabase.new('Run: ComputeUnit.refresh_pci_database') unless File.exist?(PCI_DATABASE_PATH)
+
+    ComputeUnit::Gpu.find_all(use_opencl) +
+      ComputeUnit::Cpu.find_all +
+      ComputeUnit::Asic.find_all
+  end
+
+  def self.find_all_with_database(use_opencl = false)
+    refresh_pci_database
+    find_all(use_opencl)
+  end
+
+  def self.refresh_pci_database
+    ComputeUnit::Utils.check_for_root
+    require 'net/http'
+    require 'uri'
+    uri = URI.parse(PCI_DATABASE_URL)
+    response = Net::HTTP.get_response(uri)
+    # I can't write to it unless it has correct permissions
+    File.chmod(0o644, PCI_DATABASE_PATH) if File.exist?(PCI_DATABASE_PATH)
+    File.write(PCI_DATABASE_PATH, response.body) if response.code == '200'
+    File.chmod(0o644, PCI_DATABASE_PATH)
+    PCI_DATABASE_PATH
+  end
+end

data/lib/compute_unit/asic.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'compute_unit/compute_base'
+module ComputeUnit
+  class Asic < ComputeBase
+    DEVICE_CLASS_NAME = 'Asic'
+
+    def self.find_all
+      []
+    end
+
+    # /sys/devices/platform $ more coretemp.0/hwmon/hwmon1/temp1_input / 1000
+  end
+end

data/lib/compute_unit/cache_store.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require 'compute_unit/logger'
+require 'fileutils'
+require 'yaml/store'
+
+module ComputeUnit
+  class CacheStore
+    attr_accessor :name
+    include ComputeUnit::Logger
+
+    def initialize(name)
+      @name = name
+      FileUtils.mkdir_p(File.dirname(cache_file))
+      FileUtils.mkdir_p(cache_files_dir)
+    end
+
+    def cache_files_dir
+      File.join(File.dirname(cache_file), 'files')
+    end
+
+    # @return [YAML::Store]
+    def cache_store
+      @cache_store ||= ::YAML::Store.new(cache_file)
+    end
+
+    # @return [String] - the file where the cache is stored, different per user, due to permissions issue
+    def cache_file
+      if Etc.getpwuid.name == 'root'
+        File.expand_path(File.join(ComputeUnit::CACHE_DIR, name, "#{name}.db"))
+      else
+        File.expand_path(File.join('~', '.compute_unit-cache', name, "#{name}.db"))
+      end
+    end
+
+    # @return [Object] - returns the stored object given the key, defaults to nil when not found unless specified
+    # @param key [String] - the key to retrieve
+    # @param default [Object] - the default value if no data is found
+    def read_cache(key, default = nil)
+      return default unless key
+
+      begin
+        cache_store.transaction do
+          cache_store.fetch(key, default)
+        end
+      rescue StandardError => e
+        logger.debug("Error reading from cache with key #{key}: #{e.message}")
+        default
+      end
+    end
+
+    # @return [?] -
+    # @param key [String] - the key to retrieve
+    # param value [Object] - the object to store in the cache
+    def write_cache(key, value)
+      return if ENV['XB_DISABLE_CACHE'] =~ /yes|true/i
+
+      begin
+        cache_store.transaction do
+          cache_store[key] = value
+        end
+      rescue StandardError => e
+        logger.debug("Error writing to cache with key #{key}: #{e.message}")
+      end
+    end
+
+    def memory_cache
+      @memory_cache ||= {}
+    end
+
+    def write_memcache(key, value)
+      logger.debug("Caching content with key : #{key}")
+      memory_cache[key] = {
+        content: value,
+        ttl: Time.now.to_i
+      }
+      value
+    end
+
+    def memory_cache_lookup(key, ttl = 300)
+      return unless ttl.positive?
+
+      logger.debug("Looking up memory cache for #{key}")
+      hexkey = Digest::SHA1.hexdigest(key)
+      cached_item = memory_cache[hexkey]
+      return nil unless cached_item && cached_item[:content]
+
+      timestamp = cached_item[:ttl] + ttl
+      expired = Time.now.to_i
+      if timestamp > expired
+        logger.debug("Memory cache hit #{hexkey}")
+        begin
+          cached_item[:content]
+        rescue JSON::ParserError
+          nil
+        end
+      else
+        logger.debug("Cleaning cache for #{hexkey}")
+        memory_cache.delete(hexkey)
+        nil
+      end
+    end
+
+    # @return [Object] - return the parsed json object or nil only if the item ttl has not expired
+    # @param key [String] - the url of request
+    # @param ttl [Integer] - time in seconds to keep the request for
+    def read_json_cache_file(key, ttl = 300)
+      logger.debug("Looking up cache for #{key}")
+      hexkey = Digest::SHA1.hexdigest(key)
+      cache_file = File.join(cache_files_dir, "#{hexkey}.json")
+      return nil unless cache_file
+      return nil unless File.exist?(cache_file)
+
+      timestamp = File.mtime(cache_file).to_i + ttl
+      expired = Time.now.to_i
+      if timestamp > expired
+        logger.debug("Cache hit #{hexkey}")
+        begin
+          JSON.parse(File.read(cache_file))
+        rescue JSON::ParserError
+          nil
+        end
+      else
+        logger.debug("Cleaning cache for #{hexkey}")
+        FileUtils.rm(cache_file)
+        nil
+      end
+    end
+
+    # @return [?] -
+    # @param key [String] - the key to retrieve
+    # @param value [Object] - the object to store in the cache in json format
+    def write_json_cache_file(key, value)
+      return if ENV['XB_DISABLE_CACHE'] =~ /yes|true/i
+
+      logger.debug("Caching content with key : #{key}")
+      cache_file = File.join(cache_files_dir, "#{key}.json")
+      File.open(cache_file, 'w') do |f|
+        f.write(value)
+      end
+    end
+  end
+end

data/lib/compute_unit/compute_base.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'time'
+require 'compute_unit/formatters'
+require 'compute_unit/logger'
+require 'compute_unit/device'
+
+module ComputeUnit
+  class ComputeBase < Device
+    attr_reader :type, :serial, :meta, :uuid, :timestamp, :index, :compute_type
+    attr_accessor :power_offset
+
+    include ComputeUnit::Formatters
+    include ComputeUnit::Logger
+
+    # timeout value
+    CACHE_TIMEOUT = 30
+
+    # @param value [Float] a value to offset the power calculation, either a whole number, or decimal
+    # @return [Integer] the value set as the offset
+    def power_offset=(value)
+      @power_offset = value.is_a?(Float) && value.abs < 1 ? (value * power).round(0) : value.to_i
+      # Power offset by #{@power_offset} watts for #{compute_type}#{index},
+      # future calculations will include this offset")
+    end
+
+    def initialize(device_path, opts = {})
+      super
+      @timestamp = Time.now.to_i
+    end
+
+    def device_class_name
+      self.class.const_get('DEVICE_CLASS_NAME')
+    end
+
+    # @return [Array] - an array of pci bus device locations (every device on the pci bus)
+    # @note there is not a filter applied
+    def self.devices
+      Dir.glob(File.join(ComputeUnit::Device::SYSFS_DEVICES_PATH, '*'))
+    end
+
+    def expired_metadata?
+      (timestamp + CACHE_TIMEOUT) < Time.now.to_i
+    end
+
+    def experimental_on?
+      unless ENV['XB_EXPERIMENTAL'].to_s == '1'
+        logger.warn('You must set environment variable XB_EXPERIMENTAL=1 to use this feature')
+        return false
+      end
+      true
+    end
+
+    def micro_formatter(item, add_unit = false)
+      data = {}
+      item.each do |key, value|
+        if %i[hourly_cost hourly_earnings kwh_cost].include?(key)
+          v = (value * 1_000_000).round(4)
+          data[key] = add_unit ? "#{v} \u00B5BTC" : v
+        end
+      end
+      item.merge(data)
+    end
+  end
+end

data/lib/compute_unit/cpu.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'compute_unit/compute_base'
+
+module ComputeUnit
+  class Cpu < ComputeBase
+    DEVICE_CLASS = '060000'
+    DEVICE_CLASS_NAME = 'CPU'
+    # @return [Array] - returns a list of device paths of all devices considered for display
+    def self.devices
+      ComputeUnit::ComputeBase.devices.find_all do |device|
+        ComputeUnit::Device.device_class(device) == DEVICE_CLASS
+      end
+    end
+
+    def self.create_from_path(device_path, index)
+      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),
+        index: index
+      }
+      new(device_path, opts)
+    end
+
+    def self.find_all
+      return [] # not quite ready to show cpu data
+      devices.sort.map.with_index do |device_path, index|
+        create_from_path(device_path, index)
+      end
+    end
+    # /sys/devices/platform $ more coretemp.0/hwmon/hwmon1/temp1_input / 1000
+  end
+end

data/lib/compute_unit/device.rb

@@ -0,0 +1,397 @@
+# frozen_string_literal: true
+
+require 'compute_unit/logger'
+require 'compute_unit/cache_store'
+require 'compute_unit/utils'
+
+# This file supports reading from sysfs
+# More information about sysfs can be found here - https://www.kernel.org/doc/Documentation/filesystems/sysfs-pci.txt
+module ComputeUnit
+  class Device
+    # We can supply a mock sysfs path in order to test with containers and other scenarios
+    SYSFS_DEVICES_PATH = File.join(ComputeUnit::SYSFS_PATH, 'bus', 'pci', 'devices')
+
+    attr_reader :device_class_id,
+                :device_id,
+                :device_vendor_id,
+                :subsystem_vendor_id,
+                :subsystem_device_id,
+                :device_path,
+                :make,
+                :model,
+                :vendor
+
+    include ComputeUnit::Utils
+
+    def initialize(device_path, opts = {})
+      @device_path = device_path
+      @device_class_id = opts[:device_class_id]
+      @device_id = opts[:device_id]
+      @device_vendor_id = opts[:device_vendor_id]
+      @subsystem_vendor_id = opts[:subsystem_vendor_id]
+      @subsystem_device_id = opts[:subsystem_device_id]
+    end
+
+    def to_h
+      { chip_make: make, make: vendor, model: model,
+        device_id: device_id, vendor_id: device_vendor_id,
+        subsystem_device_id: subsystem_device_id,
+        subsystem_vendor_id: subsystem_vendor_id,
+        device_class: device_class_id }
+    end
+
+    # @return [String] - the path to the rom file if available
+    def rom_path
+      @rom_path ||= File.join(device_path, 'rom')
+    end
+
+    # @return [String] - writes a 1 to the rom file, therby unlocking it for reading
+    # must be root
+    def unlock_rom
+      File.write(rom_path, '1') if File.exist?(rom_path)
+    end
+
+    # @return [String] - writes a 0 to the rom file, therby locking it
+    # must be root
+    def lock_rom
+      File.write(rom_path, '0') if File.exist?(rom_path)
+    end
+
+    # @return [String::IO] - the contents of the rom file
+    def rom_data
+      return unless File.exist?(rom_path)
+
+      begin
+        unlock_rom
+        IO.read(rom_path, mode: 'rb')
+      ensure
+        lock_rom
+      end
+    end
+
+    # @return [String] - read a kernel setting using the device_path
+    # @param [String] -  the name of the kernel file in the device path to read
+    # @param [Object] - a default value to use if there is a problem reading the setting
+    def read_kernel_setting(setting, default = 0)
+      self.class.read_kernel_setting(device_path, setting, default)
+    end
+
+    # @return [String] - a reading of the kernel setting using the device_path
+    # @param value [String] - the value to assign to the setting
+    # @param setting [String] -  the name of the kernel file in the device path to read
+    def write_kernel_setting(setting, value)
+      self.class.write_kernel_setting(device_path, setting, value)
+    end
+
+    # @return [String] - the name of the vendor who made the device
+    def make
+      @make ||= begin
+        name = self.class.vendor_lookup(device_vendor_id)
+        name[/\[?(.*)\]?/, 1] if name
+      end
+    end
+
+    # @return [String] - the name of the vendor who resold the device
+    def vendor
+      @vendor ||= begin
+        if device_vendor_id == subsystem_vendor_id
+          make
+        else
+          name = self.class.subsystem_vendor_lookup(subsystem_vendor_id)
+          name[/\[?(.*)\]?/, 1] if name
+        end
+      end
+    end
+
+    # @return [String] - the name of the device model (specific name)
+    def sysfs_model_name
+      name = self.class.subsystem_device_lookup(device_id, subsystem_device_id, subsystem_vendor_id)
+      m = name[/\[?(.*)\]?/, 1] if name
+      m || generic_model
+    end
+
+    # @return [String] - the name of the device model (specific name)
+    def model
+      @model ||= begin
+        sysfs_model_name
+      end
+    end
+
+    # @return [String] - the name of the device model (sometimes not specific)
+    def generic_model
+      @generic_model ||= begin
+        name = self.class.device_lookup(device_id)
+        name[/\[?(.*)\]?/, 1] if name
+      end
+    end
+
+    def read_file(path, default = nil)
+      File.read(path).chomp
+    rescue Errno::EINVAL, Errno::EPERM, Errno::ENOENT
+      default
+    rescue Errno::EACCES
+      logger.fatal('run this command as root or with sudo, using default value')
+      default
+    end
+
+    # @param item [String] - the name of the hwmon file to read from
+    # @param default [Object] - the default value to return if the file is empty or not readable
+    # @return [String] - the value of the item looked up
+    def read_hwmon_data(item, _default = nil)
+      path = File.join(hwmon_path, item)
+      read_file(path)
+    end
+
+    # @param item [String] - the name of the hwmon file to write to
+    # @param value [String] - the value you want to write to the hwmon file
+    def write_hwmon_data(item, value)
+      File.write(File.join(hwmon_path, item), value)
+    rescue Errno::EACCES => e
+      logger.info(e.message)
+      check_for_root
+    end
+
+    # @return [String] - base hwmon path of the device
+    # @note this is used mainly for easier mocking
+    def base_hwmon_path
+      File.join(device_path, 'hwmon')
+    end
+
+    # @return [String] - the directory path to the hwmon dir for this device
+    # @note this path can be different for each device
+    # @note returns the base_hwmon_path if no path is found
+    def hwmon_path
+      @hwmon_path ||= begin
+        paths = Dir.glob(File.join(base_hwmon_path, '*'))
+        paths.first || base_hwmon_path
+      end
+    end
+
+    def expired_metadata?
+      timestamp + CACHE_TIMEOUT < Time.now.to_i
+    end
+
+    def to_json(c = nil)
+      to_h.to_json(c)
+    end
+
+    # @return [Device] - creates a device from the given path
+    # @param device_path [String] - the sysfs path to of the device
+    def self.create_from_path(device_path)
+      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)
+      }
+      new(device_path, opts)
+    end
+
+    # @return [Array] - an array of pci bus device locations (every device on the pci bus)
+    # @param [String] - the device class for filtering out devices
+    # @note there is not a filter applied
+    def self.find_all(device_class_id = nil)
+      Dir.glob(File.join(ComputeUnit::Device::SYSFS_DEVICES_PATH, '*')).map do |device_path|
+        next create_from_path(device_path) unless device_class_id
+        next create_from_path(device_path) if device_class(device_path) == device_class_id
+      end.compact
+    end
+
+    # @return [String] - translation of vendor names to how we known them
+    def self.name_translation(name)
+      name_map[name] || name
+    end
+
+    # @return [Hash] - Name translation map
+    # sometimes we just wamnt a shorter name to see
+    def self.name_map
+      @name_map ||= {
+        'ASUSTeK COMPUTER INC.' => 'Asus',
+        'ASUSTeK Computer Inc.' => 'Asus',
+        'Advanced Micro Devices, Inc. [AMD/ATI]' => 'AMD',
+        'XFX Pine Group Inc.' => 'XFX',
+        'NVIDIA Corporation' => 'Nvidia',
+        'Gigabyte Technology Co., Ltd' => 'Gigabyte',
+        'Sapphire Technology Limited' => 'Sapphire',
+        'eVga.com. Corp.' => 'Evga',
+        'Micro-Star International Co., Ltd. [MSI]' => 'MSI',
+        'Micro-Star International Co., Ltd.' => 'MSI',
+        'Intel Corporation' => 'Intel',
+        'ASMedia Technology Inc.' => 'AsMedia Tech',
+        'Advanced Micro Devices, Inc. [AMD]' => 'AMD',
+        'Tul Corporation / PowerColor' => 'PowerColor',
+        'PC Partner Limited / Sapphire Technology' => 'Sapphire',
+        'Realtek Semiconductor Co., Ltd.' => 'Realtek',
+        'Samsung Electronics Co Ltd' => 'Samsung',
+        'ZOTAC International (MCO) Ltd.' => 'Zotac'
+      }
+    end
+
+    # @return [String] - the device number ie. 1002  (can be different from vendor)
+    def self.subsystem_device(device_path)
+      read_kernel_setting(device_path, 'subsystem_device', '').slice(2, 6)
+    end
+
+    # @return [String] - the vendor number ie. 1002  (can be different from vendor)
+    # example: XFX is the reseller of the AMD chips
+    def self.subsystem_vendor(device_path)
+      read_kernel_setting(device_path, 'subsystem_vendor', '').slice(2, 6)
+    end
+
+    # @return [String] - the device number ie. 1002
+    def self.device(device_path)
+      read_kernel_setting(device_path, 'device', '').slice(2, 6)
+    end
+
+    # @return [String] - the vendor number ie. 1002
+    def self.device_vendor(device_path)
+      read_kernel_setting(device_path, 'vendor', '').slice(2, 6)
+    end
+
+    # @return [String] - the class number ie. 040300
+    # @note helps determine what kind of device this is ie. graphics, storage, ...
+    def self.device_class(device_path)
+      read_kernel_setting(device_path, 'class', '').slice(2, 8)
+    end
+
+    # @return [String] - read a kernel setting using the device_path
+    # @param [String] - the device_path to read from
+    # @param [String] -  the name of the kernel file in the device path to read
+    # @param [Object] - a default value to use if there is a problem reading the setting
+    def self.read_kernel_setting(device_path, setting, default = 0)
+      path = File.join(device_path, setting)
+      logger.debug("reading kernel file #{path}")
+      value = begin
+        File.read(path).chomp
+              rescue Errno::EINVAL, Errno::EPERM
+                logger.fatal(e.message)
+                default
+              rescue Errno::ENOENT
+                logger.fatal("File #{path} does not exist")
+                default
+              rescue Errno::EACCES
+                logger.fatal('Run this command as root or with sudo')
+                default
+      end
+    end
+
+    # @return [String] - read a kernel setting using the device_path
+    # @param [String] - the device_path to write to
+    # @param [String] -  the name of the kernel file in the device path to read
+    def self.write_kernel_setting(device_path, setting, value)
+      path = File.join(device_path, setting)
+      File.write(path, value)
+      read_kernel_setting(device_path, setting)
+    rescue Errno::EINVAL, Errno::EPERM => e
+      logger.fatal(e.message)
+    rescue Errno::ENOENT
+      logger.fatal("File #{path} does not exist")
+    rescue Errno::EACCES
+      logger.fatal('Run this command as root or with sudo')
+    end
+
+    # @return [String] - a sha1 digest that represents the pci devices found on the system
+    def self.system_checksum
+      @system_checksum ||= Dir.chdir(ComputeUnit::SYS_DEVICE_PATH) do
+        Digest::SHA1.hexdigest(Dir.glob('*').sort.join)
+      end
+    end
+
+    # Syntax:
+    # vendor  vendor_name
+    #       device  device_name                             <-- single tab
+    #               subvendor subdevice  subsystem_name     <-- two tabs
+    # @return [Array] - array of lines of the pci database
+    def self.pci_database
+      @pci_database ||= begin
+        IO.foreach(ComputeUnit::PCI_DATABASE_PATH).lazy
+      end
+    end
+
+    def self.manual_device_database
+      @manual_device_database ||= {
+        '687f_0b36_1002' => 'Radeon RX Vega 64'
+      }
+    end
+
+    def self.manual_device_lookup(device_id, subsystem_device_id, vendor_id)
+      key = "#{device_id}_#{subsystem_device_id}_#{vendor_id}"
+      manual_device_database.fetch(key, nil)
+    end
+
+    # @return [String] - the name of the device
+    # @param device_id [String] - the device id of the device
+    # @param subsystem_device_id [String] - the subsystem_device_id of the device
+    # @param vendor_id [String] - the subsystem vendor id
+    def self.subsystem_device_lookup(device_id, subsystem_device_id, vendor_id)
+      # "\t\t1002 687f  Vega 10 XT [Radeon RX Vega 64]\n"
+      p = manual_device_lookup(device_id, subsystem_device_id, vendor_id)
+      return p if p
+
+      re = Regexp.new(/\A\t\t#{vendor_id}\s+#{subsystem_device_id}/)
+      d = pci_database.find do |line|
+        re.match(line)
+      rescue ArgumentError
+        next
+      end
+      return d unless d
+
+      name = d[/\t\t\w+\s+\w+\s+(.*)\n/, 1]
+      name[/.*\[(.*)\]/, 1] || name if name
+    end
+
+    # @return [String] - the name of the subsystem vendor with a possible translation
+    def self.subsystem_vendor_lookup(vendor_id)
+      # "1002  Advanced Micro Devices, Inc. [AMD/ATI]\n"
+      vendor_lookup(vendor_id)
+    end
+
+    # @return [Hash] - a hash of vendors names and ids
+    def self.manual_vendors
+      @manual_vendors ||= { '196e' => 'PNY' }
+    end
+
+    # @return [String] -  return the string of the device vendor
+    # @param id [String] - the vendor id
+    def self.manual_vendor_lookup(id)
+      manual_vendors[id]
+    end
+
+    # @return [String] - the name of the subsystem vendor with a possible translation
+    def self.vendor_lookup(vendor_id)
+      # "1002  Advanced Micro Devices, Inc. [AMD/ATI]\n"
+      re = Regexp.new(/\A#{vendor_id}/)
+      d = pci_database.find do |line|
+        re.match(line)
+      rescue ArgumentError
+        next
+      end
+      return manual_vendor_lookup(vendor_id) unless d
+
+      name = d[/\w+\s+(.*)\n/, 1]
+      name_translation(name)
+    end
+
+    # @param [String] -  the device id such as '686f'
+    # queries the pci_database that is shipped with this gem and looks up the device
+    # @return [String] - the device name
+    def self.device_lookup(device_id)
+      # "\t687f  Vega 10 XT [Radeon RX Vega 64]\n"
+      re = Regexp.new(/\A\t#{device_id}/)
+      d = pci_database.find do |line|
+        re.match(line)
+      rescue ArgumentError
+        next
+      end
+      return d unless d
+
+      name = d[/\t\w+\s+(.*)\n/, 1]
+      name[/.*\[(.*)\]/, 1] || name if name
+    end
+
+    def self.logger
+      ComputeUnit::Logger.logger
+    end
+  end
+end