radeonnoise 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: '02952e3cdd342be45f7b8ae82ecfe77e6c879b14033a517200ea82976a48448d'
+  data.tar.gz: 40f43b97f906aa5ce67f2b4fbf38f0cb4e4ca4ca819d0668318cfb74638340ce
+SHA512:
+  metadata.gz: 938c9d89e13aa117be7ad45ffbdd5888360c27a91b686d6f908080fe949ca7cfbfef4edef7dc1f10520fb516cd63d50cdb00af33e7e4054262dfb48f7bba03c3
+  data.tar.gz: e9f0fde1fba7214c006c029020eaed87419580e9f102c6f93e93ef3cda747db618b12313f0e33d4febcf3e5f2339fdc361dc4b9794f0ad848b2a26e5305cab88

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Change log
+This file will document any important changes to the RadeonNoise gem
+
+## [INITIAL RELEASE]
+-radeonnoise-0.1.0

data/README.md

@@ -0,0 +1,20 @@
+### OVERVIEW ###
+"radeonnoise" is a port of my other Linux ``amdgpu`` project done in Elixir. It will allow monitoring and control of Radeon graphics cards that use the ``amdgpu`` driver.
+
+I had previously hacked together this same library (also in Ruby) for a personal app, and I was planning to port the whole thing to Elixir. However, I just find Ruby more enjoyable and speedy to code in, and with Ruby 3.0.0's release, the Ractor model allows Ruby to bypass the GIL, so performance hits should be far less than the original private project.
+
+Unlike the Elixir version, this is going to be a pluggable module and is not intended to inherently be a server unto itself.
+
+The name is a play on Raildex's "Radio Noise Project", with the Misaka clones.
+
+# TO-DO
+1) Link driver version, probably by host bus and ``lspci``
+1) Clean out unnecessary/unused code
+1) Add better documentation
+1) Add a fan curve configuration system
+1) Add a fan curve controller
+
+# INSTALLATION
+```
+gem install radeonnoise
+```

data/lib/radeonnoise.rb

@@ -0,0 +1,3 @@
+# lib/radeonnoise.rb
+# Main file
+require_relative './radeonnoise/core.rb'

data/lib/radeonnoise/core.rb

@@ -0,0 +1,430 @@
+# lib/radeonnoise/core.rb
+
+# Local requires
+require_relative "./parts.rb"
+
+# This module will control the
+# basic operation of a RadeonNoise
+# application and configuration details.
+module RadeonNoise
+  # Base directory for hwmon
+  BASEDIR = "/sys/class/hwmon"
+  
+  # List of cards
+  attr_reader :cards, :lspci
+  
+  # Initialize the RadeonNoise controls
+  def self.init
+    @cards = []
+    @lspci = self.read_lspci
+    # Iterate over hwmon subdirectories
+    Dir.glob("#{BASEDIR}/*")
+      # For each subdirectory, create an array
+      .collect do |subd|
+        # Read the uevent file
+        File.read("#{subd}/device/uevent")
+          .split(/\n/) # Divide it into lines
+          .map do |line|
+            parts = line.downcase.split("=") # Split into key-value pairs, lowercase
+            k,v = parts[0].strip.to_sym, parts[1].strip # Remove whitespace
+            
+            # Return the intermediate value as a hash containing
+            # the hwmon subdirectory and the key-value pair
+            {dir: subd.split("/").last, k => v}
+          end
+      end
+      # Merge each array into a single hash; if the array
+      # is empty, it will just be an empty hash
+      .collect { |card| card.reduce Hash.new, :update }
+      # We only want AMDGPU cards
+      .select { |card| card[:driver] == "amdgpu" }
+      # Convert each into a card object
+      .each { |card| @cards.push(AMDGPUCard.new(card)) }
+      
+      # Return the cards
+      self.all
+  end
+  
+  # Read the lspci data
+  def self.read_lspci
+    # See if `lspci` is present on the system
+    present = (Dir.glob("/usr/bin/*") + Dir.glob("/sbin/*"))
+      .select { |x| x.strip.match? "lspci" } 
+      .then { |out| out.length > 0 }
+    if present then
+      # The output of this command directly fits for simple parsing
+      # of each system device. It will also likely be ported to the
+      # other project, which will become a dependency here.
+      `lspci -Dnnvvvkmm`.split(/^\s*$/).collect { |device|
+        self.split_device(device.strip) }
+    else
+      [{}]
+    end
+  end # End read of `lspci` data
+  
+  # Divide the lspci data into devices
+  # Each pair should only have a single split, because the
+  # first colon represents the key to use
+  def self.split_device(device)
+    device.split("\n").collect { |line|
+      line.split(/:\s*/, 2).then { |k,v| {k.downcase.strip.to_sym => v.strip } }
+    }.reduce :update
+  end # End device splitter
+
+  # Return all the cards
+  def self.all() @cards end
+    
+  # Return the PCI data
+  def self.pci() @lspci end
+    
+  # Return whether the user is root
+  def self.root
+    if `id -u`.strip.to_i == 0 then
+      return true
+    else
+      puts "You need superuser/root permissions to use setters in this module"
+    end
+    false
+  end
+  
+  # Holds data associated with each
+  # AMDGPU card and provides access to
+  # its fans and settings.
+  class AMDGPUCard
+    # Store the current settings for the 
+    # graphics card:
+    # # detail is the sysfs hardware object data
+    # # sclk is the processor clock
+    # # mclk is the memory clock
+    # # pwm is whether fans are manual (true) or auto (false)
+    # # fan_curve is a list of values for the fan speeds
+    # # by temp.
+    attr_reader :config, :cache
+    
+    PROTECTLVL = [:no_prot, :min_prot, :low_prot, :med_prot, :high_prot, :max_prot]
+    PWMLVL = {0 => :none, 1 => :manual, 2 => :auto}
+    PWMERR = "ERROR: accepted PWM type values are #{PWMLVL.values} or #{PWMLVL.invert.values}"
+    
+    # Constructor
+    def initialize(hw)
+      # Initialize the card's config
+      @config = {
+        detail: hw,
+        sclk: [], # Processor clock
+        mclk: [], # Video memory clock
+        
+        # Regexes for various settings
+        # Use these to detect the numbers for each
+        rg_pwm: /pwm\d*$/, # Fan power settings (0-255)
+        rg_freqs: /freq\d*_label/, # GPU frequencies
+        rg_power: /power\d*_average/, # GPU processor power consumption
+        rg_voltages: /in\d*_label/, # Voltage inputs
+        rg_temps: /temp\d*_label/, # Temperatures
+        rg_fans: /fan\d*_input/, # List of available fans
+        
+        # Quick access to some files
+        # Manual/Auto clocking of processor
+        dpm_level: "device/power_dpm_force_performance_level",
+        # Power cap (used in a setting, as well as a read)
+        pcap: "power1_cap",
+        
+        # Fan curve settings
+        fan_curve: {},
+        
+        # Allow unsafe operations
+        protection: :max_prot,
+      }
+      
+      # Initialize the card's stat cache
+      "#{RadeonNoise::BASEDIR}/#{@config[:detail][:dir]}".then { |d| @cache = {
+        dir: d,
+        vram_total: File.read("#{d}/device/mem_info_vram_total").to_f,
+        vbios: File.read("#{d}/device/vbios_version").strip,
+      }}
+      @cache.update(temps).update(fans).update(subsystem)
+      update
+    end # End constructor
+    
+    # Stat the current cached data
+    def stat() @cache end
+    
+    ####################################
+    ####################################
+    # +++ BASIC READERS SECTION
+    # +++ SECTION CONTAINS READ AND
+    # +++ UPDATE OPERATION METHODS
+    # +++ FOR SIMPLE READERS
+    ####################################
+    ####################################
+      
+    # Attach the `lspci` subsystem data
+    # Essentially, this is the most useful data that is
+    # really relevant from the command, at least for the
+    # purpose of this interface. I may add more, though.
+    def subsystem
+      # There should only be one of these per card, as they
+      # are matched by bus ID. As such, only the first is
+      # selected.
+      RadeonNoise.pci.reject { |item|
+        item[:slot] != @config[:detail][:pci_slot_name]}
+        .first.then { |item| {subsystem: item} }
+    end # End card type
+    
+    # Update the card values
+    def update
+      @cache.update(udevice)
+        .update({slot: upcie})
+        .update(upwm)
+        .update(ufreqs)
+        .update(uvolts)
+        .update(upower)
+        .then { utemps }
+        .then { ufans }
+        .then { @cache }
+    end # End abstract update function
+    
+    # Update core device stats
+    def udevice
+      @cache[:dir].then { |d| {
+        level: File.read("#{d}/#{@config[:dpm_level]}").strip,
+        busy_proc: File.read("#{d}/device/gpu_busy_percent").to_f,
+        busy_mem: File.read("#{d}/device/mem_busy_percent").to_f,
+      }}
+    end # End core device data reader
+    
+    # PWM (fan power)
+    def upwm
+      @cache[:dir].then { |d| {
+        pwm_control: pwmtype(File.read("#{d}/pwm1_enable").to_i),
+        pwm_max: File.read("#{d}/pwm1_max").to_i,
+        pwm_current: File.read("#{d}/pwm1").to_i,
+      }}
+    end # End PWM
+    
+    # Voltage
+    # The inputs were re-classified from a previous commit:
+    # they have a specific meaning and are not actually
+    # variable. in0 is the graphics processor, while in1
+    # is the northbridge, if a sensor is present.
+    # 
+    # As such, will update with a value or empty.
+    def uvolts
+      [@cache[:dir], "in0_input", "in1_input"].then { |d,c,n| {
+        volt_core: File.read("#{d}/#{c}").to_f,
+        volt_northbridge: File.exist?("#{d}/#{n}") ? File.read("#{d}/#{n}").to_f : nil,
+      }}
+    end # End voltage reader
+    
+    # Power consumption
+    # This monitors the current and maximum possible
+    # power usage of the card. 'pcap', however, can be lower
+    # than the card's physical limit, if set as such
+    def upower
+      @cache[:dir].then { |d| {
+        power_cap: File.read("#{d}/#{@config[:pcap]}").strip,
+        power_usage: File.read("#{d}/power1_average").strip,
+      }}
+    end # End power reader
+    
+    # Frequencies
+    # sclk is the processor clock
+    # mclk is the VRAM clock
+    def ufreqs
+      @cache[:dir].then { |d| {
+        freq_core: active_s(File.read("#{d}/device/pp_dpm_sclk"))
+          .collect { |item| item.to_f },
+        freq_vram: active_s(File.read("#{d}/device/pp_dpm_mclk"))
+          .collect { |item| item.to_f },
+      }}
+    end # End frequency reader
+    
+    # PCIe speed
+    # Although this is a 
+    def upcie
+      active_s(File.read("#{@cache[:dir]}/device/pp_dpm_pcie"))
+      .collect do |item| 
+        item.split(",").then { |tf, mul|
+          {multiplier: mul.gsub(/\W/, ''), tfspeed: tf} }
+      end
+    end # End PCIe setting reader
+    
+    ####################################
+    ####################################
+    # +++ COMPLEX ABSTRACT READERS SECTION
+    # +++ SECTION CONTAINS READ AND
+    # +++ UPDATE OPERATION METHODS
+    # +++ FOR VARIABLE READERS
+    ####################################
+    ####################################
+    
+    # Temperatures
+    def temps
+      [@config[:rg_temps], @cache[:dir]].then { |rg, d| 
+        {temps: Component::Temp.new(rg, "#{d}/*")} }
+    end # End temperatures
+    
+    # Update the temperatures
+    def utemps() @cache[:temps].update end
+    
+    # Read fan data
+    def fans
+      [@config[:rg_fans], @cache[:dir]].then { |rg, d| 
+        {fans: Component::Fan.new(rg, "#{d}/*")} }
+    end
+    
+    # Update the fan data
+    def ufans() @cache[:fans].update end
+    
+    ####################################
+    ####################################
+    # +++ GENERAL HELPER FUNCTIONS
+    # +++ FOR SOME OF THE OTHER METHODS
+    ####################################
+    ####################################
+    
+    # Warn the user about unsafe operations
+    def unsafe_warning(fn)
+      ("+" * 20).then { |sep| <<~MSG
+        #{sep}\n'#{fn}' is a potentially damaging operation, and you must supply
+        the parameter 'force=true' to allow it to complete. This function
+        may cause graphics card crashes or damage to components, if used
+        incorrectly. During erroneous usage, data loss/corruption, due to a system
+        crash might be considered 'optimistic'.\n#{sep}
+        MSG
+        }.then { |msg| puts msg }
+      false
+    end # End unsafe warning
+    
+    # Split multi-line read-ins
+    # and then select the active option
+    # only (for settings)
+    def active_s(data)
+      data.split(/\n/)
+        .reject { |item| !item.strip.match?(/\*$/) }
+        .collect { |item| item.split(":").last.strip }
+    end # End abstract active setting reader
+    
+    # PWM control type
+    # Accepts: [Integer, String, Symbol]
+    # 
+    # If String, convert to lowercase w/o whitespace, then
+    # check if it's an Integer or Symbol, and recurse.
+    # 
+    # If Integer, check if in PWMLVL.
+    # If Symbol, check if in inverse hash of PWMLVL.
+    # Return `nil`, if not present -- up to user how to handle.
+    # If anything else, return error message.
+    def pwmtype(val)
+      case
+      when String === val # Try to recursively check on conversion
+        val.downcase.strip.then { |v| v.match?(/^\d+$/) ? pwmtype(v.to_i) : pwmtype(v.to_sym) }
+      when Integer === val # Check the constant directly
+        PWMLVL[val] || PWMERR
+      when Symbol === val # Invert constant, check
+        PWMLVL.invert[val] || PWMERR
+      else # Wrong class of input
+        "ERROR: wrong arg type (#{val.class}) for `pwmtype`. Accepts: [Integer, String, Symbol]"
+      end
+    end # End PWM type checker
+    
+    ####################################
+    ####################################
+    # +++ SETTER FUNCTIONS: THESE NEED
+    # +++ TO BE RUN WITH ROOT PRIVILEGES
+    ####################################
+    ####################################
+    
+    # Set the level of unsafe protection
+    def set_protection(val)
+      if RadeonNoise.root then
+        if PROTECTLVL.include?(val) then
+          @config[:protection] = val
+        else
+          ("+" * 20).then { |sep| <<~ERR
+            #{sep}\n'#{val}' is not a valid protection setting
+            Valid options are: #{PROTECTLVL}
+            No change\n#{sep}
+          ERR
+            }.then { |e| puts e }
+        end
+      end
+    end # End setter for protection level
+    
+    # Change the power cap on the card -- microWatts
+    def set_pcap(uwatts, force=false)
+      # Potentially potentially damaging operation, must supply force param
+      if !force then
+        return unsafe_warning('set_pcap')
+      else
+        # Make sure user is root
+        if RadeonNoise.root then
+          # Writes the minimum value, as the minimum is either below the maximum
+          # power cap or the maximum power cap itself. Absolute value
+          # is applied, so that a negative cannot be entered
+          uwatts.to_i.then { |w|
+            File.write("#{@cache[:dir]}/#{@config[:pcap]}", [w, @cache[:power_max]].min.abs, mode: "r+")}
+        end
+      end
+    end # End pcap setter
+    
+    # Change performance type (manual / auto)
+    # /device/power_dpm_force_performance_level
+    # "manual" / "auto"
+    def set_dpm(setting)
+      if RadeonNoise.root then
+        if [:manual, :auto].include?(setting) then
+          File.write("#{@cache[:dir]}/#{@config[:dpm_level]}", setting, mode: "r+")
+        else
+          puts "DPM force setting can only be 'manual' or 'auto'"
+        end
+      end
+    end # End dpm setter
+    
+    # Set the PWM type
+    # ONLY USABLE AS ROOT
+    # 
+    # Takes a user-entered value to choose the PWM mode
+    # setting -- no control, manual control, or automatic control.
+    # 
+    # Use `pwmtype` to check validity. If invalid, just print an error.
+    # Otherwise, if the value is returned as a symbol, pass it back to
+    # produce and integer to write to the file. Otherwise, write the
+    # returned integer directly
+    def set_pwmt(val)
+      if RadeonNoise.root then
+        pwmtype(val).then { |v| # If the pwmtype output is valid
+          if Integer === v or Symbol === v then
+            (Integer === v ? v : pwmtype(v)).then { |data| # Only use Integers
+              File.write("#{@cache[:dir]}/pwm1_enable", data, mode: "r+") }
+          else # If the pwmtype output is any kind of error message
+            puts "#{v}"
+          end }
+      end
+    end # End setter for PWM type
+    
+    # PWM speed controller
+    # ONLY USABLE AS ROOT
+    # 
+    # Take either a string or integer and write it to the PWM
+    # speed file. The value must be less than :pwm_max, so before
+    # writing, take the min of the max and input values.
+    # 
+    # If the value is an int already, take the absolute value, to
+    # ensure only a positive (or zero) number is entered. If it is
+    # a string, match it to an int, automatically removing ANY non-digits
+    # (including negatives).
+    def set_pwm(input)
+      if RadeonNoise.root then
+        [@cache[:dir], @cache[:pwm_max]].then { |d, mx| 
+          if Integer === input then # If integer, write directly
+            File.write("#{d}/pwm1", [input.abs, mx].min, mode: "r+")
+          elsif String === input and input.match?(/^\d+$/) then
+            input.to_i.then { |data| # If string, convert to int
+              File.write("#{d}/pwm1", [data, mx].min, mode: "r+") }
+          else # Otherwise, error
+            puts "#{input} is not valid. Please enter a positive integer up to #{mx}"
+          end }
+      end
+    end # End setter for PWM speed
+  end # End class AMDGPUCard
+end # End module

data/lib/radeonnoise/curve.rb

@@ -0,0 +1,10 @@
+# lib/radeonnoise/curve.rb
+
+# This module will handle fan curve operations.
+# 
+# It will process a card's fan curve profile, load in
+# fan curve configurations, and operate offer the necessary
+# interfaces to run a fan curve server / supervisor.
+module Curve
+  
+end

data/lib/radeonnoise/parts.rb

@@ -0,0 +1,117 @@
+# lib/radeonnoise/parts.rb
+
+# This module will handle several part objects
+# and their abstract representations as components
+# of a Radeon AMDGPU graphics card.
+# 
+# They operate to represent possible multi-unit
+# components, such as fans, graphics cores, power
+# data, PWM components, and temperature sensors
+module Component
+  # Inherited class
+  # No implementations.
+  class AbstractComponent
+    # Headers is being used to refer to the
+    # subclass-specific file prefixes and suffixes,
+    # which are merged with the indices to generate
+    # a full filename to be read from on each update.
+    # 
+    # Files associated with the object
+    # Items of that type
+    attr_reader :path, :prefixes, :current
+    
+    # Use the path (should end with 'hwmon[number]/*')
+    # to glob all the files by the object type's regex, rg
+    def initialize(rg, path)
+      # Initialize the object variables
+      @current, @prefixes, @path = {}, pfx(rg, index(rg, path)), path.gsub("/*", "")
+      
+      # Create a card index for each prefix
+      @prefixes.each { |pref| @current[pref] = {} }
+      update
+    end # End constructor
+    
+    # Attach regex components to
+    # item indices, so they can be used
+    # with the specific component items
+    def index(rg, path)
+      Dir.glob(path)
+        .reject { |item| !item.match?(rg) }
+        .collect { |item| item.split("/").last.gsub(/\D/, '').to_sym }
+    end # End index
+    
+    # Generate prefixes
+    def pfx(rg, arr)
+      rg.source.gsub(/\\.*$/, '').then { |pf|
+        arr.collect { |item| "#{pf}#{item}".to_sym }}
+    end # End prefix
+    
+    # Update the local data
+    # Set the values that don't change, permanently
+    def update
+      puts "method 'update' is not implemented for #{self.class}, yet"
+    end # End update
+  end # End AbstractComponent class
+  
+  # Temp loader class
+  class Temp < AbstractComponent
+    # For temp, will read the files:
+    # -input (current temp)
+    # -label (name of sensor)
+    # -crit (critical max temperature)
+    # -crit_hyst (critical hysteresis temp)
+    # Permanent values are crit, crit_hyst, and label
+    def update
+      # Fill in all the data, only fill the permanent ones
+      # on the first load.
+      # 
+      # Label should be stripped of trailing spaces, and
+      # all other values should be converted to a float and
+      # divided by 1000, to change back into degrees Celsius
+      @current.each do |k,v|
+        @current[k][:critical] ||= File.read("#{@path}/#{k}_crit").to_f / 1000
+        @current[k][:hysteresis] ||= File.read("#{@path}/#{k}_crit_hyst").to_f / 1000
+        @current[k][:label] ||= File.read("#{@path}/#{k}_label").strip
+        @current[k][:current] = File.read("#{@path}/#{k}_input").to_f / 1000
+      end 
+    end # End update method
+  end # End Temp class
+    
+  # Fan loader class
+  class Fan < AbstractComponent
+    # Read in the enabled state, max state, and target state.
+    # 
+    # Although _target can be read in and manipulated, it is pointlessly
+    # risky to manipulate it, when the PWM controller in the core module
+    # already does this.
+    # 
+    # Due to it being a mechanical RPM target, it will also
+    # CONSTANTLY need to readjust, rather than just keeping the pulse width
+    # setting the same and letting the motor do the lifting. Setting this
+    # forces the driver to take an active role in manipulating the speed, when
+    # it changes by even a small margin.
+    # 
+    ## Whether I will add this later or recommend users overload it themselves, ##
+    ## I am not yet sure. Unlike the power cap, this does not provide any real ##
+    ## benefit, and it can freeze up the driver, at least as tested on my system. ##
+    def update
+      @current.each do |k,v|
+        # If the value, when converted to an integer, is 1, it is enabled.
+        # If it is 1, the result should be true. `.zero?` returns true if 0,
+        # so invert it.
+        @current[k][:enabled] = !File.read("#{@path}/#{k}_enable").to_i.zero?
+        # The current speed of the fan
+        @current[k][:rpm_current] = File.read("#{@path}/#{k}_input").to_i
+        # As the below 2 values, _min and _max, cannot be changed, I have
+        # implemented them as such.
+        # 
+        # _min is probably locked by firmware or the card's BIOS. However,
+        # it is here, anyway. Even root cannot modify this.
+        @current[k][:rpm_min] ||= File.read("#{@path}/#{k}_min").to_i
+        # _max does not seem editable either, but unlike _min, it is
+        # definitely useful to know the card's max RPM.
+        @current[k][:rpm_max] ||= File.read("#{@path}/#{k}_max").to_i
+      end
+    end # End update
+  end # End Fan class
+end # End Component module

data/lib/radeonnoise/version.rb

@@ -0,0 +1,4 @@
+# lib/radeonnoise/version.rb
+module RadeonNoise
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: radeonnoise
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Edelweiss
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-04-19 00:00:00.000000000 Z
+dependencies: []
+description: |
+  Ruby module to provide access to Linux's AMDGPU
+  driver API from Ruby scripts.
+
+  + Control operations require `root` access.
+email: 
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+- CHANGELOG.md
+files:
+- CHANGELOG.md
+- README.md
+- lib/radeonnoise.rb
+- lib/radeonnoise/core.rb
+- lib/radeonnoise/curve.rb
+- lib/radeonnoise/parts.rb
+- lib/radeonnoise/version.rb
+homepage: https://github.com/KleineEdelweiss/radeonnoise_rb
+licenses:
+- LGPL-3.0
+metadata:
+  homepage_uri: https://github.com/KleineEdelweiss/radeonnoise_rb
+  source_code_uri: https://github.com/KleineEdelweiss/radeonnoise_rb
+  bug_tracker_uri: https://github.com/KleineEdelweiss/radeonnoise_rb/issues
+post_install_message: 
+rdoc_options:
+- "--title"
+- RadeonNoise RB -- Linux AMDGPU Controller
+- "--main"
+- README.md
+- "--line-numbers"
+- "--inline-source"
+- "--quiet"
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.5
+signing_key: 
+specification_version: 4
+summary: Linux AMDGPU controller in Ruby
+test_files: []