Skip to content

GPUServiceDirect

Navigation: Programming with ADLX → ADLX Samples → C++ Samples → ServiceCall

Demonstrates how to use ADLX into a system service application for ADLX v1.4 and above.

Command Prompts

Command PromptDescription
-installInstall “ADLX GPU Service” into services.
-removeRemove “ADLX GPU Service” from services.

Sample Path

/Samples/CPP/ServiceCall/GPUServiceDirect

C++

Code

C++

//
// Copyright Advanced Micro Devices, Inc. All rights reserved.
//
//-------------------------------------------------------------------------------------------------


/// \file mainGPUServiceDirect.cpp
/// \brief This document demonstrate how to use windows service call to get GPU information.


#pragma warning(suppress: 6248)


#include <Windows.h>
#include <TlHelp32.h>
#include <WtsApi32.h>
#include <tchar.h>
#include "SDK/ADLXHelper/Windows/Cpp/ADLXHelper.h"
#include "SDK/Include/ISystem.h"
#include "SDK/Include/IPerformanceMonitoring3.h"
#include <string>
#include <iostream>


#pragma comment(lib, "wtsapi32.lib")


#define MAX_DEBUG_STR_LEN 1024


void XTrace (wchar_t* lpszFormat, ...)
{
    va_list args;
    va_start (args, lpszFormat);
    int nBuf;
    WCHAR szBuffer[MAX_DEBUG_STR_LEN];
    nBuf = _vsnwprintf_s (szBuffer, MAX_DEBUG_STR_LEN, _TRUNCATE, lpszFormat, args);
    ::OutputDebugStringW (szBuffer);
    va_end (args);
}


// Use adlx namespace
using namespace adlx;


// ADLXHelper instance.
static ADLXHelper g_ADLXHelp;
// Indicates that ADLX is functional
bool g_ADLXAlive = false;
// An event to wait for the right conditions to initialize ADLX
HANDLE g_ADLXInitReady = CreateEvent(NULL, FALSE, FALSE, NULL);


// Service name
#define ADLX_SERVICE_NAME  L"ADLX GPU Service"


// Global variables for service routine
SERVICE_STATUS_HANDLE g_StatusHandle = NULL;
SERVICE_STATUS        g_ServiceStatus = { 0 };
HANDLE                g_ServiceStopEvent = INVALID_HANDLE_VALUE;
bool                  g_StopWorkThread = false;


// Service routine
VOID WINAPI  ServiceMain (DWORD argc, LPTSTR* argv);
DWORD WINAPI ServiceCtrlHandler(DWORD ctrlCode, DWORD eventType, LPVOID eventData, LPVOID context);
DWORD WINAPI ServiceWorkerThread (LPVOID lpParam);


// Check if any user is logged on
bool IsAnyUserLogon ();


// Install/unistall this service
// N.B: Need admin permission
// User can also install/unistall this service by windows command line
// Usage: SC CREATE "ADLX GPU Service" "GPUService.exe"
//        SC DELETE "ADLX GPU Service"
void InstallService ();
void RemoveService ();


// Usage
void Usage ()
{
    std::cout << std::endl;
    std::cout << "\tThis exe is a service executable, you can install/unistall it with:" << std::endl;
    std::cout << "\t    SC CREATE 'ADLX GPU Service' 'GPUService.exe'" << std::endl;
    std::cout << "\t    SC DELETE 'ADLX GPU Service'" << std::endl;
    std::cout << std::endl;
    std::cout << "\tOr use the executable itself to install/uninstall:" << std::endl;
    std::cout << "\t    GPUService.exe -install or GPUService.exe /install" << std::endl;
    std::cout << "\t    GPUService.exe -remove or GPUService.exe /remove" << std::endl;
    std::cout << std::endl;
    std::cout << "\t    Use GPUService.exe -help, GPUService.exe /help to show this usage, or GPUService.exe ?" << std::endl;
    std::cout << std::endl;
}


int wmain (int argc, wchar_t* argv[])
{
    XTrace (L"ADLX Call Service: Main: Entry");
    XTrace (L"ADLX Call Service: Main: Args:%s", GetCommandLineW ());


    if ((argc > 1))
    {
        if (((*argv[1] == '-') || (*argv[1] == '/')))
        {
            if (_wcsicmp (L"install", argv[1] + 1) == 0)
            {
                InstallService ();
                return 0;
            }
            else if (_wcsicmp (L"remove", argv[1] + 1) == 0)
            {
                RemoveService ();
                return 0;
            }
            else if (_wcsicmp (L"help", argv[1] + 1) == 0)
            {
                Usage ();
                return 0;
            }
        }
        else if (_wcsicmp (L"?", argv[1]) == 0)
        {
            Usage ();
            return 0;
        }
    }


    SERVICE_TABLE_ENTRYW ServiceTable[] =
    {
        { ADLX_SERVICE_NAME, (LPSERVICE_MAIN_FUNCTIONW)ServiceMain },
        { NULL, NULL }
    };


    if (StartServiceCtrlDispatcherW (ServiceTable) == FALSE)
    {
        XTrace (L"ADLX Call Service: Main: StartServiceCtrlDispatcher returned error.");
        return GetLastError ();
    }


    XTrace (L"ADLX Call Service: Main: Exit");
    return 0;
}


VOID WINAPI ServiceMain (DWORD argc, LPTSTR* argv)
{
    DWORD Status = E_FAIL;


    XTrace (L"ADLX Call Service: ServiceMain: Entry");


    g_StatusHandle = RegisterServiceCtrlHandlerExW (ADLX_SERVICE_NAME, ServiceCtrlHandler, NULL);
    if (g_StatusHandle == NULL)
    {
        XTrace (L"ADLX Call Service: ServiceMain: RegisterServiceCtrlHandler returned error");
        goto EXIT;
    }


    // Tell the service controller we are starting
    ZeroMemory (&g_ServiceStatus, sizeof (g_ServiceStatus));
    g_ServiceStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
    g_ServiceStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SESSIONCHANGE;
    g_ServiceStatus.dwCurrentState = SERVICE_START_PENDING;
    g_ServiceStatus.dwWin32ExitCode = 0;
    g_ServiceStatus.dwServiceSpecificExitCode = 0;
    g_ServiceStatus.dwCheckPoint = 0;


    if (SetServiceStatus (g_StatusHandle, &g_ServiceStatus) == FALSE)
    {
        XTrace (L"ADLX Call Service: ServiceMain: SetServiceStatus returned error");
    }


    /*
     * Perform tasks neccesary to start the service here
     */
    XTrace (L"ADLX Call Service: ServiceMain: Performing Service Start Operations");


    // Create stop event to wait on later.
    g_ServiceStopEvent = CreateEvent (NULL, TRUE, FALSE, NULL);
    if (g_ServiceStopEvent == NULL)
    {
        XTrace (L"ADLX Call Service: ServiceMain: CreateEvent(g_ServiceStopEvent) returned error");


        g_ServiceStatus.dwControlsAccepted = 0;
        g_ServiceStatus.dwCurrentState = SERVICE_STOPPED;
        g_ServiceStatus.dwWin32ExitCode = GetLastError ();
        g_ServiceStatus.dwCheckPoint = 1;


        if (SetServiceStatus (g_StatusHandle, &g_ServiceStatus) == FALSE)
        {
            XTrace (L"ADLX Call Service: ServiceMain: SetServiceStatus returned error");
        }
        goto EXIT;
    }


    // Tell the service controller we are started
    g_ServiceStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SESSIONCHANGE;
    g_ServiceStatus.dwCurrentState = SERVICE_RUNNING;
    g_ServiceStatus.dwWin32ExitCode = 0;
    g_ServiceStatus.dwCheckPoint = 0;


    if (SetServiceStatus (g_StatusHandle, &g_ServiceStatus) == FALSE)
    {
        XTrace (L"ADLX Call Service: ServiceMain: SetServiceStatus returned error");
    }


    // Start the thread that will perform the main task of the service
    HANDLE hThread = CreateThread (NULL, 0, ServiceWorkerThread, NULL, 0, NULL);


    XTrace (L"ADLX Call Service: ServiceMain: Waiting for Worker Thread to complete");


    // Wait until our worker thread exits effectively signaling that the service needs to stop
    if (hThread)
    {
        // Wait until our worker thread exits effectively signaling that the service needs to stop
        WaitForSingleObject(hThread, INFINITE);


        XTrace(L"ADLX Call Service: ServiceMain: Worker Thread Stop Event signaled");
    }
    /*
     * Perform any cleanup tasks
     */
    XTrace (L"ADLX Call Service: ServiceMain: Performing Cleanup Operations");


    CloseHandle (g_ServiceStopEvent);


    g_ServiceStatus.dwControlsAccepted = 0;
    g_ServiceStatus.dwCurrentState = SERVICE_STOPPED;
    g_ServiceStatus.dwWin32ExitCode = 0;
    g_ServiceStatus.dwCheckPoint = 3;


    if (SetServiceStatus (g_StatusHandle, &g_ServiceStatus) == FALSE)
    {
        XTrace (L"ADLX Call Service: ServiceMain: SetServiceStatus returned error");
    }


EXIT:
    XTrace (L"ADLX Call Service: ServiceMain: Exit");


    return;
}


DWORD WINAPI ServiceCtrlHandler (DWORD ctrlCode, DWORD eventType, LPVOID eventData, LPVOID context)
{
    XTrace (L"ADLX Call Service: ServiceCtrlHandler: Entry");


    switch (ctrlCode)
    {
    case SERVICE_CONTROL_STOP:
    {
        XTrace(L"ADLX Call Service: ServiceCtrlHandler: SERVICE_CONTROL_STOP Request");


        if (g_ServiceStatus.dwCurrentState != SERVICE_RUNNING)
            break;


        /*
         * Perform tasks neccesary to stop the service here
         */


        g_ServiceStatus.dwControlsAccepted = 0;
        g_ServiceStatus.dwCurrentState = SERVICE_STOP_PENDING;
        g_ServiceStatus.dwWin32ExitCode = 0;
        g_ServiceStatus.dwCheckPoint = 4;


        if (SetServiceStatus(g_StatusHandle, &g_ServiceStatus) == FALSE)
        {
            XTrace(L"ADLX Call Service: ServiceCtrlHandler: SetServiceStatus returned error");
        }


        // This will signal the worker thread to shut down
        SetEvent(g_ServiceStopEvent);
        g_StopWorkThread = true;
    }
    break;
    case SERVICE_CONTROL_SESSIONCHANGE:
    {
        XTrace(L"ADLX Call Service: ServiceCtrlHandler: SERVICE_CONTROL_SESSIONCHANGE");
        WTSSESSION_NOTIFICATION* pSessionNotification = (WTSSESSION_NOTIFICATION*)eventData;
        switch (eventType)
        {
        case WTS_SESSION_LOGOFF:
        {
            XTrace(L"ADLX Call Service: ServiceCtrlHandler: WTS_SESSION_LOGOFF");
        }
        break;
        case WTS_SESSION_LOGON:
        {
            XTrace(L"ADLX Call Service: ServiceCtrlHandler: WTS_SESSION_LOGON");
            // When user logon, initialize ADLX
            if (!g_ADLXAlive)
            {
                auto res = g_ADLXHelp.Initialize();
                if (ADLX_SUCCEEDED(res))
                {
                    XTrace(L"Initialize ADLX succeed: %d\n", res);
                    g_ADLXAlive = true;
                }
                else
                {
                    XTrace(L"Initialize ADLX failed: %d\n", res);
                }
                SetEvent(g_ADLXInitReady);
            }
        }
        break;
        default:
            break;
        }
    }
    break;
    default:
        break;
    }


    XTrace (L"ADLX Call Service: ServiceCtrlHandler: Exit");
    return NO_ERROR;
}


DWORD WINAPI ServiceWorkerThread (LPVOID lpParam)
{
    XTrace (L"ADLX Call Service: ServiceWorkerThread: Entry");


    // Check if any user is logged on
    if (!IsAnyUserLogon())
    {
        XTrace(L"No user logon, wait for user logon");
        g_ADLXAlive = false;
        WaitForSingleObject(g_ADLXInitReady, INFINITE);
    }


    ADLX_RESULT res = g_ADLXHelp.Initialize();
    XTrace(L"--Initialize:  %d\n", res);
    if (ADLX_SUCCEEDED(res))
    {
        g_ADLXAlive = true;


        auto iloop = 40;
        while (iloop-- > 0 && !g_StopWorkThread)
        {
            // Get GPU list
            IADLXGPUListPtr gpus;
            res = g_ADLXHelp.GetSystemServices()->GetGPUs(&gpus);
            if (ADLX_SUCCEEDED(res) && !gpus->Empty())
            {
                IADLXGPUPtr gpuInfo;
                adlx_uint index = 0;
                res = gpus->At(index, &gpuInfo);


                if (ADLX_SUCCEEDED(res))
                {
                    const char* vendorId = nullptr;
                    res = gpuInfo->VendorId(&vendorId);
                    if (ADLX_SUCCEEDED(res))
                    {
                        XTrace(L"--VenderId=%hs\n", vendorId);
                    }


                    const char* gpuName = nullptr;
                    res = gpuInfo->Name(&gpuName);
                    if (ADLX_SUCCEEDED(res))
                    {
                        XTrace(L"--GpuName=%hs\n", gpuName);
                    }
                }
            }
            if (res == ADLX_ORPHAN_OBJECTS)
            {
                XTrace(L"ADLX return ADLX_ORPHAN_OBJECTS");
                // Terminate ADLX, discard all the cached ADLX interfaces and wait for the right conditions to re-initialize ADLX
                g_ADLXHelp.Terminate();
                g_ADLXAlive = false;


                //Attempt to re-initialize, if another user is still logged on
                if (IsAnyUserLogon())
                {
                    res = g_ADLXHelp.Initialize();
                    if (ADLX_SUCCEEDED(res))
                    {
                        XTrace(L"ADLX recovered ");
                        g_ADLXAlive = true;
                    }
                }


                if (!g_ADLXAlive)
                {
                    WaitForSingleObject(g_ADLXInitReady, INFINITE);
                    continue;
                }
            }


            // Get performance monitoring service
            IADLXPerformanceMonitoringServicesPtr perfMonitorServ;
            res = g_ADLXHelp.GetSystemServices()->GetPerformanceMonitoringServices(&perfMonitorServ);
            XTrace(L"--GetPerformanceMonitoringServices:  %d\n", res);
            if (ADLX_SUCCEEDED(res))
            {
                ADLX_IntRange range;
                res = perfMonitorServ->GetSamplingIntervalRange(&range);
                XTrace(L"--GetSamplingIntervalRange:  %d\n", res);
                XTrace(L"range.minValue: %d, range.maxValue: %d, range.step: %d", range.minValue, range.maxValue, range.step);
            }
            if (res == ADLX_ORPHAN_OBJECTS)
            {
                XTrace(L"ADLX return ADLX_ORPHAN_OBJECTS");
                // Terminate ADLX, discard all the cached ADLX interfaces and wait for the right conditions to re-initialize ADLX
                g_ADLXHelp.Terminate();
                g_ADLXAlive = false;


                //Attempt to re-initialize, if another user is still logged on
                if (IsAnyUserLogon())
                {
                    res = g_ADLXHelp.Initialize();
                    if (ADLX_SUCCEEDED(res))
                    {
                        XTrace(L"ADLX recovered ");
                        g_ADLXAlive = true;
                    }
                }


                if (!g_ADLXAlive)
                {
                    WaitForSingleObject(g_ADLXInitReady, INFINITE);
                    continue;
                }
            }
            Sleep(3000);
        }
    }


    Sleep(3000);
    g_ADLXHelp.Terminate();


    XTrace (L"ADLX Call Service: ServiceWorkerThread: Exit");


    return ERROR_SUCCESS;
}


bool IsAnyUserLogon ()
{
    bool isUserLogon = false;
    WTS_SESSION_INFO *pSessionInfo = NULL;
    DWORD sessionCount = 0;
    if (WTSEnumerateSessions(WTS_CURRENT_SERVER_HANDLE, 0, 1, &pSessionInfo, &sessionCount) == TRUE && pSessionInfo != NULL)
    {
        for (DWORD i = 0; i < sessionCount; i++)
        {
            if (pSessionInfo[i].State == WTSActive)
            {
                isUserLogon = true;
                break;
            }
        }
        WTSFreeMemory(pSessionInfo);
    }
    return isUserLogon;
}


void InstallService ()
{
    WCHAR path[512] = { 0 };
    if (GetModuleFileNameW (NULL, path, 512) == 0)
    {
        XTrace (L"ADLX Call Service: InstallService: Cannot get file path.");
        return;
    }


    SC_HANDLE serviceManager = OpenSCManager (NULL, NULL, SC_MANAGER_CONNECT | SC_MANAGER_CREATE_SERVICE);
    if (serviceManager)
    {
        SC_HANDLE serviceHandle = CreateServiceW (
            serviceManager, ADLX_SERVICE_NAME, ADLX_SERVICE_NAME, SERVICE_QUERY_STATUS,
            SERVICE_WIN32_OWN_PROCESS | SERVICE_INTERACTIVE_PROCESS,
            SERVICE_AUTO_START, SERVICE_ERROR_NORMAL, path,
            NULL, NULL, L"", NULL, NULL);


        if (serviceHandle)
        {
            CloseServiceHandle (serviceHandle);
        }
        else
        {
            XTrace (L"ADLX Call Service: InstallService: Cannot create service.");
        }


        CloseServiceHandle (serviceManager);
    }
    else
    {
        XTrace (L"ADLX Call Service: InstallService: Cannot open service.");
    }
}


void RemoveService ()
{
    SC_HANDLE serviceManager = OpenSCManager (NULL, NULL, SC_MANAGER_CONNECT);
    if (!serviceManager)
    {
        XTrace (L"ADLX Call Service: RemoveService: Cannot open service manager.");
        return;
    }


    SC_HANDLE serviceHandle = OpenServiceW (serviceManager, ADLX_SERVICE_NAME, DELETE | SERVICE_STOP);
    if (!serviceHandle)
    {
        CloseServiceHandle (serviceManager);
        XTrace (L"ADLX Call Service: RemoveService: Cannot open service.");
        return;
    }


    if (!DeleteService (serviceHandle))
    {
        CloseServiceHandle (serviceHandle);
        CloseServiceHandle (serviceManager);
        XTrace (L"ADLX Call Service: RemoveService: Delete service failed.");
        return;
    }


    XTrace (L"ADLX Call Service: RemoveService: Deleted service.");


    SERVICE_STATUS serviceStatus = { 0 };
    ControlService (serviceHandle, SERVICE_CONTROL_STOP, (LPSERVICE_STATUS)&serviceStatus);


    CloseServiceHandle (serviceHandle);
    CloseServiceHandle (serviceManager);
}

See Also: ADLX Macro, ADLX_IntRange, ADLX Enums