ManualFanTuning

Demonstrates how to control manual fan tuning when programming with ADLX.
Command Prompts

Command Prompt	Description
1	Get and set fan setting.
2	Get and set ZeroRPM setting.
3	Get and set MinAcoustic setting.
4	Get and set MinFanSpeed setting.
5	Get and set TargetFanSpeed setting.
M/m	Show this menu.
Q/q	Quit.
Sample Path

/Samples/C/GPUTuning/ManualFanTuning
Code

Copied!
//
// Copyright (c) 2021 - 2025 Advanced Micro Devices, Inc. All rights reserved.
//
//-------------------------------------------------------------------------------------------------


#include "SDK/ADLXHelper/Windows/C/ADLXHelper.h"
#include "SDK/Include/IGPUManualFanTuning.h"
#include "SDK/Include/IGPUTuning.h"

// Main menu
void MainMenu ();

// Menu action control
void MenuControl (IADLXManualFanTuning* manualFanTuning);

// Wait for exit with error message
int WaitAndExit (const char* msg, const int retCode,
    IADLXGPUTuningServices* gpuTuningService,
    IADLXGPUList* gpus,
    IADLXGPU* oneGPU,
    IADLXInterface* manualFanTuni.gifc,
    IADLXManualFanTuning* manualFanTuning);

// Display and set fan settings
void ShowGetAndSetFan (IADLXManualFanTuning* manualFanTuning);

// Display and set ZeroRPM settings
void ShowGetAndSetZeroRPM (IADLXManualFanTuning* manualFanTuning);

// Display and set MinAcoustic settings
void ShowGetAndSetMinAcoustic (IADLXManualFanTuning* manualFanTuning);

// Display and set MinFanSpeed settings
void ShowGetAndSetMinFanSpeed (IADLXManualFanTuning* manualFanTuning);

// Display and set TargetFanSpeed settings
void ShowGetAndSetTargetFanSpeed (IADLXManualFanTuning* manualFanTuning);

int main ()
{
    ADLX_RESULT  res = ADLX_FAIL ;

    // Initialize ADLX
    res = ADLXHelper_Initialize ();

    if (ADLX_SUCCEEDED  (res))
    {
        IADLXSystem* sys = ADLXHelper_GetSystemServices ();
        IADLXGPUTuningServices* gpuTuningService = NULL;
        IADLXGPUList* gpus = NULL;
        IADLXGPU* oneGPU = NULL;
        IADLXInterface* manualFanTuni.gifc = NULL;
        IADLXManualFanTuning* manualFanTuning = NULL;

        res = sys->pVtbl->GetGPUTuningServices (sys, &gpuTuningService);
        if (ADLX_FAILED  (res))
            return WaitAndExit ("\\tGet GPU tuning services failed", 0, gpuTuningService, gpus, oneGPU, manualFanTuni.gifc, manualFanTuning);

        res = sys->pVtbl->GetGPUs (sys, &gpus);
        if (ADLX_FAILED  (res))
            return WaitAndExit ("\\tGet GPU list failed", 0, gpuTuningService, gpus, oneGPU, manualFanTuni.gifc, manualFanTuning);

        res = gpus->pVtbl->At_GPUList (gpus, 0, &oneGPU);
        if (ADLX_FAILED  (res) || oneGPU == NULL)
            return WaitAndExit ("\\tGet GPU failed", 0, gpuTuningService, gpus, oneGPU, manualFanTuni.gifc, manualFanTuning);

        adlx_bool supported = false;
        res = gpuTuningService->pVtbl->IsSupportedManualFanTuning (gpuTuningService, oneGPU, &supported);
        if (ADLX_FAILED  (res) || supported == false)
            return WaitAndExit ("\\tThis GPU does not support manual fan tuning", 0, gpuTuningService, gpus, oneGPU, manualFanTuni.gifc, manualFanTuning);

        res = gpuTuningService->pVtbl->GetManualFanTuning (gpuTuningService, oneGPU, &manualFanTuni.gifc);
        if (ADLX_FAILED  (res) || manualFanTuni.gifc == NULL)
            return WaitAndExit ("\\tGet manual fan tuning interface failed", 0, gpuTuningService, gpus, oneGPU, manualFanTuni.gifc, manualFanTuning);

        manualFanTuni.gifc->pVtbl->QueryInterface (manualFanTuni.gifc, IID_IADLXManualFanTuning (), (void**)&manualFanTuning);
        if (manualFanTuning == NULL)
            return WaitAndExit ("\\tGet manual fan tuning failed", 0, gpuTuningService, gpus, oneGPU, manualFanTuni.gifc, manualFanTuning);

        // Display main menu options
        MainMenu ();

        // Get and execute the choice
        MenuControl (manualFanTuning);

        // Release the manualFanTuning interface
        if (manualFanTuning != NULL)
        {
            manualFanTuning->pVtbl->Release (manualFanTuning);
            manualFanTuning = NULL;
        }
        if (manualFanTuni.gifc != NULL)
        {
            manualFanTuni.gifc->pVtbl->Release (manualFanTuni.gifc);
            manualFanTuni.gifc = NULL;
        }
        if (oneGPU != NULL)
        {
            oneGPU->pVtbl->Release (oneGPU);
            oneGPU = NULL;
        }
        if (gpus != NULL)
        {
            gpus->pVtbl->Release (gpus);
            gpus = NULL;
        }
        if (gpuTuningService != NULL)
        {
            gpuTuningService->pVtbl->Release (gpuTuningService);
            gpuTuningService = NULL;
        }
    }
    else
    {
        printf ("\\tg_ADLXHelp initialize failed\\n");
        system ("pause");
        return 0;
    }

    // Destroy ADLX
    res = ADLXHelper_Terminate ();
    printf ("Destroy ADLX res: %d\\n", res);

    // Pause to see the print out
    system ("pause");

    return 0;
}

// Main menu
void MainMenu ()
{
    printf ("\\tChoose from the following options:\\n");

    printf ("\\t->Press 1 to display and set fan setting\\n");
    printf ("\\t->Press 2 to display and set ZeroRPM setting\\n");
    printf ("\\t->Press 3 to display and set MinAcoustic setting\\n");
    printf ("\\t->Press 4 to display and set MinFanSpeed setting\\n");
    printf ("\\t->Press 5 to display and set TargetFanSpeed setting\\n");

    printf ("\\t->Press Q/q to terminate the application\\n");
    printf ("\\t->Press M/m to display main menu options\\n");
}

// Menu action control
void MenuControl (IADLXManualFanTuning* manualFanTuning)
{
    int num = 0;
    while ((num = getchar ()) != 'q' && num != 'Q')
    {
        switch (num)
        {
            // Display and set fan settings
        case '1':
            ShowGetAndSetFan (manualFanTuning);
            break;

            // Display and set ZeroRPM settings
        case '2':
            ShowGetAndSetZeroRPM (manualFanTuning);
            break;

            // Display and set MinAcoustic settings
        case '3':
            ShowGetAndSetMinAcoustic (manualFanTuning);
            break;

            // Display and set MinFanSpeed settings
        case '4':
            ShowGetAndSetMinFanSpeed (manualFanTuning);
            break;

            // Display and set TargetFanSpeed settings
        case '5':
            ShowGetAndSetTargetFanSpeed (manualFanTuning);
            break;

            // Display menu options
        case 'm':
        case 'M':
            MainMenu ();
            break;
        default:
            break;
        }
    }
}

// Wait for exit with error message
int WaitAndExit (const char* msg, const int retCode,
    IADLXGPUTuningServices* gpuTuningService,
    IADLXGPUList* gpus,
    IADLXGPU* oneGPU,
    IADLXInterface* manualFanTuni.gifc,
    IADLXManualFanTuning* manualFanTuning)
{
    // Printout the message and pause to see it before returning the desired code
    if (NULL != msg)
        printf ("%s\\n", msg);

    // Release the manualFanTuning interface
    if (manualFanTuning != NULL)
    {
        manualFanTuning->pVtbl->Release (manualFanTuning);
        manualFanTuning = NULL;
    }
    if (manualFanTuni.gifc != NULL)
    {
        manualFanTuni.gifc->pVtbl->Release (manualFanTuni.gifc);
        manualFanTuni.gifc = NULL;
    }
    if (oneGPU != NULL)
    {
        oneGPU->pVtbl->Release (oneGPU);
        oneGPU = NULL;
    }
    if (gpus != NULL)
    {
        gpus->pVtbl->Release (gpus);
        gpus = NULL;
    }
    if (gpuTuningService != NULL)
    {
        gpuTuningService->pVtbl->Release (gpuTuningService);
        gpuTuningService = NULL;
    }
    // Destroy ADLX
    ADLX_RESULT  res = ADLXHelper_Terminate ();
    printf ("Destroy ADLX res: %d\\n", res);

    system ("pause");
    return retCode;
}

// Display and set fan settings
void ShowGetAndSetFan (IADLXManualFanTuning* manualFanTuning)
{
    // Display manual fan tuning ranges (speed, temperature)
    ADLX_IntRange  fanSpeedRange, fanTemperatureRange;
    ADLX_RESULT  res = manualFanTuning->pVtbl->GetFanTuningRanges (manualFanTuning, &fanSpeedRange, &fanTemperatureRange);
    printf ("\\tFan speed range: (%d, %d)\\n", fanSpeedRange.minValue , fanSpeedRange.maxValue );
    printf ("\\tFan temperature range: (%d, %d)\\n", fanTemperatureRange.minValue , fanTemperatureRange.maxValue );
    printf ("\\tReturn code is: %d(0 means success)\\n", res);

    // Display current fan tuning states
    IADLXManualFanTuningStateList* states;
    IADLXManualFanTuningState* oneState;
    res = manualFanTuning->pVtbl->GetFanTuningStates (manualFanTuning, &states);
    if (ADLX_SUCCEEDED  (res))
    {
        for (adlx_uint crt = states->pVtbl->Begin (states); crt != states->pVtbl->End (states); ++crt)
        {
            res = states->pVtbl->At_ManualFanTuningStateList (states, crt, &oneState);
            adlx_int speed = 0, temperature = 0;
            oneState->pVtbl->GetFanSpeed (oneState, &speed);
            oneState->pVtbl->GetTemperature (oneState, &temperature);
            printf ("\\tThe current %d state: speed is %d temperature is %d\\n", crt, speed, temperature);
            if (oneState != NULL)
            {
                oneState->pVtbl->Release (oneState);
                oneState = NULL;
            }
        }
        if (states != NULL)
        {
            states->pVtbl->Release (states);
            states = NULL;
        }
    }
    // Display default fan tuning states
    IADLXManualFanTuning1* manualFanTuning1;
    manualFanTuning->pVtbl->QueryInterface(manualFanTuning, IID_IADLXManualFanTuning1(), (void**)&manualFanTuning1);
    if (manualFanTuning1)
    {
        res = manualFanTuning1->pVtbl->GetDefaultFanTuningStates(manualFanTuning1, &states);
        if (ADLX_SUCCEEDED (res))
        {
            for (adlx_uint crt = states->pVtbl->Begin(states); crt != states->pVtbl->End(states); ++crt)
            {
                res = states->pVtbl->At_ManualFanTuningStateList(states, crt, &oneState);
                adlx_int speed = 0, temperature = 0;
                oneState->pVtbl->GetFanSpeed(oneState, &speed);
                oneState->pVtbl->GetTemperature(oneState, &temperature);
                printf("\\tThe default %d state: speed is %d temperature is %d\\n", crt, speed, temperature);
                if (oneState != NULL)
                {
                    oneState->pVtbl->Release(oneState);
                    oneState = NULL;
                }
            }
            if (states != NULL)
            {
                states->pVtbl->Release(states);
                states = NULL;
            }
        }
        manualFanTuning1->pVtbl->Release(manualFanTuning1);
        manualFanTuning1 = NULL;
    }

    // Set empty fan tuning states
    res = manualFanTuning->pVtbl->GetEmptyFanTuningStates (manualFanTuning, &states);
    if (ADLX_SUCCEEDED  (res))
    {
        for (adlx_uint crt = states->pVtbl->Begin (states); crt != states->pVtbl->End (states); ++crt)
        {
            res = states->pVtbl->At_ManualFanTuningStateList (states, crt, &oneState);
            adlx_int speed = 0, temperature = 0;
            int fanSpeedStep = (fanSpeedRange.maxValue  - fanSpeedRange.minValue ) / states->pVtbl->Size (states);
            int fanTemperatureStep = (fanTemperatureRange.maxValue  - fanTemperatureRange.minValue ) / states->pVtbl->Size (states);
            oneState->pVtbl->SetFanSpeed (oneState, fanSpeedRange.minValue  + fanSpeedStep * crt);
            oneState->pVtbl->GetFanSpeed (oneState, &speed);
            oneState->pVtbl->SetTemperature (oneState, fanTemperatureRange.minValue  + fanTemperatureStep * crt);
            oneState->pVtbl->GetTemperature (oneState, &temperature);
            printf ("\\tSet empty %d state: speed is %d temperature is %d\\n", crt, speed, temperature);
            if (oneState != NULL)
            {
                oneState->pVtbl->Release (oneState);
                oneState = NULL;
            }
        }
    }

    // Set empty fan tuning states to current fan tuning states
    adlx_int errorIndex;
    res = manualFanTuning->pVtbl->IsValidFanTuningStates (manualFanTuning, states, &errorIndex);
    printf ("\\tIsValidGPUTuningStates, errorIndex is : %d\\n", errorIndex);
    if (ADLX_SUCCEEDED  (res))
    {
        manualFanTuning->pVtbl->SetFanTuningStates (manualFanTuning, states);
    }
    if (states != NULL)
    {
        states->pVtbl->Release (states);
        states = NULL;
    }
    res = manualFanTuning->pVtbl->GetFanTuningStates (manualFanTuning, &states);
    if (ADLX_SUCCEEDED  (res))
    {
        printf ("\\tAfter setting:\\n");
        for (adlx_uint crt = states->pVtbl->Begin (states); crt != states->pVtbl->End (states); ++crt)
        {
            res = states->pVtbl->At_ManualFanTuningStateList (states, crt, &oneState);
            adlx_int speed = 0, temperature = 0;
            oneState->pVtbl->GetFanSpeed (oneState, &speed);
            oneState->pVtbl->GetTemperature (oneState, &temperature);
            printf ("\\tThe current %d state: speed is %d temperature is %d\\n", crt, speed, temperature);
            if (oneState != NULL)
            {
                oneState->pVtbl->Release (oneState);
                oneState = NULL;
            }
        }
        if (states != NULL)
        {
            states->pVtbl->Release (states);
            states = NULL;
        }
    }
}

// Display and set ZeroRPM settings
void ShowGetAndSetZeroRPM (IADLXManualFanTuning* manualFanTuning)
{
    adlx_bool supported = false;
    ADLX_RESULT  res = manualFanTuning->pVtbl->IsSupportedZeroRPM (manualFanTuning, &supported);
    printf ("\\tIs support ZeroRPM: %d\\n", supported);
    if (ADLX_FAILED  (res) || !supported)
        return;
    adlx_bool isZeroRPMStateSet = false;
    res = manualFanTuning->pVtbl->SetZeroRPMState (manualFanTuning, true);
    printf ("\\tSet ZeroRPM state, return code is: %d(0 means success)\\n", res);
    res = manualFanTuning->pVtbl->GetZeroRPMState (manualFanTuning, &isZeroRPMStateSet);
    printf ("\\tIs ZeroRPM state set: %d, return code is: %d(0 means success)\\n", isZeroRPMStateSet, res);
    res = manualFanTuning->pVtbl->SetZeroRPMState (manualFanTuning, false);
    printf ("\\tReset ZeroRPM state, return code is: %d(0 means success)\\n", res);
    res = manualFanTuning->pVtbl->GetZeroRPMState (manualFanTuning, &isZeroRPMStateSet);
    printf ("\\tIs ZeroRPM state set: %d, return code is: %d(0 means success)\\n", isZeroRPMStateSet, res);
    IADLXManualFanTuning1* manualFanTuning1;
    manualFanTuning->pVtbl->QueryInterface(manualFanTuning, IID_IADLXManualFanTuning1(), (void**)&manualFanTuning1);
    if (manualFanTuning1)
    {
        res = manualFanTuning1->pVtbl->GetDefaultZeroRPMState(manualFanTuning1, &isZeroRPMStateSet);
        printf("\\tDefault ZeroRPM state is: %d, return code is: %d(0 means success)\\n", isZeroRPMStateSet, res);
        // release manualFanTuning1
        manualFanTuning1->pVtbl->Release(manualFanTuning1);
        manualFanTuning1 = NULL;
    }
}

// Display and set MinAcoustic settings
void ShowGetAndSetMinAcoustic (IADLXManualFanTuning* manualFanTuning)
{
    adlx_bool supported = false;
    ADLX_RESULT  res = manualFanTuning->pVtbl->IsSupportedMinAcousticLimit (manualFanTuning, &supported);
    printf ("\\tIs MinAcousticLimit supported: %d\\n", supported);
    if (ADLX_FAILED  (res) || !supported)
        return;

    ADLX_IntRange  tuningRange;
    res = manualFanTuning->pVtbl->GetMinAcousticLimitRange (manualFanTuning, &tuningRange);
    printf ("\\tMinAcoustic limit range: (%d, %d), return code is: %d(0 means success)\\n", tuningRange.minValue , tuningRange.maxValue , res);

    adlx_int minAcousticLimit;
    res = manualFanTuning->pVtbl->GetMinAcousticLimit (manualFanTuning, &minAcousticLimit);
    printf ("\\tCurrent min acoustic limit: %d, return code is: %d(0 means success)\\n", minAcousticLimit, res);
    res = manualFanTuning->pVtbl->SetMinAcousticLimit (manualFanTuning, tuningRange.minValue  + (tuningRange.maxValue  - tuningRange.minValue ) / 2);
    res = manualFanTuning->pVtbl->GetMinAcousticLimit (manualFanTuning, &minAcousticLimit);
    printf ("\\tSet current min acoustic limit to: %d, return code is: %d(0 means success)\\n", minAcousticLimit, res);

    IADLXManualFanTuning1* manualFanTuning1;
    manualFanTuning->pVtbl->QueryInterface(manualFanTuning, IID_IADLXManualFanTuning1(), (void**)&manualFanTuning1);
    if (manualFanTuning1)
    {
        res = manualFanTuning1->pVtbl->GetMinAcousticLimitDefault(manualFanTuning1, &minAcousticLimit);
        printf("\\tDefault min acoustic limit is: %d, return code is: %d(0 means success)\\n", minAcousticLimit, res);
        // release manualFanTuning1
        manualFanTuning1->pVtbl->Release(manualFanTuning1);
        manualFanTuning1 = NULL;
    }
}

// Display and set MinFanSpeed settings
void ShowGetAndSetMinFanSpeed (IADLXManualFanTuning* manualFanTuning)
{
    adlx_bool supported = false;
    ADLX_RESULT  res = manualFanTuning->pVtbl->IsSupportedMinFanSpeed (manualFanTuning, &supported);
    printf ("\\tIs MinFanSpeed supported: %d\\n", supported);
    if (ADLX_FAILED  (res) || !supported)
        return;

    ADLX_IntRange  tuningRange;
    res = manualFanTuning->pVtbl->GetMinFanSpeedRange (manualFanTuning, &tuningRange);
    printf ("\\tMinFanSpeed range: (%d, %d), return code is: %d(0 means success)\\n", tuningRange.minValue , tuningRange.maxValue , res);

    adlx_int minFanSpeed = 0;
    res = manualFanTuning->pVtbl->GetMinFanSpeed (manualFanTuning, &minFanSpeed);
    printf ("\\tCurrent MinFanSpeed: %d, return code is: %d(0 means success)\\n", minFanSpeed, res);
    res = manualFanTuning->pVtbl->SetMinFanSpeed (manualFanTuning, tuningRange.minValue  + (tuningRange.maxValue  - tuningRange.minValue ) / 2);
    res = manualFanTuning->pVtbl->GetMinFanSpeed (manualFanTuning, &minFanSpeed);
    printf ("\\tSet current MinFanSpeed to: %d, return code is: %d(0 means success)\\n", minFanSpeed, res);

    IADLXManualFanTuning1* manualFanTuning1;
    manualFanTuning->pVtbl->QueryInterface(manualFanTuning, IID_IADLXManualFanTuning1(), (void**)&manualFanTuning1);
    if (manualFanTuning1)
    {
        res = manualFanTuning1->pVtbl->GetMinFanSpeedDefault(manualFanTuning1, &minFanSpeed);
        printf("\\tDefault MinFanSpeed is: %d, return code is: %d(0 means success)\\n", minFanSpeed, res);
        // release manualFanTuning1
        manualFanTuning1->pVtbl->Release(manualFanTuning1);
        manualFanTuning1 = NULL;
    }
}

// Display and set TargetFanSpeed settings
void ShowGetAndSetTargetFanSpeed (IADLXManualFanTuning* manualFanTuning)
{
    adlx_bool supported = false;
    ADLX_RESULT  res = manualFanTuning->pVtbl->IsSupportedTargetFanSpeed (manualFanTuning, &supported);
    printf ("\\tIs TargetFanSpeed supported: %d\\n", supported);
    if (ADLX_FAILED  (res) || !supported)
        return;

    ADLX_IntRange  tuningRange;
    res = manualFanTuning->pVtbl->GetTargetFanSpeedRange (manualFanTuning, &tuningRange);
    printf ("\\tTargetFanSpeed range: (%d, %d), return code is: %d(0 means success)\\n", tuningRange.minValue , tuningRange.maxValue , res);

    adlx_int targetFanSpeed;
    res = manualFanTuning->pVtbl->GetTargetFanSpeed (manualFanTuning, &targetFanSpeed);
    printf ("\\tCurrent TargetFanSpeed: %d, return code is: %d(0 means success)\\n", targetFanSpeed, res);
    res = manualFanTuning->pVtbl->SetTargetFanSpeed (manualFanTuning, tuningRange.minValue  + (tuningRange.maxValue  - tuningRange.minValue ) / 2);
    res = manualFanTuning->pVtbl->GetTargetFanSpeed (manualFanTuning, &targetFanSpeed);
    printf ("\\tSet current TargetFanSpeed to: %d, return code is: %d(0 means success)\\n", targetFanSpeed, res);

    IADLXManualFanTuning1* manualFanTuning1;
    manualFanTuning->pVtbl->QueryInterface(manualFanTuning, IID_IADLXManualFanTuning1(), (void**)&manualFanTuning1);
    if (manualFanTuning1)
    {
        res = manualFanTuning1->pVtbl->GetTargetFanSpeedDefault(manualFanTuning1, &targetFanSpeed);
        printf("\\Default TargetFanSpeed: %d, return code is: %d(0 means success)\\n", targetFanSpeed, res);
        // release manualFanTuning1
        manualFanTuning1->pVtbl->Release(manualFanTuning1);
        manualFanTuning1 = NULL;
    }

}
Engines and APIs

Engines and APIs

Hybrid RT and samples

Hybrid RT and samples

Our SDKs and libraries

Our SDKs and libraries

Content creation

Content creation

Blogs and videos

Blogs and videos

Performance guides

Performance guides

Reference

Reference

Latest news

Latest news

Events

Events

Research

Research

Getting started with:

Getting started with:

Site directory

Manuals home

ManualFanTuning

Command Prompts

Sample Path

Code

Related pages

GPU Tuning – ManualFanTuning (ADLX) (C++)

GPU Tuning – GPUAutoTuning (ADLX) (C)

GPU Tuning – GPUAutoTuning (ADLX) (C++)

Python Samples – ADLXPybind (ADLX) (Python)

Performance Monitoring – PerfGPUMetrics (ADLX) (C)

GPU Tuning – ManualGraphicsTuning (ADLX) (C++)

GPU Tuning – ManualGraphicsTuning (ADLX) (C)

Performance Monitoring – PerfGPUMetrics (ADLX) (C++)

Looking for more documentation on GPUOpen?

Find out more about our software!

Engines and APIs

Hybrid RT and samples

Our SDKs and libraries

Content creation

Blogs and videos

Performance guides

Reference

Latest news

Events

Research

Getting started with:

AMD Device Library eXtra v1.4 documentation

ManualFanTuning

Command Prompts

Sample Path

Code

Related pages

GPU Tuning – ManualFanTuning (ADLX) (C++)

GPU Tuning – GPUAutoTuning (ADLX) (C)

GPU Tuning – GPUAutoTuning (ADLX) (C++)

Python Samples – ADLXPybind (ADLX) (Python)

Performance Monitoring – PerfGPUMetrics (ADLX) (C)

GPU Tuning – ManualGraphicsTuning (ADLX) (C++)

GPU Tuning – ManualGraphicsTuning (ADLX) (C)

Performance Monitoring – PerfGPUMetrics (ADLX) (C++)

Looking for more documentation on GPUOpen?

Find out more about our software!
