获取OpenGL版本号、双显卡切换技术代码实现（Optimus、NVAPI、CUDA）

#include "GL\glew.h"
#include "GL\glut.h"
#include <Windows.h>
#pragma comment(lib,"glew32.lib")
#pragma comment(lib,"opengl32.lib")
#pragma comment(lib,"glu32.lib")

int main(int argc, char **argv)
{
  glutInit(&argc, argv);
  int wnd = glutCreateWindow("GLUT");

  glewInit();
  printf("OpenGL vendor string: %s\n", glGetString(GL_VENDOR));
  printf("OpenGL renderer string: %s\n", glGetString(GL_RENDERER));
  printf("OpenGL version string: %s\n", glGetString(GL_VERSION));

  glutDestroyWindow(wnd);
  return 0;
}

#include "GL\glew.h"
#include <Windows.h>

#pragma comment(lib,"opengl32.lib")
#pragma comment(lib,"glu32.lib")
#pragma comment(lib,"glew32.lib")

typedef struct GLContextStruct
{
  HWND wnd;
  HDC dc;
  HGLRC rc;
} GLContext;

void InitContext(GLContext* ctx);
GLboolean CreateContext(GLContext* ctx);
void DestroyContext(GLContext* ctx);
void PrintExtensions(const char* s);

int main(int argc, char **argv)
{
  GLenum err;
  GLContext ctx;

  /* ---------------------------------------------------------------------- */
  /* create OpenGL rendering context */
  InitContext(&ctx);
  if (GL_TRUE == CreateContext(&ctx))
  {
    fprintf(stderr, "Error: CreateContext failed\n");
    DestroyContext(&ctx);
    return 1;
  }

  /* ---------------------------------------------------------------------- */
 /* initialize GLEW */
  glewExperimental = GL_TRUE;
  err = glewInit();
  if (GLEW_OK != err)
  {
    fprintf(stderr, "Error [main]: glewInit failed: %s\n", glewGetErrorString(err));
    DestroyContext(&ctx);
    return 1;
  }

  /* ---------------------------------------------------------------------- */
  /* output header information */
  /* OpenGL extensions */
  printf("OpenGL vendor string: %s\n", glGetString(GL_VENDOR));
  printf("OpenGL renderer string: %s\n", glGetString(GL_RENDERER));
  printf("OpenGL version string: %s\n", glGetString(GL_VERSION));
  printf("OpenGL extensions (GL_): \n");
  PrintExtensions((const char*)glGetString(GL_EXTENSIONS));

  /* GLU extensions */
  printf("GLU version string: %s\n", gluGetString(GLU_VERSION));
  printf("GLU extensions (GLU_): \n");
  PrintExtensions((const char*)gluGetString(GLU_EXTENSIONS));

  DestroyContext(&ctx);
  return 0;
}


void InitContext(GLContext* ctx)
{
  ctx->wnd = NULL;
  ctx->dc = NULL;
  ctx->rc = NULL;
}

GLboolean CreateContext(GLContext* ctx)
{
  WNDCLASS wc;
  PIXELFORMATDESCRIPTOR pfd;
  /* check for input */
  if (NULL == ctx) return GL_TRUE;
  /* register window class */
  ZeroMemory(&wc, sizeof(WNDCLASS));
  wc.hInstance = GetModuleHandle(NULL);
  wc.lpfnWndProc = DefWindowProc;
  wc.lpszClassName = "GLTEST";
  if (0 == RegisterClass(&wc)) return GL_TRUE;

  /* create window */
  ctx->wnd = CreateWindow("GLTEST", "GLTEST", 0, CW_USEDEFAULT, CW_USEDEFAULT,
    CW_USEDEFAULT, CW_USEDEFAULT, NULL, NULL,
    GetModuleHandle(NULL), NULL);
  if (NULL == ctx->wnd) return GL_TRUE;
  /* get the device context */
  ctx->dc = GetDC(ctx->wnd);
  if (NULL == ctx->dc) return GL_TRUE;
  /* find pixel format */
  ZeroMemory(&pfd, sizeof(PIXELFORMATDESCRIPTOR));
  pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR);
  pfd.nVersion = 1;
  pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL;
  int visual = ChoosePixelFormat(ctx->dc, &pfd);
  if (0 == visual) return GL_TRUE;

  /* set the pixel format for the dc */
  if (FALSE == SetPixelFormat(ctx->dc, visual, &pfd)) return GL_TRUE;
  /* create rendering context */
  ctx->rc = wglCreateContext(ctx->dc);
  if (NULL == ctx->rc) return GL_TRUE;
  if (FALSE == wglMakeCurrent(ctx->dc, ctx->rc)) return GL_TRUE;
  return GL_FALSE;
}

void DestroyContext(GLContext* ctx)
{
  if (NULL == ctx) return;
  if (NULL != ctx->rc) wglMakeCurrent(NULL, NULL);
  if (NULL != ctx->rc) wglDeleteContext(wglGetCurrentContext());
  if (NULL != ctx->wnd && NULL != ctx->dc) ReleaseDC(ctx->wnd, ctx->dc);
  if (NULL != ctx->wnd) DestroyWindow(ctx->wnd);
  UnregisterClass("GLEW", GetModuleHandle(NULL));
}

/* do the magic to separate all extensions with comma's, except
   for the last one that _may_ terminate in a space. */
void PrintExtensions(const char* s)
{
  char t[80];
  int i = 0;
  char* p = 0;

  t[79] = '\0';
  while (*s)
  {
    t[i++] = *s;
    if (*s == ' ')
    {
      if (*(s + 1) != '\0') {
        t[i - 1] = ',';
        t[i] = ' ';
        p = &t[i++];
      }
      else /* zoinks! last one terminated in a space! */
      {
        t[i - 1] = '\0';
      }
    }
    if (i > 80 - 5)
    {
      *p = t[i] = '\0';
      printf("    %s\n", t);
      p++;
      i = (int)strlen(p);
#if defined(_MSC_VER) && (_MSC_VER >= 1400)
      strcpy_s(t, sizeof(t), p);
#else
      strcpy(t, p);
#endif
    }
    s++;
  }
  t[i] = '\0';
  printf("    %s.\n", t);
}

#include <glad/glad.h>
#include <GLFW/glfw3.h>
#pragma comment(lib,"opengl32.lib")
#pragma comment(lib,"glu32.lib")
#pragma comment(lib,"glfw3.lib")

int main(int argc, char **argv)
{
  const unsigned int SCR_WIDTH = 800;
  const unsigned int SCR_HEIGHT = 600;

  glfwInit();
  //glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
  //glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
  //glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

  GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "GLFW", NULL, NULL);
  if (window == NULL)
  {
    std::cout << "Failed to create GLFW window" << std::endl;
    glfwTerminate();
    return -1;
  }
  glfwMakeContextCurrent(window);

  if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
  {
    std::cout << "Failed to initialize GLAD" << std::endl;
    return -1;
  }
  printf("OpenGL vendor string: %s\n", glGetString(GL_VENDOR));
  printf("OpenGL renderer string: %s\n", glGetString(GL_RENDERER));
  printf("OpenGL version string: %s\n", glGetString(GL_VERSION));
  
  glfwTerminate();
  return 0;
}

public class MainActivity extends AppCompatActivity {

    private AppBarConfiguration appBarConfiguration;
    private ActivityMainBinding binding;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        binding = ActivityMainBinding.inflate(getLayoutInflater());
        setContentView(binding.getRoot());
        setSupportActionBar(binding.toolbar);

        NavController navController = Navigation.findNavController(this, R.id.nav_host_fragment_content_main);
        appBarConfiguration = new AppBarConfiguration.Builder(navController.getGraph()).build();
        NavigationUI.setupActionBarWithNavController(this, navController, appBarConfiguration);

        binding.fab.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Snackbar.make(view, "Replace with your own action", Snackbar.LENGTH_LONG)
                        .setAction("Action", null).show();
            }
        });

        // 获取设备的OpenGL ES的版本号
        ActivityManager am =(ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
        ConfigurationInfo info = am.getDeviceConfigurationInfo();
        String hex = Integer.toHexString (info.reqGlEsVersion);
        System.out.println("OpenGL ES版本：" + hex + "(" + info.reqGlEsVersion+")");

    }

<!DOCTYPE html>
<html>
<head>
    <meta lang="en">
    <meta charset="UTF-8">
    <title>WebGL Test</title>
    <link href="style/style.css">
    <script type="text/javascript" src="webgl_test1.js"></script>
</head>
<body>
<canvas id="canvas" width="200px" height="200px"></canvas>
</body>
</html>

/**
 * Created by Tomcat on 2022-01-05
 */
window.onload = function () {

    //获取canvas元素
    var canvas = document.getElementById('canvas');
    
    //获取绘制二维上下文
    var gl = canvas.getContext('webgl');
    if (!gl) {
        console.log("Failed");
        return;
    }
   
    //打印OpenGL信息
    const gl1 = canvas.getContext("webgl");
    if (!gl1) { console.log("WebGL1不支持！"); }
    
    const gl2 = canvas.getContext("webgl2");
    if (!gl2) { console.log("WebGL2不支持！"); }
    
    var info1 = gl.getParameter(gl.VERSION);
    if (info1) { console.log(info1); }
    
    var info2 = gl.getParameter(gl.SHADING_LANGUAGE_VERSION);
    if (info2) { console.log(info2); }
    
}

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>

<head>
  <title>3D Simulation</title>
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <style>
    #mycanvas,
    #viewContainer,
    body,
    html {
      width: 100%;
      height: 100%
    }

    body,
    html {
      border: 0;
      padding: 0;
      margin: 0;
      position: fixed
    }
</style>
</head>

<body>
    <div id="viewContainer">
        <canvas id="mycanvas" width="1920" height="1080">Loading...</canvas>
    </div>

    <script type="text/javascript">
    var gl;
    var c = null;

    function sleep(milliseconds) {
      var start = new Date().getTime();
      for (var i = 0; i < 1e7; i++) {
        if ((new Date().getTime() - start) > milliseconds) {
          break;
        }
      }
    }

    function initGL() {
      if (!window.WebGLRenderingContext) {
        alert("Your browser does not accept WebGL content");
        window.location = "http://get.webgl.org";
      } else {
        try {
          c = document.getElementById("mycanvas");
          // c = = document.querySelector("#mycanvas");
          gl = c.getContext("webgl");
          if (!gl) {
            gl = c.getContext("experimental-webgl");
          }
          if (!gl) {
            alert("Could not initialise WebGL");
            //alert("无法初始化WebGL，你的浏览器、操作系统或硬件等可能不支持WebGL。");
          }
        } catch (e) {
          alert("Could not initialise WebGL: " + e);
        }
      }
    }

    window.onload = function () {
      webGLStart();
    }
    function webGLStart() {
        initGL();

        // 使用完全不透明的黑色清除所有图像
        gl.clearColor(0.0, 0.0, 0.0, 1.0);
        // 用上面指定的颜色清除缓冲区
        gl.clear(gl.COLOR_BUFFER_BIT);
    }
    </script>

</body>
</html>

//NVAPI R470, 2021/07/13
//VC++2017
//Create by tomcat on 2022-01-09
#include "nvapi/nvapi.h"
#include "nvapi/NvApiDriverSettings.h"
int addExeToNvidiaGpu()
{
  //
  wchar_t szProfileName[256] = { 0 };
  wchar_t szAppName[256] = { 0 };
  GetModuleFileNameW(NULL, szAppName, 256);
  wchar_t* pFileName = wcsrchr(szAppName, '\\');
  if (pFileName) pFileName++;
  if (pFileName) wcscpy(szProfileName, pFileName);

  //
  NvAPI_Status status = NVAPI_OK;
  status = NvAPI_Initialize();
  if (status != NVAPI_OK)
  {
    return -1;
  }
  NvDRSSessionHandle hSession = 0;
  status = NvAPI_DRS_CreateSession(&hSession);
  if (status != NVAPI_OK)
  {
    return -2;
  }
  status = NvAPI_DRS_LoadSettings(hSession);
  if (status != NVAPI_OK)
  {
    return -3;
  }

  NvDRSProfileHandle hProfile = 0;
  NvAPI_UnicodeString profile_name = {0};
  memcpy_s(profile_name, sizeof(profile_name), szProfileName, wcslen(szProfileName) * sizeof(wchar_t));
  status = NvAPI_DRS_FindProfileByName(hSession, profile_name, &hProfile);
  if (status == NVAPI_OK) {
    status = NvAPI_DRS_DeleteProfile(hSession, hProfile);
    if (status != NVAPI_OK)
    {
      return -10;
    }
    status = NvAPI_DRS_SaveSettings(hSession);
    if (status != NVAPI_OK)
    {
      return -11;
    }
    status = NvAPI_DRS_LoadSettings(hSession);
    if (status != NVAPI_OK)
    {
      return -12;
    }
  }
  
  NVDRS_PROFILE drsProfile = { 0 };
  drsProfile.version = NVDRS_PROFILE_VER;
  drsProfile.isPredefined = 0;
  memcpy_s(drsProfile.profileName, sizeof(drsProfile.profileName), szProfileName, wcslen(szProfileName) * sizeof(wchar_t));
  status = NvAPI_DRS_CreateProfile(hSession, &drsProfile, &hProfile);
  if (status != NVAPI_OK)
  {
    return -13;
  }

  NVDRS_APPLICATION app;
  memset(&app, 0, sizeof(NVDRS_APPLICATION));
  app.version = NVDRS_APPLICATION_VER;
  app.isPredefined = 0;
  memcpy_s(app.appName, sizeof(app.appName), szAppName, 256 * sizeof(wchar_t));
  memcpy_s(app.userFriendlyName, sizeof(app.appName), szAppName, 256 * sizeof(wchar_t));
  status = NvAPI_DRS_CreateApplication(hSession, hProfile, &app);
  if (status != NVAPI_OK)
  {
    return -14;
  }

  NVDRS_SETTING drsSetting = { 0 };
  drsSetting.version = NVDRS_SETTING_VER;
  drsSetting = NVDRS_SETTING();
  drsSetting.version = NVDRS_SETTING_VER;
  drsSetting.settingId = SHIM_MCCOMPAT_ID;
  drsSetting.settingType = NVDRS_DWORD_TYPE;
  drsSetting.u32CurrentValue = SHIM_MCCOMPAT_ENABLE;
  status = NvAPI_DRS_SetSetting(hSession, hProfile, &drsSetting);
  if (status != NVAPI_OK)
  {
    return -15;
  }

  drsSetting = NVDRS_SETTING();
  drsSetting.version = NVDRS_SETTING_VER;
  drsSetting.settingId = SHIM_RENDERING_MODE_ID;
  drsSetting.settingType = NVDRS_DWORD_TYPE;
  drsSetting.u32CurrentValue = SHIM_RENDERING_MODE_ENABLE;
  status = NvAPI_DRS_SetSetting(hSession, hProfile, &drsSetting);
  if (status != NVAPI_OK)
  {
    return -16;
  }

  drsSetting = NVDRS_SETTING();
  drsSetting.version = NVDRS_SETTING_VER;
  drsSetting.settingId = SHIM_RENDERING_OPTIONS_ID;
  drsSetting.settingType = NVDRS_DWORD_TYPE;
  drsSetting.u32CurrentValue = SHIM_RENDERING_OPTIONS_DEFAULT_RENDERING_MODE;
  status = NvAPI_DRS_SetSetting(hSession, hProfile, &drsSetting);
  if (status != NVAPI_OK)
  {
    return -17;
  }
  status = NvAPI_DRS_SaveSettings(hSession);
  if (status != NVAPI_OK)
  {
    return -18;
  }
  status = NvAPI_DRS_DestroySession(hSession);
  if (status != NVAPI_OK)
  {
    return -19;
  }
  hSession = 0;
  NvAPI_Unload();
  return 0;
}

nvcc -V

// http://developer.download.nvidia.com/devzone/devcenter/gamegraphics/files/OptimusRenderingPolicies.pdf
// The following line is to favor the high performance NVIDIA GPU if there are multiple GPUs
// Has to be .exe module to be correctly detected.
// N卡使用独显运行
extern "C" __declspec(dllexport) DWORD NvOptimusEnablement = 0x00000001;

// And the AMD equivalent
// Also has to be .exe module to be correctly detected.
// A显卡使用独显运行
extern "C" __declspec(dllexport) int AmdPowerXpressRequestHighPerformance = 0x00000001;

#include <GL/wglew.h>
...
//禁用垂直同步
wglSwapIntervalEXT(0);

//启用垂直同步
wglSwapIntervalEXT(1);

nvidia-smi

nvidia-smi -l 3

nvidia-smi --query-gpu=gpu_name,gpu_bus_id,vbios_version --format=csv

nvidia-smi --query-gpu=timestamp,memory.total,memory.free,memory.used,name,utilization.gpu,utilization.memory --format=csv -l 5