amdgpu_fan 0.3.0 → 0.7.0

data/lib/amdgpu_fan/mixin/fan.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module AmdgpuFan
+  ##
+  # A mixin to read fan details and validate input
+  module Fan
+    private
+
+    def fan_file(type)
+      @fan_file ||= {}
+      @fan_file[type] ||= "#{base_hwmon_dir}/fan1_#{type}"
+    end
+
+    def fan_mode_file
+      @fan_mode_file ||= "#{base_hwmon_dir}/pwm1_enable"
+    end
+
+    def fan_power_file
+      @fan_power_file ||= "#{base_hwmon_dir}/pwm1"
+    end
+
+    def fan_speed_raw
+      File.read(fan_power_file).strip
+    end
+
+    def fan_raw_speeds(type)
+      @fan_raw_speeds ||= {}
+      @fan_raw_speeds[type] ||= File.read(Dir.glob("#{base_card_dir}/**/pwm1_#{type}").first).to_i
+    end
+
+    ##
+    # Validate the raw fan speed is between the minimum and maximum values
+    # read from sysfs.
+    def valid_fan_raw_speed?(raw)
+      !raw.nil? && (fan_raw_speeds(:min)..fan_raw_speeds(:max)).cover?(raw.to_i)
+    end
+
+    def valid_fan_percent_speed?(percent)
+      (1..100.to_i).cover?(percent.to_i)
+    end
+  end
+end

data/lib/amdgpu_fan/mixin/sys_write.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module AmdgpuFan
+  # A mixin to help with writing to system files
+  module SysWrite
+    private
+
+    ##
+    # Write to a system file with elevated priviledges.
+    def sudo_write(file_path, value)
+      `echo "#{value}" | sudo tee #{file_path}`
+    end
+  end
+end

data/lib/amdgpu_fan/pci.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'net/http'
+
+module AmdgpuFan
+  ## PCI
+  #
+  # Retrieve device information from PCI IDs.
+  # https://pci-ids.ucw.cz/
+  #
+  class PCI
+    TMP_FILE = '/tmp/pci.ids.txt'
+    URL = 'https://pci-ids.ucw.cz/v2.2/pci.ids'
+
+    ##
+    # Return the device name if available
+    #
+    def self.device_name(vendor_id, device_id, subdevice_id)
+      device = info.dig vendor_id, :devices, device_id
+
+      device.dig(subdevice_id, :name) || device[:name]
+    end
+
+    def self.vendor_name(vendor_id)
+      info.dig vendor_id, :name
+    end
+
+    def self.info
+      current_vendor_id = nil
+      current_device_id = nil
+
+      @info = raw.each_line.with_object({}) do |line, hash|
+        next if line.empty? || line.start_with?('#')
+
+        if line[0] =~ /(\d|[a-z])/
+          # Vendor line
+          current_vendor_id = line.split('  ').first.to_i(16)
+          vendor_name = line.split('  ').last.strip
+          hash[current_vendor_id] = { name: vendor_name, devices: {} }
+        elsif line[0..1] =~ /\t\w/
+          # Device line
+          current_device_id = line.split('  ').first.to_i(16)
+          device_name = line.split('  ').last.strip
+          hash[current_vendor_id][:devices][current_device_id] = { name: device_name }
+        elsif line[0..2] =~ /\t\t\w/
+          # Subvendor line
+          subvendor_id = line.split(' ').first.to_i(16)
+          subdevice_id = line.split(' ')[1].to_i(16)
+          subdevice_name = line.split('  ')[1].strip
+          hash[current_vendor_id][:devices][current_device_id][subdevice_id] =
+            { name: subdevice_name }
+        end
+      end
+    end
+
+    def self.raw
+      File.write(TMP_FILE, Net::HTTP.get(URI(URL))) unless File.exist?(TMP_FILE)
+
+      @raw ||= File.read(TMP_FILE)
+    end
+  end
+end

data/lib/amdgpu_fan/service.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require_relative 'mixin/fan'
+require_relative 'mixin/sys_write'
+
+require_relative 'connector'
+require_relative 'pci'
+
+module AmdgpuFan
+  ## AmdgpuService
+  #
+  # A service class for reading and interacting with AMD radeon graphics cards
+  # through the amdgpu Linux kernel driver.
+  class Service
+    include Fan
+    include SysWrite
+
+    BASE_FOLDER = '/sys/class/drm'
+    FAN_MODES = { '1' => 'manual', '2' => 'auto' }.freeze
+
+    attr_reader :card_num
+
+    class Error < StandardError; end
+
+    def initialize(card_num: 0)
+      @card_num = card_num
+    end
+
+    def busy_percent
+      File.read("#{base_card_dir}/gpu_busy_percent").strip
+    end
+
+    def connectors
+      @connectors ||= Connector.where card_num: card_num
+    end
+
+    def core_clock
+      clock_from_pp_file "#{base_card_dir}/pp_dpm_sclk"
+    end
+
+    def display_names
+      connectors.map(&:display_name).compact
+    end
+
+    def fan_mode
+      FAN_MODES[File.read(fan_mode_file).strip] || 'unknown'
+    end
+
+    ##
+    # Set the fan mode to auto or manual.
+    #
+    def fan_mode=(mode)
+      sudo_write fan_mode_file, FAN_MODES.key(mode.to_s)
+    end
+
+    ##
+    # Set the fan speed to a percentage if <= 100 or a raw value
+    #
+    def fan_speed=(value)
+      if valid_fan_percent_speed?(value)
+        new_raw = (value.to_f / 100 * fan_raw_speeds(:max).to_i).round
+      elsif valid_fan_raw_speed?(value)
+        new_raw = value
+      end
+
+      raise(self.class::Error, 'Invalid fan speed provided') if new_raw.to_s.empty?
+
+      self.fan_mode = :manual unless fan_mode == 'manual'
+
+      sudo_write fan_power_file, new_raw
+    end
+
+    def fan_speed_percent
+      (fan_speed_raw.to_f / fan_raw_speeds(:max).to_i * 100).round
+    end
+
+    ##
+    # Return the fan speed in revolutions per minute
+    #
+    def fan_speed_rpm
+      File.read(fan_file(:input)).strip
+    end
+
+    ##
+    # Return the current memory clock speed.
+    #
+    def memory_clock
+      clock_from_pp_file "#{base_card_dir}/pp_dpm_mclk"
+    end
+
+    ##
+    # Return the total memory on the card in bytes
+    #
+    def memory_total
+      File.read("#{base_card_dir}/mem_info_vram_total").to_i
+    end
+
+    def model_id
+      @model_id ||= File.read(File.join(base_card_dir, '/subsystem_device')).gsub(/\A0x/, '').upcase
+    end
+
+    def name
+      return 'Unknown' unless PCI.vendor_name(vendor_id)
+
+      [PCI.vendor_name(vendor_id),
+       PCI.device_name(vendor_id, device_id, subdevice_id) || 'unknown']
+        .join(' ')
+    end
+
+    def power_dpm_state
+      File.read("#{base_card_dir}/power_dpm_state").strip
+    end
+
+    def power_draw
+      power_raw_to_watts File.read(power_avg_file)
+    end
+
+    def power_draw_percent
+      (power_draw.to_f / power_max.to_i * 100).round
+    end
+
+    def power_max
+      @power_max ||= power_raw_to_watts File.read("#{base_hwmon_dir}/power1_cap")
+    end
+
+    def profile_auto
+      sudo_write "#{base_card_dir}/power_dpm_force_performance_level", 'auto'
+    end
+
+    def profile_force=(state)
+      sudo_write "#{base_card_dir}/power_dpm_force_performance_level", 'manual'
+      sudo_write "#{base_card_dir}/pp_power_profile_mode", state
+    end
+
+    def profile_mode
+      File.read("#{base_card_dir}/pp_power_profile_mode").slice(/\w+\s*+\*/).delete('*').strip
+    end
+
+    def profile_summary
+      File.read("#{base_card_dir}/pp_power_profile_mode")
+    end
+
+    def temperature
+      (File.read(temperature_file).to_f / 1000).round(1)
+    end
+
+    def vbios_version
+      @vbios_version ||= File.read("#{base_card_dir}/vbios_version").strip
+    end
+
+    private
+
+    def base_card_dir
+      @base_card_dir ||= "#{BASE_FOLDER}/card#{card_num}/device"
+    end
+
+    def base_hwmon_dir
+      @base_hwmon_dir ||= Dir.glob("#{base_card_dir}/hwmon/hwmon*").first
+    end
+
+    def clock_from_pp_file(file)
+      File.read(file).slice(/\w+(?= \*)/)
+    end
+
+    def device_id
+      @device_id ||= File.read(File.join(base_card_dir, 'device')).to_i(16)
+    end
+
+    def power_avg_file
+      @power_avg_file ||= Dir.glob("#{base_card_dir}/**/power1_average").first
+    end
+
+    def power_raw_to_watts(raw_string)
+      (raw_string.strip.to_f / 1_000_000).round(2)
+    end
+
+    def subdevice_id
+      @subdevice_id ||= File.read(File.join(base_card_dir, 'subsystem_device')).to_i(16)
+    end
+
+    def temperature_file
+      @temperature_file ||= Dir.glob("#{base_card_dir}/**/temp1_input").first
+    end
+
+    def vendor_id
+      @vendor_id ||= File.read(File.join(base_card_dir, 'vendor')).to_i(16)
+    end
+  end
+end

data/lib/amdgpu_fan/stat_set.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module AmdgpuFan
+  # A set of stats
+  class StatSet < Hash
+    attr_accessor :avg, :max, :min, :now
+    attr_reader :unit
+
+    def initialize(unit)
+      @unit = unit
+    end
+
+    def stats
+      { min: min, avg: avg, max: max, now: now }
+    end
+
+    ##
+    # Return a string containing all the stats with units.
+    #
+    def to_s
+      stats.map { |k, v| "#{k}: #{v.to_s.rjust(6)} #{unit.ljust(3)} " }.join
+    end
+  end
+end

data/lib/amdgpu_fan/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module AmdgpuFan
+  # Current version of RSpec Core, in semantic versioning format.
+  VERSION = '0.7.0'
+end

data/lib/amdgpu_fan/watcher.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative 'stat_set'
+
+module AmdgpuFan
+  # Keep track of stats over time.
+  class Watcher
+    attr_reader :core_clock, :fan_speed, :num_measurements, :mem_clock, :power, :temp
+
+    def initialize(amdgpu_service)
+      @amdgpu_service = amdgpu_service
+      @num_measurements = 0
+
+      @core_clock = StatSet.new 'MHz'
+      @mem_clock = StatSet.new 'MHz'
+      @fan_speed = StatSet.new 'RPM'
+      @power = StatSet.new 'W'
+      @temp = StatSet.new '°C'
+    end
+
+    ##
+    # Take a new set of measurements and adjust the stats.
+    #
+    def measure
+      @num_measurements += 1
+
+      @core_clock.now = @amdgpu_service.core_clock.to_i
+      @mem_clock.now = @amdgpu_service.memory_clock.to_i
+      @fan_speed.now = @amdgpu_service.fan_speed_rpm.to_i
+      @power.now = @amdgpu_service.power_draw.to_f
+      @temp.now = @amdgpu_service.temperature.to_i
+
+      [@core_clock, @mem_clock, @fan_speed, @power, @temp].each do |stat_set|
+        calculate_stats(stat_set)
+      end
+    end
+
+    private
+
+    def calculate_stats(stat_set)
+      if num_measurements == 1
+        stat_set.min = stat_set.now
+        stat_set.avg = stat_set.now.to_f
+        stat_set.max = stat_set.now
+        return
+      end
+
+      stat_set.min = stat_set.now if stat_set.now < stat_set.min
+      stat_set.avg =
+        ((stat_set.now + stat_set.avg * (num_measurements - 1)) / num_measurements.to_f)
+        .round(1)
+      stat_set.max = stat_set.now if stat_set.now > stat_set.max
+    end
+  end
+end

metadata

@@ -1,16 +1,58 @@
 --- !ruby/object:Gem::Specification
 name: amdgpu_fan
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Kevin McCormack
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-01-14 00:00:00.000000000 Z
-dependencies: []
-description: A CLI for amdgpu fans
+date: 2020-09-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  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'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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: A CLI for interacting with the amdgpu Linux driver
 email: harlemsquirrel@gmail.com
 executables:
 - amdgpu_fan
@@ -20,14 +62,23 @@ files:
 - README.md
 - bin/amdgpu_fan
 - config/environment.rb
-- lib/amdgpu_fan_cli.rb
-- lib/amdgpu_service.rb
-- lib/radeon_r_black_red_100x100.ascii
+- config/icons.yml
+- lib/amdgpu_fan.rb
+- lib/amdgpu_fan/cli.rb
+- lib/amdgpu_fan/connector.rb
+- lib/amdgpu_fan/mixin/cli_output_format.rb
+- lib/amdgpu_fan/mixin/fan.rb
+- lib/amdgpu_fan/mixin/sys_write.rb
+- lib/amdgpu_fan/pci.rb
+- lib/amdgpu_fan/service.rb
+- lib/amdgpu_fan/stat_set.rb
+- lib/amdgpu_fan/version.rb
+- lib/amdgpu_fan/watcher.rb
 homepage: https://github.com/HarlemSquirrel/amdgpu-fan-rb
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -42,8 +93,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.1.2
+signing_key:
 specification_version: 4
 summary: A CLI to view and set fan speeds for AMD graphics cards running on the open
   source amdgpu Linux driver