Instalar AMDGPU desde cero

Sumario

Introducción
Libdrm (32/64 bits)
Libglvnd (32/64 bits)
Libvdpau
Libva
OpenCL Headers
OpenCL ICD Loader (32/64 bits)
Mesa (32/64 bits)
Xf86-video-amdgpu
GLU
FreeGLUT
Mesa demos
Clinfo (32/64 bits)
Configurar el inicio de AMDGPU
Iniciamos AMDGPU
Aceleración 3D por software con LLVMpipe
Configurar la aceleración 3D con Adriconf
Uso de OpenCL con AMDGPU
Crear un firmware personalizado para tener RGB completo en el puerto HDMI
Aplicaciones auxiliares de AMDGPU
Enlaces

Xf86-video-amdgpu

Es el controlador de gráficos para el servidor gráfico X.

Instalación

Dependencias

Herramientas de Compilación

Entre paréntesis la versión con la que se ha compilado Xf86-video-amdgpu para la elaboración de este documento.

* GCC - (13.2.0) o Clang - (18.1.0)
* Gawk - (5.3.0)
* M4 - (1.4.19)
* Libtool - (2.4.7)
* Make - (4.4.1)
* Automake - (1.16.5)
* Autoconf - (2.72)
* Pkg-config - (0.29.2)

Librerías de Desarrollo

* Xorg - (7.7 / xorg-server 21.1.11)
LibXrandr - (1.5.4)
LibXrender - (0.9.11)
LibXv - (1.0.12)
Libdrm - (2.4.120)
Xorgproto - (2023.2)
* Libudev (Udev) - (251)
* Mesa - (24.0.2)

Descarga

xf86-video-amdgpu-23.0.0.tar.xz

Optimizaciones

Optimizaciones adicionales

Optimizaciones adicionales
GCC
Graphite
`$ export {C,CXX}FLAGS+=' -ftree-loop-linear -floop-strip-mine -floop-block'`
IPA
`$ export {C,CXX}FLAGS+=' -fipa-pta'`
LTO
`$ export {C,CXX}FLAGS+=' -fuse-linker-plugin -flto=auto'`
En versiones inferiores a GCC 10, sustituir auto por el número de núcleos que tenga nuestro procesador. Si sólo tiene uno, utilizar el parámetro -flto
Clang
Polly
`$ export {C,CXX}FLAGS+=' -O3 -mllvm -polly -mllvm -polly-vectorizer=stripmine'`
LTO
`$ export {C,CXX}FLAGS+=' -flto'`
ThinLTO
`$ export {C,CXX}FLAGS+=' -flto=thin'`
La aplicación de esta optimización es alternativa a la tradicional LTO, a partir de Clang 3.9 y, por lo tanto, no es combinable con la misma.
Unified LTO
LTO >> ThinLTO
`$ export {C,CXX}FLAGS+=' -flto -funified-lto' $ export LDFLAGS+=' -Wl,--lto=thin'`
ThinLTO >> LTO
`$ export {C,CXX}FLAGS+=' -flto=thin -funified-lto' $ export LDFLAGS+=' -Wl,--lto=full'`
La aplicación de esta optimización es aplicable, a partir de Clang 17, y sólo es combinable con LLD.

Parámetros adicionales

Parámetros adicionales de eliminación de avisos en el proceso de compilación
`$ export {C,CXX}FLAGS+=' -w'`

Establecer la ruta de búsqueda de directorios de librerías en sistemas de 64 bits multiarquitectura
`$ export LDFLAGS+=" -L/usr/lib64 -L/usr/local/lib64 -L/opt/gcc13/lib64"`
Cada usuario tendrá que establecer la ruta de búsqueda de directorios, en función de la distribución que utilice.

Establecer el uso de enlazador dinámico para Mold
`$ export LDFLAGS+=' -fuse-ld=mold'`

Establecer el uso de enlazador dinámico para LLD
Clang
`$ export LDFLAGS+=' -fuse-ld=lld'`
Optimizaciones complementarias LTO/ThinLTO de LLD
`$ export LDFLAGS+=' -Wl,--lto-aa-pipeline=globals-aa -Wl,--lto-newpm-passes=memcpyopt'`
Optimizaciones complementarias LTO de LLD
`$ export LDFLAGS+=" -Wl,--lto-partitions=$(expr $(nproc) / 2)"`
Optimizaciones complementarias ThinLTO de LLD
`$ export LDFLAGS+=" -Wl,--thinlto-jobs=$(expr $(nproc) / 2)"`

Establecer la variable de entorno de uso de compilador para Clang
`$ export CC=clang CXX=clang++`

Extracción y Configuración

$ tar Jxvf xf86-video-amdgpu-23.0.0.tar.xz

$ cd xf86-video-amdgpu-23.0.0

$ ./configure --prefix=$(pkg-config --variable=prefix xorg-server) \

--libdir=$(pkg-config --variable=libdir xorg-server)

Explicación de los comandos

--prefix=$(pkg-config --variable=prefix xorg-server) : Instala el controlador en el mismo directorio raíz que esté ubicado el servidor gráfico X tomando como referencia la información ofrecida por pkg-config.

--libdir=$(pkg-config --variable=libdir xorg-server) : Lo mismo que arriba pero establece la ubicación exacta del directorio de controladores de Xorg, en el caso de que tengamos un sistema de 64 bits multiarquitectura.

Compilación

 make

Parámetros de compilación opcionales

Instalación como root

$ su -c "make install-strip"

Estadísticas de Compilación e Instalación de Xf86-video-amdgpu

Estadísticas de Compilación e Instalación de Xf86-video-amdgpu
CPU	AMD Ryzen 5 5500
MHz	3600 (BoostMax=4457)
RAM	32 GB
Sistema de archivos	XFS
Versión del Kernel	6.7.8-ml SMP PREEMPT_DYNAMIC x86_64
Modo de frecuencia de la CPU	powersave (balance performance)
Planificador de CPU	BORE
Versión de Glibc	2.39
Enlazador dinámico	LLD 18.1.0
Compilador	Clang 18.1.0
Parámetros de optimización	-03 -march=znver3 -mtune=znver3 -mllvm -polly -mllvm -polly-vectorizer=stripmine -flto -funified-lto -Wl,--lto=thin -Wl,--thinlto-jobs=6 -Wl,--lto-aa-pipeline=globals-aa -Wl,--lto-newpm-passes=memcpyopt
Parámetros de compilación	V=1 -j12
Tiempo de compilación	1"
Archivos instalados	4
Archivos instalados
Ocupación de espacio en disco	160 KB

Desinstalación como root

1) MODO TRADICIONAL

$ su -c "make uninstall"

2) MODO MANUALINUX

xf86-video-amdgpu-23.0.0-scripts.tar.gz

$ su

# tar zxvf xf86-video-amdgpu-23.0.0-scripts.tar.gz

# cd xf86-video-amdgpu-23.0.0-scripts

# ./Desinstalar_xf86-video-amdgpu-23.0.0

Copia de Seguridad como root

$ su

# tar zxvf xf86-video-amdgpu-23.0.0-scripts.tar.gz

# cd xf86-video-amdgpu-23.0.0-scripts

# ./Respaldar_xf86-video-amdgpu-23.0.0

Restaurar la Copia de Seguridad como root

$ su

# cd /var/copibin/restaurar_copias

# ./Restaurar_xf86-video-amdgpu-23.0.0

GLU

Librería incluida en el manual por ser una dependencia del paquete Mesa demos.

Instalación

Dependencias

Herramientas de Compilación

Entre paréntesis la versión con la que se ha compilado GLU para la elaboración de este documento.

* GCC - (13.2.0) o Clang - (18.1.0)
* Meson - (1.3.2)
* Ninja - (1.11.1)
* Pkg-config - (0.29.2)

Librerías de Desarrollo

* Libglvnd - (1.7.0)

Descarga

glu-9.0.3.tar.xz

Optimizaciones

Optimizaciones adicionales

Optimizaciones adicionales
GCC
Graphite
`$ export {C,CXX}FLAGS+=' -ftree-loop-linear -floop-strip-mine -floop-block'`
IPA
`$ export {C,CXX}FLAGS+=' -fipa-pta'`
LTO
`$ export {C,CXX}FLAGS+=' -fuse-linker-plugin -flto=auto'`
En versiones inferiores a GCC 10, sustituir auto por el número de núcleos que tenga nuestro procesador. Si sólo tiene uno, utilizar el parámetro -flto
Clang
Polly
`$ export {C,CXX}FLAGS+=' -O3 -mllvm -polly -mllvm -polly-vectorizer=stripmine'`
LTO
`$ export {C,CXX}FLAGS+=' -flto'`
ThinLTO
`$ export {C,CXX}FLAGS+=' -flto=thin'`
La aplicación de esta optimización es alternativa a la tradicional LTO, a partir de Clang 3.9 y, por lo tanto, no es combinable con la misma.
Unified LTO
LTO >> ThinLTO
`$ export {C,CXX}FLAGS+=' -flto -funified-lto' $ export LDFLAGS+=' -Wl,--lto=thin'`
ThinLTO >> LTO
`$ export {C,CXX}FLAGS+=' -flto=thin -funified-lto' $ export LDFLAGS+=' -Wl,--lto=full'`
La aplicación de esta optimización es aplicable, a partir de Clang 17, y sólo es combinable con LLD.

Parámetros adicionales

Parámetros adicionales de eliminación de avisos en el proceso de compilación
`$ export {C,CXX}FLAGS+=' -w'`

Establecer la ruta de búsqueda de directorios de librerías en sistemas de 64 bits multiarquitectura
`$ export LDFLAGS+=" -L/usr/lib64 -L/usr/local/lib64 -L/opt/gcc13/lib64"`
Cada usuario tendrá que establecer la ruta de búsqueda de directorios, en función de la distribución que utilice.

Establecer el uso de enlazador dinámico para Mold
`$ export LDFLAGS+=' -fuse-ld=mold'`

Establecer el uso de enlazador dinámico para LLD
Clang
`$ export LDFLAGS+=' -fuse-ld=lld'`
Optimizaciones complementarias LTO/ThinLTO de LLD
`$ export LDFLAGS+=' -Wl,--lto-aa-pipeline=globals-aa -Wl,--lto-newpm-passes=memcpyopt'`
Optimizaciones complementarias LTO de LLD
`$ export LDFLAGS+=" -Wl,--lto-partitions=$(expr $(nproc) / 2)"`
Optimizaciones complementarias ThinLTO de LLD
`$ export LDFLAGS+=" -Wl,--thinlto-jobs=$(expr $(nproc) / 2)"`

Establecer la variable de entorno de uso de compilador para Clang
`$ export CC=clang CXX=clang++`

Extracción y Configuración

$ tar Jxvf glu-9.0.3.tar.xz

$ cd glu-9.0.3

$ meson build --prefix=/usr --buildtype=release --strip

Explicación de los comandos

--prefix=/usr : Instala la librería en el directorio principal /usr.
--buildtype=release : Compila la versión optimizada del paquete, ya que Meson compila por defecto los paquetes con los parámetros -O2 -g.

--strip : Elimina los símbolos no necesarios para su ejecución de los binarios ejecutables correspondientes.

Compilación

 ninja -C build

Parámetros de compilación opcionales

Instalación como root

$ su

# ninja -C build install

# rm -f $(pkg-config --variable=libdir glu)/libGLU.a

# ldconfig -v

Explicación de los comandos

rm -f $(pkg-config --variable=libdir glu)/libGLU.a : Borra la librería estática instalada, ya que el cambio del sistema de compilación a Meson, no incluye la opción para poder desactivar su compilación.

Estadísticas de Compilación e Instalación de GLU

Estadísticas de Compilación e Instalación de GLU
CPU	AMD Ryzen 5 5500
MHz	3600 (BoostMax=4457)
RAM	32 GB
Sistema de archivos	XFS
Versión del Kernel	6.7.8-ml SMP PREEMPT_DYNAMIC x86_64
Modo de frecuencia de la CPU	powersave (balance performance)
Planificador de CPU	BORE
Versión de Glibc	2.39
Enlazador dinámico	LLD 18.1.0
Compilador	Clang 18.1.0
Parámetros de optimización	-03 -march=znver3 -mtune=znver3 -mllvm -polly -mllvm -polly-vectorizer=stripmine -flto -funified-lto -Wl,--lto=thin -Wl,--thinlto-jobs=6 -Wl,--lto-aa-pipeline=globals-aa -Wl,--lto-newpm-passes=memcpyopt
Parámetros de compilación	V=1 -j12
Tiempo de compilación	2"
Archivos instalados	3
Archivos instalados
Enlaces simbólicos creados	2
Enlaces simbólicos creados
Ocupación de espacio en disco	436 KB

Desinstalación como root

1) MODO TRADICIONAL

$ su -c "make uninstall"

2) MODO MANUALINUX

glu-9.0.3-scripts.tar.gz

$ su

# tar zxvf glu-9.0.3-scripts.tar.gz

# cd glu-9.0.3-scripts

# ./Desinstalar_glu-9.0.3

Copia de Seguridad como root

$ su

# tar zxvf glu-9.0.3-scripts.tar.gz

# cd glu-9.0.3-scripts

# ./Respaldar_glu-9.0.3

Restaurar la Copia de Seguridad como root

$ su

# cd /var/copibin/restaurar_copias

# ./Restaurar_glu-9.0.3

FreeGLUT

Librería incluida en el manual por ser una dependencia del paquete Mesa demos.

Instalación

Dependencias

Herramientas de Compilación

Entre paréntesis la versión con la que se ha compilado FreeGLUT para la elaboración de este documento.

* GCC - (13.2.0) o Clang - (18.1.0)
* CMake - (3.28.3)
* Ninja - (1.11.1)
* Pkg-config - (0.29.2)

Librerías de Desarrollo

* Xorg - (7.7 / xorg-server 21.1.11)
LibICE - (1.1.1)
LibX11 - (1.8.7)
LibXext - (1.3.6)

Descarga

freeglut-3.4.0.tar.gz

Optimizaciones

Optimizaciones adicionales

Optimizaciones adicionales
GCC
Graphite
`$ export {C,CXX}FLAGS+=' -ftree-loop-linear -floop-strip-mine -floop-block'`
IPA
`$ export {C,CXX}FLAGS+=' -fipa-pta'`
LTO
`$ export {C,CXX}FLAGS+=' -fuse-linker-plugin -flto=auto'`
En versiones inferiores a GCC 10, sustituir auto por el número de núcleos que tenga nuestro procesador. Si sólo tiene uno, utilizar el parámetro -flto
Clang
Polly
`$ export {C,CXX}FLAGS+=' -O3 -mllvm -polly -mllvm -polly-vectorizer=stripmine'`
LTO
`$ export {C,CXX}FLAGS+=' -flto'`
ThinLTO
`$ export {C,CXX}FLAGS+=' -flto=thin'`
La aplicación de esta optimización es alternativa a la tradicional LTO, a partir de Clang 3.9 y, por lo tanto, no es combinable con la misma.
Unified LTO
LTO >> ThinLTO
`$ export {C,CXX}FLAGS+=' -flto -funified-lto' $ export LDFLAGS+=' -Wl,--lto=thin'`
ThinLTO >> LTO
`$ export {C,CXX}FLAGS+=' -flto=thin -funified-lto' $ export LDFLAGS+=' -Wl,--lto=full'`
La aplicación de esta optimización es aplicable, a partir de Clang 17, y sólo es combinable con LLD.

Parámetros adicionales

Parámetros adicionales de eliminación de avisos en el proceso de compilación
`$ export {C,CXX}FLAGS+=' -w'`

Establecer la ruta de búsqueda de directorios de librerías en sistemas de 64 bits multiarquitectura
`$ export LDFLAGS+=" -L/usr/lib64 -L/usr/local/lib64 -L/opt/gcc13/lib64"`
Cada usuario tendrá que establecer la ruta de búsqueda de directorios, en función de la distribución que utilice.

Establecer el uso de enlazador dinámico para Mold
`$ export LDFLAGS+=' -fuse-ld=mold'`

Establecer el uso de enlazador dinámico para LLD
Clang
`$ export LDFLAGS+=' -fuse-ld=lld'`
Optimizaciones complementarias LTO/ThinLTO de LLD
`$ export LDFLAGS+=' -Wl,--lto-aa-pipeline=globals-aa -Wl,--lto-newpm-passes=memcpyopt'`
Optimizaciones complementarias LTO de LLD
`$ export LDFLAGS+=" -Wl,--lto-partitions=$(expr $(nproc) / 2)"`
Optimizaciones complementarias ThinLTO de LLD
`$ export LDFLAGS+=" -Wl,--thinlto-jobs=$(expr $(nproc) / 2)"`

Establecer la variable de entorno de uso de compilador para Clang
`$ export CC=clang CXX=clang++`

Extracción y Configuración

$ tar zxvf freeglut-3.4.0.tar.gz

$ cd freeglut-3.4.0

$ cmake -S . -B build -DCMAKE_INSTALL_PREFIX=/usr -DFREEGLUT_BUILD_STATIC_LIBS=OFF -G Ninja

Explicación de los comandos

-S . -B build : Establece el directorio del código fuente y crea de forma automática el directorio de compilación.

-DCMAKE_INSTALL_PREFIX=/usr : Instala la librería en el directorio principal /usr.

-DFREEGLUT_BUILD_STATIC_LIBS=OFF : Desactiva la compilación de las librerías estáticas al no ser necesarias para la compilación y ejecución de programas dependientes de este paquete.

-G Ninja : Utiliza Ninja en lugar de GNU Make para compilar el paquete (opcional).

Compilación

 ninja

Parámetros de compilación opcionales

Instalación como root

$ su

# ninja install/strip

# ldconfig -v

Estadísticas de Compilación e Instalación de FreeGLUT

Estadísticas de Compilación e Instalación de FreeGLUT
CPU	AMD Ryzen 5 5500
MHz	3600 (BoostMax=4457)
RAM	32 GB
Sistema de archivos	XFS
Versión del Kernel	6.7.8-ml SMP PREEMPT_DYNAMIC x86_64
Modo de frecuencia de la CPU	powersave (balance performance)
Planificador de CPU	BORE
Versión de Glibc	2.39
Enlazador dinámico	LLD 18.1.0
Compilador	Clang 18.1.0
Parámetros de optimización	-03 -march=znver3 -mtune=znver3 -mllvm -polly -mllvm -polly-vectorizer=stripmine -flto -funified-lto -Wl,--lto=thin -Wl,--thinlto-jobs=6 -Wl,--lto-aa-pipeline=globals-aa -Wl,--lto-newpm-passes=memcpyopt
Parámetros de compilación	-v -j12
Tiempo de compilación	1"
Archivos instalados	11
Archivos instalados
Enlaces simbólicos creados	2
Enlaces simbólicos creados
Ocupación de espacio en disco	424 KB

Desinstalación como root

1) MODO TRADICIONAL

Este paquete no tiene soporte para desinstalación con el comando 'ninja uninstall'

2) MODO MANUALINUX

freeglut-3.4.0-scripts.tar.gz

$ su

# tar zxvf freeglut-3.4.0-scripts.tar.gz

# cd freeglut-3.4.0-scripts

# ./Desinstalar_freeglut-3.4.0

Copia de Seguridad como root

$ su

# tar zxvf freeglut-3.4.0-scripts.tar.gz

# cd freeglut-3.4.0-scripts

# ./Respaldar_freeglut-3.4.0

Restaurar la Copia de Seguridad como root

$ su

# cd /var/copibin/restaurar_copias

# ./Restaurar_freeglut-3.4.0

Mesa demos

Una colección de utilidades y programas de ejemplo que muestran las capacidades de las librerías gráficas, Mesa.

Instalación

Dependencias

Herramientas de Compilación

Entre paréntesis la versión con la que se ha compilado Mesa demos para la elaboración de este documento.

* GCC - (13.2.0) o Clang - (18.1.0)
* Meson - (1.3.2)
* Ninja - (1.11.1)
* Pkg-config - (0.29.2)

Librerías de Desarrollo

* Xorg - (7.7 / xorg-server 21.1.11)
LibX11 - (1.8.7)
LibXext - (1.3.6)
Libdrm - (2.4.120)
* FreeGLUT - (3.4.0)
* GLU - (9.0.3)
* Libdecor - (0.2.2)
* Libglvnd - (1.7.0)
* Libvulkan - (1.3.279)
* Libxcb - (1.16.1)
* Mesa - (24.0.2)
* Wayland - (1.22.0)

Descarga

mesa-demos-9.0.0.tar.xz

Optimizaciones

Optimizaciones adicionales

Optimizaciones adicionales
GCC
Graphite
`$ export {C,CXX}FLAGS+=' -ftree-loop-linear -floop-strip-mine -floop-block'`
IPA
`$ export {C,CXX}FLAGS+=' -fipa-pta'`
LTO
`$ export {C,CXX}FLAGS+=' -fuse-linker-plugin -flto=auto'`
En versiones inferiores a GCC 10, sustituir auto por el número de núcleos que tenga nuestro procesador. Si sólo tiene uno, utilizar el parámetro -flto
Clang
Polly
`$ export {C,CXX}FLAGS+=' -O3 -mllvm -polly -mllvm -polly-vectorizer=stripmine'`
LTO
`$ export {C,CXX}FLAGS+=' -flto'`
ThinLTO
`$ export {C,CXX}FLAGS+=' -flto=thin'`
La aplicación de esta optimización es alternativa a la tradicional LTO, a partir de Clang 3.9 y, por lo tanto, no es combinable con la misma.
Unified LTO
LTO >> ThinLTO
`$ export {C,CXX}FLAGS+=' -flto -funified-lto' $ export LDFLAGS+=' -Wl,--lto=thin'`
ThinLTO >> LTO
`$ export {C,CXX}FLAGS+=' -flto=thin -funified-lto' $ export LDFLAGS+=' -Wl,--lto=full'`
La aplicación de esta optimización es aplicable, a partir de Clang 17, y sólo es combinable con LLD.

Parámetros adicionales

Parámetros adicionales de eliminación de avisos en el proceso de compilación
`$ export {C,CXX}FLAGS+=' -w'`

Establecer la ruta de búsqueda de directorios de librerías en sistemas de 64 bits multiarquitectura
`$ export LDFLAGS+=" -L/usr/lib64 -L/usr/local/lib64 -L/opt/gcc13/lib64"`
Cada usuario tendrá que establecer la ruta de búsqueda de directorios, en función de la distribución que utilice.

Establecer el uso de enlazador dinámico para Mold
`$ export LDFLAGS+=' -fuse-ld=mold'`

Establecer el uso de enlazador dinámico para LLD
Clang
`$ export LDFLAGS+=' -fuse-ld=lld'`
Optimizaciones complementarias LTO/ThinLTO de LLD
`$ export LDFLAGS+=' -Wl,--lto-aa-pipeline=globals-aa -Wl,--lto-newpm-passes=memcpyopt'`
Optimizaciones complementarias LTO de LLD
`$ export LDFLAGS+=" -Wl,--lto-partitions=$(expr $(nproc) / 2)"`
Optimizaciones complementarias ThinLTO de LLD
`$ export LDFLAGS+=" -Wl,--thinlto-jobs=$(expr $(nproc) / 2)"`

Establecer la variable de entorno de uso de compilador para Clang
`$ export CC=clang CXX=clang++`

Extracción y Configuración

$ tar Jxvf mesa-demos-9.0.0.tar.xz

$ cd mesa-demos-9.0.0

$ meson build --prefix=/usr --buildtype=release --strip

$ ninja -C build

Parámetros de compilación opcionales

Instalación como root

$ su -c "ninja -C build install"

Estadísticas de Compilación e Instalación de Mesa demos

Estadísticas de Compilación e Instalación de Mesa demos
CPU	AMD Ryzen 5 5500
MHz	3600 (BoostMax=4457)
RAM	32 GB
Sistema de archivos	XFS
Versión del Kernel	6.7.8-ml SMP PREEMPT_DYNAMIC x86_64
Modo de frecuencia de la CPU	powersave (balance performance)
Planificador de CPU	BORE
Versión de Glibc	2.39
Enlazador dinámico	Mold 2.4.1
Compilador	GCC 13.2.0
Parámetros de optimización	-03 -march=znver3 -mtune=znver3 -ftree-loop-linear -floop-strip-mine -floop-block -fipa-pta -flto=auto
Parámetros de compilación	V=1 -j12
Tiempo de compilación	39"
Archivos instalados	326
Archivos instalados
Ocupación de espacio en disco	22,5 MB

Desinstalación como root

1) MODO TRADICIONAL

$ su -c "ninja -C build uninstall"

2) MODO MANUALINUX

mesa-demos-9.0.0-scripts.tar.gz

$ su

# tar zxvf mesa-demos-9.0.0-scripts.tar.gz

# cd mesa-demos-9.0.0-scripts

# ./Desinstalar_mesa-demos-9.0.0

Copia de Seguridad como root

$ su

# tar zxvf mesa-demos-9.0.0-scripts.tar.gz

# cd mesa-demos-9.0.0-scripts

# ./Respaldar_mesa-demos-9.0.0

Restaurar la Copia de Seguridad como root

$ su

# cd /var/copibin/restaurar_copias

# ./Restaurar_mesa-demos-9.0.0

Clinfo (32/64 bits)

Utilidad de línea de comandos que muestra las propiedades OpenCL de las plataformas disponibles en nuestro sistema y los dispositivos asociados.

Instalación

Dependencias

Herramientas de Compilación

Entre paréntesis la versión con la que se ha compilado Clinfo para la elaboración de este documento.

* GCC - (13.2.0) o Clang - (18.1.0)
* Make - (4.4.1)

Librerías de Desarrollo

* OpenCL Headers - (2023.12.14)
* OpenCL ICD Loader - (2023.12.14)

Descarga

clinfo-3.0.23.01.25.tar.gz

Optimizaciones

Optimizaciones adicionales

Optimizaciones adicionales
GCC
Graphite
`$ export {C,CXX}FLAGS+=' -ftree-loop-linear -floop-strip-mine -floop-block'`
IPA
`$ export {C,CXX}FLAGS+=' -fipa-pta'`
LTO
`$ export {C,CXX}FLAGS+=' -fuse-linker-plugin -flto=auto'`
En versiones inferiores a GCC 10, sustituir auto por el número de núcleos que tenga nuestro procesador. Si sólo tiene uno, utilizar el parámetro -flto
Clang
Polly
`$ export {C,CXX}FLAGS+=' -O3 -mllvm -polly -mllvm -polly-vectorizer=stripmine'`
LTO
`$ export {C,CXX}FLAGS+=' -flto'`
ThinLTO
`$ export {C,CXX}FLAGS+=' -flto=thin'`
La aplicación de esta optimización es alternativa a la tradicional LTO, a partir de Clang 3.9 y, por lo tanto, no es combinable con la misma.
Unified LTO
LTO >> ThinLTO
`$ export {C,CXX}FLAGS+=' -flto -funified-lto' $ export LDFLAGS+=' -Wl,--lto=thin'`
ThinLTO >> LTO
`$ export {C,CXX}FLAGS+=' -flto=thin -funified-lto' $ export LDFLAGS+=' -Wl,--lto=full'`
La aplicación de esta optimización es aplicable, a partir de Clang 17, y sólo es combinable con LLD.

Parámetros adicionales para la versión de 32 bits

Optimizaciones de CPU para Intel en sistemas de 64 bits multiarquitectura
`$ export {C,CXX}FLAGS='-O3 -march=i686 -mtune=pentium4'`

Optimizaciones de CPU para AMD en sistemas de 64 bits multiarquitectura
`$ export {C,CXX}FLAGS='-O3 -march=i686 -mtune=athlon-xp'`

Establecer la variable de entorno adecuada para pkg-config en sistemas de 64 bits multiarquitectura
`$ export PKG_CONFIG_PATH=/usr/lib/pkgconfig:/usr/local/lib/pkgconfig:/usr/share/pkgconfig:$PKG_CONFIG_PATH`

Establecer la ruta de búsqueda de directorios de librerías en sistemas de 64 bits multiarquitectura
`$ export LDFLAGS+=' -L/usr/lib -L/usr/local/lib -L/opt/gcc13/lib'`
Cada usuario tendrá que establecer la ruta de búsqueda de directorios, en función de la distribución que utilice.

Establecer la variable de entorno de uso de compilador en modo de 32 bits, en sistemas de 64 bits multiarquitectura
GCC
`$ export CC="gcc -m32" CXX="g++ -m32"`
Clang
`$ export CC="clang -m32" CXX="clang++ -m32"`

Parámetros adicionales para la versión de 64 bits

Establecer la ruta de búsqueda de directorios de librerías en sistemas de 64 bits multiarquitectura
`$ export LDFLAGS+=" -L/usr/lib64 -L/usr/local/lib64 -L/opt/gcc13/lib64"`
Cada usuario tendrá que establecer la ruta de búsqueda de directorios, en función de la distribución que utilice.

Establecer la variable de entorno de uso de compilador para Clang
`$ export CC=clang CXX=clang++`

Parámetros adicionales globales

Parámetros adicionales de eliminación de avisos en el proceso de compilación
`$ export {C,CXX}FLAGS+=' -w'`

Establecer el uso de enlazador dinámico para Mold
`$ export LDFLAGS+=' -fuse-ld=mold'`

Establecer el uso de enlazador dinámico para LLD
Clang
`$ export LDFLAGS+=' -fuse-ld=lld'`
Optimizaciones complementarias LTO/ThinLTO de LLD
`$ export LDFLAGS+=' -Wl,--lto-aa-pipeline=globals-aa -Wl,--lto-newpm-passes=memcpyopt'`
Optimizaciones complementarias LTO de LLD
`$ export LDFLAGS+=" -Wl,--lto-partitions=$(expr $(nproc) / 2)"`
Optimizaciones complementarias ThinLTO de LLD
`$ export LDFLAGS+=" -Wl,--thinlto-jobs=$(expr $(nproc) / 2)"`

Establecer la variable de entorno de uso de compilador para Clang
`$ export CC=clang CXX=clang++`

Extracción y Compilación de la versión de 32 bits

$
tar zxvf clinfo-3.0.23.01.25.tar.gz

$ cd clinfo-3.0.23.01.25

$ make

Instalación como root

$ su

# make install PREFIX=/usr MANDIR=/usr/share/man

# mv /usr/bin/clinfo{,32}

# make clean

Explicación de los comandos

mv /usr/bin/clinfo{,32} : Renombra el ejecutable de 32 bits a clinfo32, para que no sea sobrescrito por la instalación del ejecutable de 64 bits.

Compilación de la versión de 64 bits

 $ make

Instalación como root

$ su -c "make install PREFIX=/usr MANDIR=/usr/share/man"

Estadísticas de Compilación e Instalación de Clinfo

Estadísticas de Compilación e Instalación de Clinfo
CPU	AMD Ryzen 5 5500
MHz	3600 (BoostMax=4457)
RAM	32 GB
Sistema de archivos	XFS
Versión del Kernel	6.7.8-ml SMP PREEMPT_DYNAMIC x86_64
Modo de frecuencia de la CPU	powersave (balance performance)
Planificador de CPU	BORE
Versión de Glibc	2.39
Enlazador dinámico	LLD 18.1.0
Compilador	Clang 18.1.0
Parámetros de optimización de la versión de 32 bits	-03 -march=i686 -mtune=athlon-xp -fexperimental-new-pass-manager -mllvm -polly -mllvm -polly-vectorizer=stripmine -flto -funified-lto -Wl,--lto=thin -Wl,--thinlto-jobs=6 -Wl,--lto-aa-pipeline=globals-aa -Wl,--lto-newpm-passes=memcpyopt
Parámetros de optimización de la versión de 64 bits	-03 -march=znver3 -mtune=znver3 -fexperimental-new-pass-manager -mllvm -polly -mllvm -polly-vectorizer=stripmine -flto -funified-lto -Wl,--lto=thin -Wl,--thinlto-jobs=6 -Wl,--lto-aa-pipeline=globals-aa -Wl,--lto-newpm-passes=memcpyopt
Parámetros de compilación	-j12
Tiempo de compilación	2"
Archivos instalados	3
Archivos instalados
Ocupación de espacio en disco	312 KB

Desinstalación como root

1) MODO TRADICIONAL

Este paquete no tiene soporte para desinstalación con el comando 'make uninstall'

2) MODO MANUALINUX

clinfo-3.0.23.01.25-scripts.tar.gz

$ su

# tar zxvf clinfo-3.0.23.01.25-scripts.tar.gz

# cd clinfo-3.0.23.01.25-scripts

# ./Desinstalar_clinfo-3.0.23.01.25

Copia de Seguridad como root

$ su

# tar zxvf clinfo-3.0.23.01.25-scripts.tar.gz

# cd clinfo-3.0.23.01.25-scripts

# ./Respaldar_clinfo-3.0.23.01.25

Restaurar la Copia de Seguridad como root

$ su

# cd /var/copibin/restaurar_copias

# ./Restaurar_clinfo-3.0.23.01.25

Configurar el inicio de AMDGPU

1) Comprobar que el kernel ha sido compilado con el soporte de AMDGPU
2) Comprobar que tenemos el firmware de AMDGPU instalado
3) Configurar el DPI y el Gamma de la pantalla

1) Comprobar que el kernel ha sido compilado con el soporte de AMDGPU

Tanto el código fuente original del kernel, cómo los que instalan las distribuciones, llevan activado por defecto el soporte del controlador amdgpu del DRM. Basta ejecutar el siguiente comando en la terminal para ver que el kernel en curso, tiene compilado este soporte. Un ejemplo con Debian.

$ cat /boot/config-6.2.10-ml | grep 'CONFIG_DRM_AMDGPU=m'

CONFIG_DRM_AMDGPU=m

Si el comando no mostrara ningún resultado, es que no tenemos compilado el soporte. Y para asegurarnos más, nos vamos a /lib/modules/[versión del kernel]/kernel/drivers/gpu/drm, y comprobamos que no existe ningún directorio con el nombre amd. Como por ejemplo, era mi caso, con un kernel personalizado, con lo que tuve que recompilar el kernel, activando la compilación del módulo en la correspondiente sección de configuración, en la ruta Device Drivers >> Graphics support >> AMD GPU, como se muestra en la captura de pantalla:

2) Comprobar que tenemos el firmware de AMDGPU instalado

Sin el firmware de nuestra tarjeta gráfica ubicado en /lib/firmware/amdgpu, el módulo del kernel no se cargará nunca. Por lo general, las distribuciones incluyen este firmware. En aquellos que nos compilamos todo desde cero, basta tener los archivos de firmware necesarios para la tarjeta gráfica que tengamos. Un ejemplo con la AMD Radeon RX 580 2048SP:

$ [jose@localhost amdgpu]$ ls

polaris10_ce_2.bin    polaris10_me_2.bin    polaris10_pfp_2.bin  polaris10_smc_sk.bin

polaris10_ce.bin     
polaris10_me.bin     
polaris10_pfp.bin    polaris10_uvd.bin

polaris10_k2_smc.bin  polaris10_mec2_2.bin  polaris10_rlc.bin    polaris10_vce.bin

polaris10_k_mc.bin    polaris10_mec_2.bin   polaris10_sdma1.bin

polaris10_k_smc.bin   polaris10_mec2.bin    polaris10_sdma.bin

polaris10_mc.bin      polaris10_mec.bin     polaris10_smc.bin

3) Configurar el DPI y el Gamma de la pantalla

Para saber el DPI de nuestro monitor, basta irse a este enlace, introducir la resolución nativa del mismo y el tamaño en pulgadas de la pantalla. Ejemplo: 1920x1080 + 21.5 pulgadas = 102.46 ppp. Que trasladado en milimetros al archivo de configuración de Xorg es un tamaño de monitor de 477mm x 268mm y un DPI redondeado (no se admiten decimales) de 102, cuya información nos mostrará el archivo de registro de inicio del servidor gráfico, si configuramos correctamente dicho archivo.

Y lo establecemos en la sección dedicada al monitor en el dicho archivo. Un ejemplo que pongo a continuación (lo que está en rojo y en negrita). Si no tenemos archivo de configuración de Xorg. Lo podemos crear con el comando Xorg -configure, como root desde una terminal, que creará un archivo con el nombre xorg.conf.new en el directorio del root. Luego lo podemos copiar a /etc/X11/xorg.conf y editarlo porque puede darnos problema alguna configuración del mismo.

Respecto al gamma, basta añadirlo en la sección correspondiente del monitor, Las opciones adicionales que aparecen en rojo y negrita, son las del nombre del controlador y las dos últimas están relacionadas con la latencia, que es mayor si está activado la rotación y volteo de la pantalla, con lo que, lo recomendable es desactivarlas.

Section "ServerLayout"

    Identifier     "X.org Configured"

    Screen      0  "Screen0" 0 0

    Screen      1  "Screen1" RightOf "Screen0"

    InputDevice    "Mouse0" "CorePointer"

    InputDevice    "Keyboard0" "CoreKeyboard"

EndSection



Section "Files"

    ModulePath   "/usr/lib64/xorg/modules"

    FontPath     "/usr/share/fonts/misc:unscaled"

    FontPath     "/usr/share/fonts/TTF"

    FontPath     "/usr/share/fonts/OTF"

    FontPath     "/usr/share/fonts/Type1"

    FontPath     "/usr/share/fonts/75dpi:unscaled"

    FontPath     "/usr/share/fonts/100dpi:unscaled"

EndSection



Section "Module"

    Load  "glx"

EndSection



Section "InputDevice"

    Identifier  "Keyboard0"

    Driver      "kbd"

EndSection



Section "InputDevice"



    # generated from default

    Identifier     "Mouse0"

    Driver         "mouse"

    Identifier "Mouse1"

    Driver "mouse"

    Option "Device" "/dev/mouse"

    Option "Protocol" "ExplorerPS/2"

EndSection



Section "Monitor"

    Identifier     "Monitor0"

    VendorName     "Unknown"

    DisplaySize 477 268

    ModelName "Flat Panel 1920x1080"

    HorizSync 31.5 - 67.0

    VertRefresh 56.0 - 65.0

    Gamma 0.50

EndSection



Section "Device"

    Identifier     "Device0"

    Driver "amdgpu"

    Option "EnablePageFlip" "off"

    Option "TearFree" "false"

EndSection



Section "Screen"

    Identifier     "Screen0"

    Device         "Device0"

    Monitor        "Monitor0"

    DefaultDepth    24

    Subsection "Display"

        Depth 8

        Modes "1920x1080" 

    EndSubsection

    

    Subsection "Display"

        Depth 16

        Modes "1920x1080" 

    EndSubsection

    

    Subsection "Display"

        Depth 24

        Modes "1920x1080" 

    EndSubsection

EndSection

Pero AMDGPU (lo mismo que con nouveau) omite el DPI que establezcamos en dicho archivo, dejándolo en 96 ppp. como muestra el mismo archivo de registro de ejecución de Xorg, cambiando posteriormente al haber establecido el DPI en el mismo proceso de inicio, el tamaño de la pantalla.

[   913.549] (II) Initializing extension DRI2

[   913.549] (II) AMDGPU(0): Setting screen physical size to 508 x 285

La única solución pasa por hacerlo de forma manual, e incluir el comando de ejecución de Xrandr en los scripts de inicio del servidor gráfico X, en unos casos, en otros se le puede pasar la opción -dpi "valor" al ejecutable Xorg. Con Qingy y SLiM lo podemos hacer de una manera muy fácil, pero aún así en estos casos concretos, la ejecución con el comando startx en el primero, también debería de tener el correspondiente comando de ejecución en el archivo personal ~/.xinitrc.

Una vez sabemos el DPI, sólo nos queda saber el identificador de conexión de nuestro monitor. Abrimos una ventana de terminal y ejecutamos el comando xrandr sin ninguna opción añadida.

[jose@localhost ~]$ xrandr

Screen 0: minimum 320 x 200, current 1920 x 1080, maximum 16384 x 16384

DisplayPort-0 disconnected primary (normal left inverted right x axis y axis)

DisplayPort-1 disconnected (normal left inverted right x axis y axis)

HDMI-A-0 connected 1920x1080+0+0 (normal left inverted right x axis y axis) 476mm x 268mm

   1920x1080     60.00*+  50.00    59.94  

   1680x1050     59.88  

   1600x900      60.00  

   1280x1024     75.02    60.02  

   1440x900      60.00  

   1280x800      59.91  

   1152x864      75.00  

   1280x720      60.00    50.00    59.94  

   1024x768      75.03    60.00  

   832x624       74.55  

   800x600       75.00    60.32  

   720x576       50.00  

   720x480       60.00    59.94  

   640x480       75.00    60.00    59.94  

   720x400       70.08

Como se puede ver en el ejemplo, el identificador en este caso, es HDMI-A-0, que es la entrada de la tarjeta gráfica a la que tengo conectado el monitor con un cable HDMI. Y ahora sólo queda configurar el comando de ejecución, que vamos a probar de forma directa, en la misma ventana de terminal:

$ xrandr --dpi 102/HDMI-A-0

Con el comando xdpyinfo, comprobamos el DPI que hemos establecido con el comando xrandr. Ejecutando un programa como MuPDF también lo podemos saber de forma visual, ya que en el título de la ventana del mismo nos muestra siempre el DPI actual de la pantalla, cuando abrimos un archivo PDF con el mismo.

[jose@localhost ~]$ xdpyinfo | grep resolution

  resolution:    102x102 dots per inch

Una vez tenemos el comando correspondiente, configuramos su ejecución al inicio del entorno gráfico correspondiente:

Tener en cuenta que dichos archivos de ejecución suelen ser sustituidos cada vez que se actualiza Xorg y sus componentes a una nueva versión, con lo que, tendremos que volver a editarlos introduciendo el comando correspondiente en los mismos. Un ejemplo con las distribuciones que tengo instaladas en mi ordenador, incluyendo también los administradores de sesiones cuya documentación se encuentra disponible en esta web. Configuramos el comando de ajuste de DPI y Gamma utilizando el comando según el script de inicio correspondiente.

Los usuarios que no tengan problemas con la configuración del gamma en el archivo /etc/X11/xorg.conf omitirán toda la información relativa al mismo, en los comandos que se explican a continuación.

DPI con xrandr

/usr/bin/xrandr --dpi 102/HDMI-A-0 --output HDMI-A-0

1) Para los que inician X desde terminal con el comando startx

Editamos el archivo ~/.xinitrc que se encuentra en nuestro home, si no existe lo creamos, y añadimos lo que está en rojo antes del comando de ejecución del entorno gráfico:

xrandr --dpi 102/HDMI-A-0 --output HDMI-A-0

exec /opt/e17/bin/enlightenment_start

2) XDM

Editamos el archivo ~/.xsession que se encuentra en nuestro home, si no existe lo creamos, y añadimos lo que está en rojo antes del comando de ejecución del entorno gráfico:

xrandr --dpi 102/HDMI-A-0 --output HDMI-A-0

exec /opt/e17/bin/enlightenment_start

3) OpenMandriva y PCLinuxOS

Abrimos como root, con un editor de texto el script de shell, /usr/share/X11/xdm/Xsetup_0 y añadimos lo que está en color rojo. El contenido del script puede variar de una distribución a otra, pero el final del mismo es idéntico. Tener en cuenta que dichos archivos de ejecución suelen ser sustituidos cada vez que se actualiza Xorg y sus componentes a una nueva versión, con lo que, tendremos que volver a editarlos introduciendo el comando correspondiente en los mismos.

#!/bin/sh

# (C) MandrakeSoft

# Chmouel Boudjnah <chmouel@mandrakesoft.com>

#

# $Id: Xsetup_0,v 1.12 2005/06/12 14:35:57 flepied Exp $



if [ -x /etc/X11/xinit/fixkeyboard ]; then

    /etc/X11/xinit/fixkeyboard

fi



if [ -x /etc/X11/xinit.d/numlock ]; then

    /etc/X11/xinit.d/numlock &

fi



for i in /etc/X11/xsetup.d/*.xsetup ; do

    [ -d $i ] && continue



    if [ -x $i ]; then

    if grep -q "# to be sourced" $i; then

        . $i

    else

        $i &

    fi

    fi

done



if [ -f /usr/share/mdk/backgrounds/default.png ] && [ -f /usr/bin/xloadimage ]; then

    /usr/bin/xloadimage -onroot -fullscreen /usr/share/mdk/backgrounds/default.png &

fi



/usr/bin/xrandr --dpi 102/HDMI-A-0 --output HDMI-A-0



# Xsetup_0 ends here

4) SDDM en Slackware y derivados

Abrimos como root, con un editor de texto el script de shell, /usr/share/sddm/scripts/Xsession y añadimos lo que está en color rojo, al principio del mismo:

#! /bin/sh

# Xsession - run as user

# Copyright (C) 2016 Pier Luigi Fiorini <pierluigi.fiorini@gmail.com>



# This file is extracted from kde-workspace (kdm/kfrontend/genkdmconf.c)

# Copyright (C) 2001-2005 Oswald Buddenhagen <ossi@kde.org>



/usr/bin/xrandr --dpi 102/HDMI-A-0 --output HDMI-A-0



# Note that the respective logout scripts are not sourced.

case $SHELL in

  */bash)

5) LightDM en Debian

Abrimos como root, con un editor de texto el script de shell, /etc/X11/Xsession y añadimos lo que está en color rojo, en las primeras líneas del archivo.

#!/bin/sh

#

# /etc/X11/Xsession

#

# global Xsession file -- used by display managers and xinit (startx)



# $Id: Xsession 967 2005-12-27 07:20:55Z dnusinow $



set -e



PROGNAME=Xsession



/usr/bin/xrandr --dpi 102/HDMI-A-0 --output HDMI-A-0



message () {

  # pretty-print messages of arbitrary length; use xmessage if it

  # is available and $DISPLAY is set

  MESSAGE="$PROGNAME: $*"

  echo "$MESSAGE" | fold -s -w ${COLUMNS:-80} >&2

  if [ -n "$DISPLAY" ] && which xmessage > /dev/null 2>&1; then

    echo "$MESSAGE" | fold -s -w ${COLUMNS:-80} | xmessage -center -file -

  fi

}

6) Qingy

Editamos el archivo de configuración de Qingy y añadimos lo que está en rojo en la línea correspondiente relativa a las opciones de inicio del servidor gráfico X.


# Parámetros a pasar al servidor X (para más información ejecutar man Xorg)

x_args = "-nolisten inet6 -deferglyphs 16 -nolisten tcp -br -dpi 102"

7) SLiM

Editamos el archivo .xinitrc de nuestro home previamente configurado para SLiM y añadimos el comando de ejecución al mismo. El problema de añadir el comando a este archivo, es que el brillo del administrador de sesión no lo podemos cambiar, sólo el de la sesión que utilicemos, por eso lo mejor y más recomendable es probar con los script de shell de ejecución del servidor gráfico X.

# La siguiente variable define la sesión que será iniciada si el usuario

# no elige de forma explícita una sesión

DEFAULT_SESSION=enlightenment_start



xrandr --dpi 102/HDMI-A-0 --output HDMI-A-0



case
$1 in

XFce4)


    exec startxfce4

    ;;

IceWM)

    exec icewm-session

    ;;

WindowMaker)

    exec wmaker

    ;;

Blackbox)

    exec startblackbox

    ;;

Fluxbox)

    exec startfluxbox

    ;;

;">E17)

  
 exec enlightenment_start

  
 ;;

E16)

    exec starte16

    ;;

Openbox)

    exec openbox-session

    ;;

Pekwm)

    exec pekwm

    ;;

ROX)

    exec rox-session

    ;;

AfterStep)

    exec afterstep

    ;;

*)

    exec $DEFAULT_SESSION

    ;;

esac

El DPI se lo podemos pasar también al archivo de configuración global, /etc/slim.conf, en el apartado correspondiente.

# Ruta al servidor X y argumentos (si es necesario)

# Nota: -xauth $authfile es automáticamente añadido

default_path        ./:/bin:/usr/X11R7/bin:/usr/bin:/usr/local/bin

default_xserver     /usr/X11R7/bin/X

xserver_arguments   -nolisten inet6 -deferglyphs 16 -nolisten tcp -dpi 102

Tener en cuenta que el ajuste del DPI del monitor en lo que respecta al servidor gráfico X tiene que ir acompañado siempre de un ajuste global en entornos de escritorio que lo soporten, archivo de configuración ~.Xdefaults, etc. Un ejemplo de archivo de configuración que tendríamos que tener en cuenta al respecto para un monitor LCD.

~/.Xdefaults

Xft.dpi: 102

Xft.rgba: rgb

Xft.hinting: 1

Xft.hintstyle: hintmedium

Xft.lcdfilter: lcddefault

Iniciamos AMDGPU

Finalmente reiniciamos el sistema y cuando se inicie el servidor gráfico X, comprobamos que todo funciona bien, realizando las pruebas pertinentes.

1) Comprobar la carga del módulo del kernel

[jose@localhost ~]$ dmesg | grep amdgpu

[   12.198111] [drm] amdgpu kernel modesetting enabled.

[   12.200911] amdgpu 0000:01:00.0: No more image in the PCI ROM

[   12.200927] amdgpu 0000:01:00.0: amdgpu: Fetched VBIOS from ROM BAR

[   12.200928] amdgpu: ATOM BIOS: xxx-xxx-xxx

[   12.201019] amdgpu 0000:01:00.0: vgaarb: deactivate vga console

[   12.201021] amdgpu 0000:01:00.0: amdgpu: Trusted Memory Zone (TMZ) feature not supported

[   12.371715] amdgpu 0000:01:00.0: amdgpu: VRAM: 8192M 0x000000F400000000 - 0x000000F5FFFFFFFF (8192M used)

[   12.371718] amdgpu 0000:01:00.0: amdgpu: GART: 256M 0x000000FF00000000 - 0x000000FF0FFFFFFF

[   12.371768] [drm] amdgpu: 8192M of VRAM memory ready

[   12.371769] [drm] amdgpu: 15958M of GTT memory ready.

[   12.613595] amdgpu: hwmgr_sw_init smu backed is polaris10_smu

[   12.719450] snd_hda_intel 0000:01:00.1: bound 0000:01:00.0 (ops amdgpu_dm_audio_component_bind_ops [amdgpu])

[   12.875760] amdgpu 0000:01:00.0: amdgpu: SE 4, SH per SE 1, CU per SH 9, active_cu_number 32

[   12.879116] amdgpu 0000:01:00.0: amdgpu: Using BACO for runtime pm

[   12.879262] [drm] Initialized amdgpu 3.49.0 20150101 for 0000:01:00.0 on minor 0

[   12.889647] fbcon: amdgpudrmfb (fb0) is primary device

[   13.010536] amdgpu 0000:01:00.0: [drm] fb0: amdgpudrmfb frame buffer device

2) Comprobar los sensores del modulo amdgpu

[jose@localhost ~]$ sensors | grep -A 5 amdgpu

amdgpu-pci-0100

Adapter: PCI adapter

vddgfx:      725.00 mV 

fan1:         865 RPM  (min =    0 RPM, max = 3500 RPM)

edge:         +26.0°C  (crit = +94.0°C, hyst = -273.1°C)

PPT:          15.20 W  (cap = 125.00 W)

3) Comprobar la carga del controlador gráfico para el servidor gráfico X

[jose@localhost ~]$ cat /var/log/Xorg.1.log | grep 'amdgpu'

[  1002.483] (II) LoadModule: "amdgpu"

[  1002.483] (II) Loading /usr/lib64/xorg/modules/drivers/amdgpu_drv.so

[  1002.512] (II) Module amdgpu: vendor="X.Org Foundation"

    All GPUs supported by the amdgpu kernel driver

4) Comprobar la carga del módulo GLX del servidor gráfico X que proporciona aceleración OpenGL por hardware al mismo

[jose@localhost ~]$ cat /var/log/Xorg.1.log | grep 'GLX:'

[  1004.320] (II) AIGLX: Loaded and initialized radeonsi

[  1004.320] (II) GLX: Initialized DRI2 GL provider for screen 0

Añadiendo la opción Option "AIGLX" "false" al archivo de configuración de Xorg en su correspondiente sección, la aceleración será por software, por si la primera nos da problemas.

Section "ServerFlags"

    Option "AIGLX" "false"

EndSection

5) Comprobar la disponibilidad de aceleración por hardware VDPAU para la decodificación de vídeo con el comando vdpauinfo

[jose@localhost ~]$ vdpauinfo

display: :1.0   screen: 0

API version: 1

Information string: G3DVL VDPAU Driver Shared Library version 1.0



Video surface:



name   width height types

-------------------------------------------

420    16384 16384  NV12 YV12 

422    16384 16384  UYVY YUYV 

444    16384 16384  Y8U8V8A8 V8U8Y8A8 

420_16 16384 16384  

422_16 16384 16384  

444_16 16384 16384  



Decoder capabilities:



name                       
level macbs width height

----------------------------------------------------

MPEG1                         
--- not supported ---

MPEG2_SIMPLE                   
3 65536  4096  4096

MPEG2_MAIN                     
3 65536  4096  4096

H264_BASELINE                 
52 65536  4096  4096

H264_MAIN                     
52 65536  4096  4096

H264_HIGH                     
52 65536  4096  4096

VC1_SIMPLE                     
1 65536  4096  4096

VC1_MAIN                       
2 65536  4096  4096

VC1_ADVANCED                   
4 65536  4096  4096

MPEG4_PART2_SP                 
3 65536  4096  4096

MPEG4_PART2_ASP                
5 65536  4096  4096

DIVX4_QMOBILE                 
--- not supported ---

DIVX4_MOBILE                  
--- not supported ---

DIVX4_HOME_THEATER             --- not supported ---

DIVX4_HD_1080P                
--- not supported ---

DIVX5_QMOBILE                 
--- not supported ---

DIVX5_MOBILE                  
--- not supported ---

DIVX5_HOME_THEATER             --- not supported ---

DIVX5_HD_1080P                
--- not supported ---

H264_CONSTRAINED_BASELINE       0 65536  4096  4096

H264_EXTENDED                 
--- not supported ---

H264_PROGRESSIVE_HIGH          --- not supported ---

H264_CONSTRAINED_HIGH          --- not supported ---

H264_HIGH_444_PREDICTIVE       --- not supported ---

VP9_PROFILE_0                 
--- not supported ---

VP9_PROFILE_1                 
--- not supported ---

VP9_PROFILE_2                 
--- not supported ---

VP9_PROFILE_3                 
--- not supported ---

HEVC_MAIN                     
186 65536  4096  4096

HEVC_MAIN_10                  
186 65536  4096  4096

HEVC_MAIN_STILL                --- not supported ---

HEVC_MAIN_12                  
--- not supported ---

HEVC_MAIN_444                 
--- not supported ---

HEVC_MAIN_444_10               --- not supported ---

HEVC_MAIN_444_12               --- not supported ---

AV1_MAIN                      
--- not supported ---

AV1_HIGH                      
--- not supported ---

AV1_PROFESSIONAL               --- not supported ---



Output surface:



name              width height nat types

----------------------------------------------------

B8G8R8A8         16384
16384    y  NV12 YV12 UYVY YUYV Y8U8V8A8 V8U8Y8A8
P010 P016 I8A8 

R8G8B8A8         16384
16384    y  NV12 YV12 UYVY YUYV Y8U8V8A8 V8U8Y8A8
P010 P016 I8A8 

R10G10B10A2      16384 16384   
y  NV12 YV12 UYVY YUYV Y8U8V8A8 V8U8Y8A8 P010 P016 I8A8 

B10G10R10A2      16384 16384   
y  NV12 YV12 UYVY YUYV Y8U8V8A8 V8U8Y8A8 P010 P016 I8A8 



Bitmap surface:



name              width height

------------------------------

B8G8R8A8         16384 16384

R8G8B8A8         16384 16384

R10G10B10A2      16384 16384

B10G10R10A2      16384 16384

A8               16384 16384



Video mixer:



feature
name                   
sup

------------------------------------

DEINTERLACE_TEMPORAL             y

DEINTERLACE_TEMPORAL_SPATIAL     -

INVERSE_TELECINE                 -

NOISE_REDUCTION                  y

SHARPNESS                       
y

LUMA_KEY                        
y

HIGH QUALITY SCALING - L1        y

HIGH QUALITY SCALING - L2        -

HIGH QUALITY SCALING - L3        -

HIGH QUALITY SCALING - L4        -

HIGH QUALITY SCALING - L5        -

HIGH QUALITY SCALING - L6        -

HIGH QUALITY SCALING - L7        -

HIGH QUALITY SCALING - L8        -

HIGH QUALITY SCALING - L9        -



parameter
name                 
sup      min      max

-----------------------------------------------------

VIDEO_SURFACE_WIDTH             
y        48    
4096

VIDEO_SURFACE_HEIGHT            
y        48    
4096

CHROMA_TYPE                     
y  

LAYERS                          
y        
0        4



attribute
name                 
sup      min      max

-----------------------------------------------------

BACKGROUND_COLOR                 y  

CSC_MATRIX                      
y  

NOISE_REDUCTION_LEVEL           
y      0.00     1.00

SHARPNESS_LEVEL                 
y     -1.00     1.00

LUMA_KEY_MIN_LUMA                y  

LUMA_KEY_MAX_LUMA                y

Para probar las bondades de dicha aceleración y compararla con la que teníamos con el controlador de gráficos original de NVIDIA, utilizaremos MPlayer con el siguiente comando:

$ mplayer -nofs -vo vdpau -vc ffmpeg12vdpau,ffwmv3vdpau,ffvc1vdpau,ffh264vdpau,ffodivxvdpau ejemplo.mkv

Para hacerlo permanente, editamos el archivo de configuración de MPlayer y descomentamos la línea 162:

[vo.vdpau]

vc=ffmpeg12vdpau,ffwmv3vdpau,ffvc1vdpau,ffh264vdpau,ffodivxvdpau,

# Most video filters do not work with vdpau.

#vf-clr=yes

Podemos probar también las opciones de eliminación de ruido y ajuste de nitidez, que proporcionan el firmware de la tarjeta gráfica, aunque mi experiencia personal no es muy satisfactoria. Es evidente que el controlador de gráficos original funciona bastante mejor en este aspecto.

$ mplayer -v -nofs -vo vdpau:denoise=0.2:sharpen=0.3 \

-vc ffmpeg12vdpau,ffwmv3vdpau,ffvc1vdpau,ffh264vdpau,ffodivxvdpau ejemplo.mkv

6) Comprobar la disponibilidad de aceleración por hardware VA-API para la decodificación de vídeo con el comando vainfo

Si nuestra tarjeta gráfica soporta aceleración por hardware para la decodificación de MPEG4 (lo sabremos ya con el comando vdpauinfo), tendremos que añadir la siguiente variable de entorno a nuestro archivo de configuración personal de Bash, ~/.bashrc, si no existe lo creamos.

export VAAPI_MPEG4_ENABLED=1

Cuando lo hayamos hecho, ejecutamos el comando correspondiente para comprobar el soporte de aceleración por hardware VA-API.

[jose@localhost ~]$ vainfo

Trying display: wayland

Trying display: x11

libva info: VA-API version 1.20.0

libva info: Trying to open /usr/lib64/dri/radeonsi_drv_video.so

libva info: Found init function __vaDriverInit_1_20

libva info: va_openDriver() returns 0

vainfo: VA-API version: 1.20 (libva 2.20.0)

vainfo: Driver version: Mesa Gallium driver 24.0.2 for AMD Radeon RX
580 2048SP (radeonsi, polaris10, LLVM 18.1.0, DRM 3.57, 6.7.8-ml)

vainfo: Supported profile and entrypoints

     
VAProfileMPEG2Simple           
:    VAEntrypointVLD

     
VAProfileMPEG2Main             
:    VAEntrypointVLD

     
VAProfileMPEG4Simple           
:    VAEntrypointVLD

      VAProfileMPEG4AdvancedSimple    :    VAEntrypointVLD

     
VAProfileVC1Simple             
:    VAEntrypointVLD

     
VAProfileVC1Main               
:    VAEntrypointVLD

     
VAProfileVC1Advanced           
:    VAEntrypointVLD

      VAProfileH264ConstrainedBaseline:    VAEntrypointVLD

      VAProfileH264ConstrainedBaseline:    VAEntrypointEncSlice

     
VAProfileH264Main              
:    VAEntrypointVLD

     
VAProfileH264Main              
:    VAEntrypointEncSlice

     
VAProfileH264High              
:    VAEntrypointVLD

     
VAProfileH264High              
:    VAEntrypointEncSlice

     
VAProfileHEVCMain              
:    VAEntrypointVLD

     
VAProfileHEVCMain              
:    VAEntrypointEncSlice

     
VAProfileHEVCMain10            
:    VAEntrypointVLD

     
VAProfileJPEGBaseline          
:    VAEntrypointVLD

     
VAProfileNone                  
:    VAEntrypointVideoProc

MPlayer no soporta VA-API de forma nativa. Tendremos que utilizar VLC o mpv con SMPlayer.

En línea de comandos con mpv sería lo siguiente:

$ mpv --vo=vaapi --hwdec=vaapi archivo.mkv

7) Comprobar las capacidades OpenGL del sistema con el comando glxinfo

[jose@localhost ~]$ glxinfo | grep 'OpenGL '

OpenGL vendor string: AMD

OpenGL renderer string: AMD Radeon RX 580 2048SP (radeonsi, polaris10, LLVM 18.1.0, DRM 3.57, 6.7.8-ml)

OpenGL core profile version string: 4.6 (Core Profile) Mesa 24.0.2

OpenGL core profile shading language version string: 4.60

OpenGL core profile context flags: (none)

OpenGL core profile profile mask: core profile

OpenGL core profile extensions:

OpenGL version string: 4.6 (Compatibility Profile) Mesa 24.0.2

OpenGL shading language version string: 4.60

OpenGL context flags: (none)

OpenGL profile mask: compatibility profile

OpenGL extensions:

OpenGL ES profile version string: OpenGL ES 3.2 Mesa 24.0.2

OpenGL ES profile shading language version string: OpenGL ES GLSL ES 3.20

OpenGL ES profile extensions:

Para una comprobación visual podemos ejecutar cualquiera de los programas de ejemplo instalados con el paquete Mesa demos (glxgears, cuberender, etc.)

Aceleración 3D por software con LLVMpipe

Una de las grandes ventajas de AMDGPU y Mesa respecto a un controlador como el de NVIDIA, es la posibilidad que nos ofrece de hacer uso de la aceleración 3D por software, lo que coloquialmente entendemos como "tirar de CPU", allí donde tengamos problemas de uso de la predefinida aceleración por hardware. A primera vista puede parecer contraproducente defender el uso de este tipo de aceleración, pero un simple ejemplo práctico, nos confirmará su beneficio indudable. La versión de 32 bits del editor de vídeo, Shotcut para Windows, se cuelga literalmente cuando utilizo la aceleración por hardware, al abrir un archivo de vídeo, y funciona sin ningún problema cuando hago uso de la aceleración por software.

Para cualquier tipo de representación en 2D, normalmente nos referimos siempre a ventanas de visualización de vídeo o imagen, este tipo de aceleración nos puede venir muy bien, allí donde la otra nos dé problemas. En el caso de juegos, es evidente que no es la mejor opción posible.

Si hemos compilado Mesa con las opciones de configuración establecidas en este manual, dispondremos de dos controladores Gallium para la aceleración por software: LLVMpipe y Softpipe. El más potente y el que se carga de forma predefinida es LLVMpipe, que es capaz de aprovechar la capacidad multinúcleo de los procesadores modernos en combinación con LLVM. Está optimizado para sistemas de 64 bits, pero lo podemos utilizar también en sistemas de 32 bits sin ningún tipo de problema.

1) Establecer la aceleración 3D por software con la correspondiente variable de entorno

Existen dos formas de establecer la aceleración por software mediante el uso de la variable de entorno definida para ello, una es mediante el uso del comando export antes de ejecutar la aplicación, la otra es escribiendo la variable de entorno justo delante del comando de ejecución de la aplicación, es decir esto:

$ export LIBGL_ALWAYS_SOFTWARE=1

$ briquolo

Es lo mismo que esto:

$ LIBGL_ALWAYS_SOFTWARE=1 briquolo

Si tenemos pensado crear scripts de shell, basta incluir la variable antes del comando de ejecución del programa, un ejemplo:

#!/bin/sh



export LIBGL_ALWAYS_SOFTWARE=1



briquolo

Para comprobar que estamos utilizando la aceleración por software, utilizaremos el programa glxinfo para ello.

[jose@localhost ~]$ glxinfo | grep "renderer string"

OpenGL renderer string: llvmpipe (LLVM 18.1.0, 256 bits)

Configurar la aceleración 3D con Adriconf

Adriconf es una interfaz gráfica de configuración para las opciones de aceleración 3D que soporte el controlador DRI de nuestra tarjeta gráfica y heredera de la abandonada DRIconf. Entre otra serie de opciones, podremos hacer uso de los filtros de suavizado de bordes, lo que en inglés se denomina antialiasing, creados por el español Jorge Jiménez, con el nombre de Jimenez's MLAA e introducidos en las librerías Mesa a partir de la versión 8.

Si los queremos probar desde línea de comandos, o mediante scripts de shell, basta establecer las correspondientes variables de entorno, teniendo en cuenta que el valor establecido tendrá que estar comprendido entre 2 y 32, aunque por encima de 16, los efectos son inapreciables. Procurar también no utilizarlos al mismo tiempo, porque el resultado puede llegar a ser catastrófico para el rendimiento de la aplicación, aunque es la combinación de los dos la que mejor resultado da sin lugar a dudas. Donde no funcionan los dos juntos es en aplicaciones o juegos de Windows ejecutados con Wine, que utilicen Direct3D. Si utilizan OpenGL ningún problema.

De los dos filtros disponibles, pp_jimenezmlaa y pp_jimenezmlaa_color, uno aplica el suavizado sobre la profundidad de la escena y el otro sobre el color, produciendo este último un efecto de borrosidad sobre el texto contenido en la misma. Tener en cuenta que cualquier aplicación de estos filtros, en determinadas condiciones, puede llegar a suponer una ralentización considerable en determinados juegos o aplicaciones. Un valor de 8 puede llegar a ser medianamente aceptable en la mayoría de los casos. En el caso de pp_jimenezmlaa_color, puede ser utilizado en representaciones en 2D.

Para probarlos desde línea de comandos o mediante script de shell, establecemos las correspondientes variables de entorno, antes de ejecutar la aplicación correspondiente, en este caso estableceríamos el valor a 16.

$ export pp_jimenezmlaa=16

$ export pp_jimenezmlaa_color=16

Aunque siempre es mejor crear los correspondientes alias o funciones de Bash, para facilitarnos las cosas. En este caso añado también la variable de entorno de depuración de los filtros de postprocesado para que muestren más información de lo que están haciendo, y por último, añado un alias que activa un gráfico en la esquina superior izquierda de la pantalla del juego, que nos mostrará la velocidad de fotogramas de segundo del mismo.

Abrimos con un editor de texto, el archivo de configuración de Bash, ~/.bashrc, si no existe lo creamos, y añadimos lo siguiente:

mlaa () { export pp_jimenezmlaa=$1 ; }

mlaa_color () { export pp_jimenezmlaa_color=$1 ; }

alias mlaa_debug="export PP_DEBUG=1"

alias opengl_fps="export GALLIUM_HUD=fps"

Ahora simplemente con escribir por ejemplo mlaa 16 ya estamos estableciendo la correspondiente variable de entorno de un filtro en concreto, y con un valor de 16. Lo mismo con mlaa_color 16, y para mostrar información de depuración, ejecutamos mlaa_debug. Y para comprobar el número de fotogramas por segundo en la misma pantalla del juego o de la aplicación, ejecutamos opengl_fps.

Instalación

Dependencias

Herramientas de Compilación

Entre paréntesis la versión con la que se ha instalado Adriconf para la elaboración de este documento.

* GCC - (13.2.0) o Clang - (18.1.0)
* CMake - (3.28.3)
* Ninja - (1.11.1)
* Gettext - (0.22.5)
* Pkg-config - (0.29.2)

Librerías de Desarrollo

* Xorg - (7.7 / xorg-server 21.1.11)
Libdrm - (2.4.120)
* GTKMM - (4.10.0)
* Libglvnd - (1.7.0)
* Mesa - (24.0.2)
* Pciutils - (3.11.1)
* Pugixml - (1.14)

Aplicaciones

* Wget - (1.21.4) [1]

[1] Requerido para poder descargarnos los iconos del archivo desktop desde internet.

Descarga

adriconf-v2.7.1.tar.bz2

Optimizaciones

Optimizaciones adicionales

Optimizaciones adicionales
GCC
Graphite
`$ export {C,CXX}FLAGS+=' -ftree-loop-linear -floop-strip-mine -floop-block'`
IPA
`$ export {C,CXX}FLAGS+=' -fipa-pta'`
LTO
`$ export {C,CXX}FLAGS+=' -fuse-linker-plugin -flto=auto'`
En versiones inferiores a GCC 10, sustituir auto por el número de núcleos que tenga nuestro procesador. Si sólo tiene uno, utilizar el parámetro -flto
Clang
Polly
`$ export {C,CXX}FLAGS+=' -O3 -mllvm -polly -mllvm -polly-vectorizer=stripmine'`
LTO
`$ export {C,CXX}FLAGS+=' -flto'`
ThinLTO
`$ export {C,CXX}FLAGS+=' -flto=thin'`
La aplicación de esta optimización es alternativa a la tradicional LTO, a partir de Clang 3.9 y, por lo tanto, no es combinable con la misma.
Unified LTO
LTO >> ThinLTO
`$ export {C,CXX}FLAGS+=' -flto -funified-lto' $ export LDFLAGS+=' -Wl,--lto=thin'`
ThinLTO >> LTO
`$ export {C,CXX}FLAGS+=' -flto=thin -funified-lto' $ export LDFLAGS+=' -Wl,--lto=full'`
La aplicación de esta optimización es aplicable, a partir de Clang 17, y sólo es combinable con LLD.

Parámetros adicionales

Parámetros adicionales de eliminación de avisos en el proceso de compilación
`$ export {C,CXX}FLAGS+=' -w'`

Establecer la ruta de búsqueda de directorios de librerías en sistemas de 64 bits multiarquitectura
`$ export LDFLAGS+=" -L/usr/lib64 -L/usr/local/lib64 -L/opt/gcc13/lib64"`
Cada usuario tendrá que establecer la ruta de búsqueda de directorios, en función de la distribución que utilice.

Establecer el uso de enlazador dinámico para Mold
`$ export LDFLAGS+=' -fuse-ld=mold'`

Establecer el uso de enlazador dinámico para LLD
Clang
`$ export LDFLAGS+=' -fuse-ld=lld'`
Optimizaciones complementarias LTO/ThinLTO de LLD
`$ export LDFLAGS+=' -Wl,--lto-aa-pipeline=globals-aa -Wl,--lto-newpm-passes=memcpyopt'`
Optimizaciones complementarias LTO de LLD
`$ export LDFLAGS+=" -Wl,--lto-partitions=$(expr $(nproc) / 2)"`
Optimizaciones complementarias ThinLTO de LLD
`$ export LDFLAGS+=" -Wl,--thinlto-jobs=$(expr $(nproc) / 2)"`

Establecer la variable de entorno de uso de compilador para Clang
`$ export CC=clang CXX=clang++`

Extracción y Configuración

$ tar zxvf adriconf-v2.7.1.tar.gz

$ cd adriconf-v2.7.1

$ cmake -S . -B build -DCMAKE_INSTALL_PREFIX=/usr -DENABLE_UNIT_TESTS=OFF -G Ninja

Explicación de los comandos

-S . -B build : Establece el directorio del código fuente y crea de forma automática el directorio de compilación.

-DCMAKE_INSTALL_PREFIX=/usr : Instala el programa en el directorio principal /usr.

-DENABLE_UNIT_TESTS=OFF : Desactiva la compilación de los tests del paquete.

-G Ninja : Utiliza Ninja en lugar de GNU Make para compilar el paquete (opcional).

Compilación

 ninja -C build

Parámetros de compilación opcionales

Instalación como root

$ su

# ninja -C build install/strip

# for i in /usr/share/icons/hicolor ; do \

install -dm755 $i/{16x16,24x24,32x32,48x48,64x64,128x128}/apps ; \

wget -c https://images.freeimages.com/fic/images/icons/1620/\

crystal_project/128/hardware.png -O $i/128x128/apps/adriconf.png ; \

wget -c https://images.freeimages.com/fic/images/icons/1620/\

crystal_project/64/hardware.png -O $i/64x64/apps/adriconf.png ; \

wget -c https://images.freeimages.com/fic/images/icons/1620/\

crystal_project/48/hardware.png -O $i/48x48/apps/adriconf.png ; \

wget -c https://images.freeimages.com/fic/images/icons/1620/\

crystal_project/32/hardware.png -O $i/32x32/apps/adriconf.png ; \

wget -c https://images.freeimages.com/fic/images/icons/1620/\

crystal_project/24/hardware.png -O $i/24x24/apps/adriconf.png ; \

wget -c https://images.freeimages.com/fic/images/icons/1620/\

crystal_project/16/hardware.png -O $i/16x16/apps/adriconf.png ; \

gtk-update-icon-cache -tf $i &> /dev/null ; \

done

Creación del archivo adriconf.desktop

Para que Adriconf sea detectado por los menús de entornos gráficos como XFce 4 o paneles como LXPanel o Fbpanel, creamos el correspondiente archivo desktop con cat o con un editor de texto:

# cat > adriconf.desktop << "EOF"

[Desktop Entry]

Name=Aceleración 3D

Comment=Cambia las opciones de aceleración 3D

Exec=adriconf

Icon=adriconf

Categories=Application;Settings;AdvancedSettings;

Type=Application


EOF

Luego, lo instalamos en /usr/share/applications. La desinstalación y respaldo de este archivo viene incluida en los scripts correspondientes proporcionados en este manual.

# install -dm755 /usr/share/applications

# install -m644 adriconf.desktop /usr/share/applications

Traducción al español

El soporte de locales por parte del programa es muy limitado, como se puede ver en la captura de pantalla, ya que los opciones de DRI no son traducibles.

Descarga

Adriconf_es-ML0.run

Firma Digital

Adriconf_es-ML0.run.asc

Verificar la firma digital del paquete

$ gpg --import manualinux.asc

$ gpg --verify Adriconf_es-ML0.run.asc Adriconf_es-ML0.run

Instalación como root

$ su -c "sh Adriconf_es-ML0.run"

Borrar las locales adicionales instaladas con la utilidad BleachBit

$ su -c "bleachbit -c system.localizations"

Estadísticas de Compilación e Instalación de Adriconf

Estadísticas de Compilación e Instalación de Adriconf
CPU	AMD Ryzen 5 5500
MHz	3600 (BoostMax=4457)
RAM	32 GB
Sistema de archivos	XFS
Versión del Kernel	6.7.8-ml SMP PREEMPT_DYNAMIC x86_64
Modo de frecuencia de la CPU	powersave (balance performance)
Planificador de CPU	BORE
Versión de Glibc	2.39
Enlazador dinámico	LLD 18.1.0
Compilador	Clang 18.1.0
Parámetros de optimización	-03 -march=znver3 -mtune=znver3 -mllvm -polly -mllvm -polly-vectorizer=stripmine -flto -funified-lto -Wl,--lto=thin -Wl,--thinlto-jobs=6 -Wl,--lto-aa-pipeline=globals-aa -Wl,--lto-newpm-passes=memcpyopt
Parámetros de compilación	-v -j12
Tiempo de compilación	5"
Archivos instalados	9
Archivos instalados
Ocupación de espacio en disco	436 KB

Desinstalación como root

1) MODO TRADICIONAL

Este paquete no tiene soporte para desinstalación con el comando 'ninja uninstall'

2) MODO MANUALINUX

adriconf-2.7.1-scripts.tar.gz

$ su

# tar zxvf adriconf-2.7.1-scripts.tar.gz

# cd adriconf-2.7.1-scripts

# ./Desinstalar_adriconf-2.7.1

Copia de Seguridad como root

$ su

# tar zxvf adriconf-2.7.1-scripts.tar.gz

# cd adriconf-2.7.1-scripts

# ./Respaldar_adriconf-2.7.1

Restaurar la Copia de Seguridad como root

$ su

# cd /var/copibin/restaurar_copias

# ./Restaurar_adriconf-2.7.1

Iniciamos Adriconf

Sólo nos queda teclear en una terminal o en un lanzador el comando adriconf, y el programa aparecerá en la pantalla. No olvidar que es el proceso lo que controla DRI, no el script de ejecución del mismo, en el caso de que lo utilicemos, ni tampoco el cargador, si por ejemplo, estamos utilizando Wine para ejecutar una aplicación de Windows.

Las opciones de aceleración 3D que se establezcan mediante la edición del archivo de configuración personal de DRI, siempre serán sobrescritas por las variables de entorno que establezca el usuario, ya sea en línea de comandos, script de shell, o cualquier otro medio para lanzar la aplicación. En el caso de la aceleración 3D por software, es la variable de entorno descrita en este manual la encargada de establecerla, ya que a través de DRI no es posible activar este tipo de aceleración.

Uso de OpenCL con AMDGPU

El soporte de OpenCL de AMDGPU, hasta que la interfaz Rusticl no esté madura, sigue siendo muy experimental, teniendo que recurrir a la vetusta interfaz Clover, limitada a OpenCL 1.1 (aunque admite también 1.2 con las correspondientes variables de entorno). Como es evidente, en este apartado se omite el uso de otras alternativas como ROCm u Orca. A continuación pongo algunos ejemplos de uso y las variables de entorno a establecer para su ejecución.

1) Clover con ImageMagick

Para poder hacer uso de OpenCL con ImageMagick, cuyas capacidades podemos encontrar en este enlace, tendremos que establecer las siguientes variables de entorno (con rusticl, de momento no es funcional).

$ export MAGICK_OCL_DEVICE=true cl_clang_storage_class_specifiers=1

Variables que podemos añadir a ~/.bashrc para que sean permanentes.

2) Activar Rusticl

La interfaz Rusticl no se activa por defecto, si ejecutamos el comando clinfo, veremos que no muestra ninguna tarjeta gráfica asociada al mismo.


[jose@localhost ~]$ clinfo | grep -A 1 rusticl

  Platform
Name                                  
rusticl

  Platform
Vendor                                
Mesa/X.org

--

  Platform
Name                                  
rusticl

Number of
devices                                
0

Para activarla, establecemos la correspondiente variable de entorno:


$ export RUSTICL_ENABLE=radeonsi

Y comprobamos que ahora sí hay una tarjeta gráfica asociada al mismo:

[jose@localhost ~]$ clinfo | grep -A 2 rusticl

  Platform
Name                                  
rusticl

  Platform
Vendor                                
Mesa/X.org

  Platform
Version                               
OpenCL 3.0 

--

  Platform
Name                                  
rusticl

Number of
devices                                
1

  Device
Name                                    
AMD Radeon RX 580 2048SP (polaris10, LLVM 16.0.3, DRM 3.52, 6.3.1-ml)

Y, para que ésta sea la interfaz predefinida para OpenCL, completamos la variable de entorno anterior, dejándola de esta manera:


$ export RUSTICL_ENABLE=radeonsi OCL_ICD_FILENAMES=libRusticlOpenCL.so

De momento, no he logrado que aplicaciones como ImageMagick o Darktable (esta ya lo es), por poner dos ejemplos, sean funcionales con esta interfaz. Que es el futuro es evidente, pero también lo es que le queda mucho por recorrer.

Crear un firmware personalizado para tener RGB completo en el puerto HDMI

Lamentablemente y, como siempre, a diferencia de Windows, en nuestro sistema no existe una forma de poder hacer uso del RGB completo (0-255 colores) en el puerto HDMI, con el controlador de gráficos AMDGPU, con lo que, nos tendremos que "conformar" con un RGB limitado (16-235 colores). Pero claro, esto de conformarse no es una característica de los usuarios de este sistema y, tomando como referencia la información proporcionada en este blog, vamos a crear un firmware personalizado de nuestro monitor con la utilidad wxEDID, que cargaremos al inicio del sistema mediante la correspondiente opción a pasarle al kernel.

1) Comprobar que el kernel está configurado con el soporte de carga de firmware en DRM

Todas las distribuciones sin excepción llevan esta opción establecida por defecto, basta ejecutar el siguiente comando para saberlo, un ejemplo con Slackware:

jose@slackware:~$ grep DRM_LOAD /boot/config

CONFIG_DRM_LOAD_EDID_FIRMWARE=y

Si no fuera así, como era mi caso en un kernel personalizado, lo activamos en la correspondiente sección de configuración del kernel.

2) Copiar el firmware del monitor a nuestro directorio personal

Primero lo buscamos,


[jose@localhost ~]$ find /sys/devices/pci*/ -name edid

/sys/devices/pci0000:00/0000:00:01.1/0000:01:00.0/drm/card0/card0-HDMI-A-1/edid

/sys/devices/pci0000:00/0000:00:01.1/0000:01:00.0/drm/card0/card0-DP-2/edid

/sys/devices/pci0000:00/0000:00:01.1/0000:01:00.0/drm/card0/card0-DP-1/edid

Luego, lo copiamos a nuestro directorio personal,


[jose@localhost ~]$ cp /sys/devices/pci0000:00/0000:00:01.1/0000:01:00.0/drm/card0/card0-HDMI-A-1/edid \

~/new_edid.bin

3) Modificarlo con wxEDID para crear un firmware personalizado

Abrimos el archivo new_edid.bin con wxEDID y modificamos lo siguiente:

3a) En la sección SPF: Supported features >> vsig_format , cambiamos el valor 0b01 por 0b00, dejándolo como se muestra en la captura de pantalla.

3b) En la sección CHD: CEA-861 header, establecemos en cero los valores YCbCr, que pueden variar según el monitor, en mi caso son 4:2:2 y 4:4:4, dejándolos como se muestra en la captura de pantalla.

3c) Recalculamos el checksum del archivo binario, seleccionando la entrada de menú, Options >> Assemble Edid y guardamos el firmware personalizado con otro nombre, seleccionando Save EDID Binary, en mi caso, simplemente edid.bin.

4) Instalar el firmware personalizado en el directorio correspondiente de carga de firmware del kernel

Una vez tenemos el firmware personalizado, lo instalamos como root en el directorio correspondiente:

$ su

# install -dm755 /lib/firmware/edid

# install -m644 edid.bin /lib/firmware/edid

5) Añadir la opción de carga del firmware al gestor de inicio del kernel (Grub o Lilo)

Añadimos la entrada drm.edid_firmware=edid/edid.bin a los archivos de configuración correspondientes de Grub o Lilo:

5a) GRUB >> /etc/default/grub

GRUB_DEFAULT=saved

GRUB_TIMEOUT=10

GRUB_TIMEOUT_STYLE=hidden

GRUB_DISTRIBUTOR="Manjaro"

GRUB_CMDLINE_LINUX_DEFAULT="quiet apparmor=1 security=apparmor udev.log_priority=3

drm.edid_firmware=edid/edid.bin

"

GRUB_CMDLINE_LINUX=""

GRUB_DISABLE_OS_PROBER=false

$ su -c "update-grub"

El comando de actualización del archivo de configuración de GRUB puede variar según distribuciones.

5b) LILO >> /etc/lilo.conf

# File generated by DrakX/drakboot

# WARNING: do not forget to run lilo after modifying this file



default="Linux"

boot=/dev/sda

map=/boot/map

vga=791

keytable=/boot/es-latin1.klt

menu-scheme=wb:bw:wb:bw

prompt

nowarn

timeout=100

message=/boot/message

image=/boot/vmlinuz-5.7.19-ck1

    label="Linux"

    root=/dev/sda1

    initrd=/boot/initrd-5.7.19-ck1.img

    append="quiet noapic acpi=off drm.edid_firmware=edid/edid.bin"

    vga=791

    read-only

$ su -c "lilo"

6) Reiniciamos el sistema y comprobamos en el siguiente inicio que estamos utilizando RGB completo en el puerto HDMI

Comprobamos el archivo de registro de inicio de Xorg, y vemos, que sólo aparece la entrada RGB 4:4:4


[jose@localhost ~]$ grep "RGB 4:4:4" /var/log/Xorg.1.log

[    62.390] (II) AMDGPU(0): Supported color encodings: RGB 4:4:4

Si hacemos la misma búsqueda en el archivo de registro antiguo, veremos que aparece también la entrada de RGB limitado, que es la que utiliza AMDGPU por defecto.


[jose@localhost ~]$ grep "RGB 4:4:4" /var/log/Xorg.1.log.old

[    61.541] (II) AMDGPU(0): Supported color encodings: RGB 4:4:4 YCrCb 4:4:4

Y en el menú OSD del monitor (BenQ GW2270H), aparecerá la entrada del menú Imagen Avanzada >> Rango RGB HDMI PC >> RGB (0~255), marcada. Cuando se utiliza el RGB limitado predefinido de AMDGPU, la sección Rango RGB HDMI PC no está disponible en el menú OSD del monitor.

Aplicaciones auxiliares de AMDGPU

Amdgpu_top

Amdgpu_top es una aplicación gráfica y de consola, que muestra el uso de los recursos de nuestra GPU. Está escrita en el lenguaje de programación Rust y se compila e instala con la aplicación cargo, desde línea de comandos.

Descarga

amdgpu_top-0.8.0.tar.gz

Extracción e Instalación como usuario

$ tar zxvf amdgpu_top-0.8.0.tar.gz

$ cd amdgpu_top-0.8.0

$ cargo install --locked --path .

Añadir a nuestro PATH la ruta $HOME/.cargo/bin (si no la tenemos aún)

$ echo "export PATH=\$HOME/.cargo/bin:\$PATH" >> ~/.bashrc

Descargar e instalar los iconos del archivo desktop desde internet

$ for i in ~/.local/share/icons/hicolor ; do \

mkdir -p $i/{16x16,24x24,32x32,48x48,64x64,128x128,256x256}/apps ; \

wget --no-check-certificate https://cdn.icon-icons.com/icons2/1381\

/PNG/256/radeonprofile_94926.png -O $i/256x256/apps/amdgputop.png ; \

wget --no-check-certificate https://cdn.icon-icons.com/icons2/1381\

/PNG/128/radeonprofile_94926.png -O $i/128x128/apps/amdgputop.png ; \

wget --no-check-certificate https://cdn.icon-icons.com/icons2/1381\

/PNG/64/radeonprofile_94926.png -O $i/164x64/apps/amdgputop.png ; \

wget --no-check-certificate https://cdn.icon-icons.com/icons2/1381\

/PNG/48/radeonprofile_94926.png -O $i/48x48/apps/amdgputop.png ; \

wget --no-check-certificate https://cdn.icon-icons.com/icons2/1381\

/PNG/32/radeonprofile_94926.png -O $i/32x32/apps/amdgputop.png ; \

convert -resize 24 $i/256x256/apps/amdgputop.png $i/24x24/apps/amdgputop.png ; \

convert -resize 16 $i/256x256/apps/amdgputop.png $i/16x16/apps/amdgputop.png ; \


gtk-update-icon-cache -tf $i &> /dev/null ; \

done

Creación del archivo amdgputop.desktop

Para que Amdgpu_top sea detectado por los menús de entornos gráficos como XFce 4 o paneles como LXPanel o Fbpanel, creamos el correspondiente archivo desktop con cat o con un editor de texto:

$ cat > amdgputop.desktop << "EOF"

[Desktop Entry]

Name=Amdgpu__top

Comment=Monitor de recursos de la GPU

Exec=amdgpu_top --gui

Icon=amdgputop

Categories=Application;System;Monitor;

Type=Application

EOF

Luego lo copiamos como usuario a ~/.local/share/applications.

mkdir -p ~/.local/share/applications

$ cp amdgputop.desktop ~/.local/share/applications

$ update-desktop-database

Iniciamos Amdgpu_top

Sólo nos queda teclear en una terminal o en un lanzador el comando amdgpu_top --gui, y el programa aparecerá en la pantalla. Si queremos utilizar la interfaz de consola, ejecutamos el comando sin argumentos y, si queremos utilizar una interfaz similar a la de nvidia-smi, lo ejecutamos con el parámetro adicional, --smi.

Enlaces

https://www.x.org/wiki/RadeonFeature >> La web de AMDGPU.

http://dri.freedesktop.org >> La web de Libdrm.

http://freedesktop.org/wiki/Software/VDPAU >> La web de Libvdpau.

http://www.mesa3d.org >> La web de Mesa y GLU.

http://freeglut.sourceforge.net >> La web de FreeGLUT.

https://wiki.gentoo.org/wiki/AMDGPU >> La wiki de la distribución Gentoo dedicada a AMDGPU.

https://wiki.archlinux.org/title/AMDGPU >> La wiki de la distribución Arch Linux dedicada a AMDGPU.