Make Mac SystemInfo reflect the currently active GPU on dual GPU machines

BUILD.gn

@@ -371,6 +371,7 @@ angle_static_library("angle_gpu_info_util") {
       "IOKit.framework",
       "CoreFoundation.framework",
       "CoreGraphics.framework",
+      "OpenGL.framework",
     ]
   }
 }

src/gpu_info_util/SystemInfo.cpp

@@ -238,7 +238,7 @@ bool CMDeviceIDToDeviceAndVendorID(const std::string &id, uint32_t *vendorId, ui
     return success;
 }
 
-void FindActiveGPU(SystemInfo *info)
+void GetDualGPUInfo(SystemInfo *info)
 {
     ASSERT(!info->gpus.empty());
 

src/gpu_info_util/SystemInfo.h

@@ -108,6 +108,11 @@ bool IsVeriSilicon(VendorID vendorId);
 bool IsVMWare(VendorID vendorId);
 bool IsVivante(VendorID vendorId);
 
+// Use a heuristic to attempt to find the GPU used for 3D graphics. Sets activeGPUIndex,
+// isOptimus, and isAMDSwitchable.
+// Always assumes the non-Intel GPU is active on dual-GPU machines.
+void GetDualGPUInfo(SystemInfo *info);
+
 // Dumps the system info to stdout.
 void PrintSystemInfo(const SystemInfo &info);
 }  // namespace angle

src/gpu_info_util/SystemInfo_internal.h

@@ -29,10 +29,6 @@ bool ParseMacMachineModel(const std::string &identifier,
                           int32_t *minor);
 bool CMDeviceIDToDeviceAndVendorID(const std::string &id, uint32_t *vendorId, uint32_t *deviceId);
 
-// Use a heuristic to attempt to find the GPU used for 3D graphics. Sets activeGPUIndex,
-// isOptimus, and isAMDSwitchable. Deprecated: also sets primaryGPUIndex.
-void FindActiveGPU(SystemInfo *info);
-
 }  // namespace angle
 
 #endif  // GPU_INFO_UTIL_SYSTEM_INFO_INTERNAL_H_

src/gpu_info_util/SystemInfo_linux.cpp

@@ -81,7 +81,7 @@ bool GetSystemInfo(SystemInfo *info)
         return false;
     }
 
-    FindActiveGPU(info);
+    GetDualGPUInfo(info);
 
     for (size_t i = 0; i < info->gpus.size(); ++i)
     {

src/gpu_info_util/SystemInfo_mac.mm

@@ -17,6 +17,52 @@ namespace angle
 namespace
 {
 
+using PlatformDisplayID = uint32_t;
+
+constexpr CGLRendererProperty kCGLRPRegistryIDLow  = static_cast<CGLRendererProperty>(140);
+constexpr CGLRendererProperty kCGLRPRegistryIDHigh = static_cast<CGLRendererProperty>(141);
+
+// Code from WebKit to get the active GPU's ID given a display ID.
+uint64_t GetGpuIDFromDisplayID(PlatformDisplayID displayID)
+{
+    GLuint displayMask              = CGDisplayIDToOpenGLDisplayMask(displayID);
+    GLint numRenderers              = 0;
+    CGLRendererInfoObj rendererInfo = nullptr;
+    CGLError error = CGLQueryRendererInfo(displayMask, &rendererInfo, &numRenderers);
+    if (!numRenderers || !rendererInfo || error != kCGLNoError)
+        return 0;
+
+    // The 0th renderer should not be the software renderer.
+    GLint isAccelerated;
+    error = CGLDescribeRenderer(rendererInfo, 0, kCGLRPAccelerated, &isAccelerated);
+    if (!isAccelerated || error != kCGLNoError)
+    {
+        CGLDestroyRendererInfo(rendererInfo);
+        return 0;
+    }
+
+    GLint gpuIDLow  = 0;
+    GLint gpuIDHigh = 0;
+
+    error = CGLDescribeRenderer(rendererInfo, 0, kCGLRPRegistryIDLow, &gpuIDLow);
+
+    if (error != kCGLNoError || gpuIDLow < 0)
+    {
+        CGLDestroyRendererInfo(rendererInfo);
+        return 0;
+    }
+
+    error = CGLDescribeRenderer(rendererInfo, 0, kCGLRPRegistryIDHigh, &gpuIDHigh);
+    if (error != kCGLNoError || gpuIDHigh < 0)
+    {
+        CGLDestroyRendererInfo(rendererInfo);
+        return 0;
+    }
+
+    CGLDestroyRendererInfo(rendererInfo);
+    return static_cast<uint64_t>(gpuIDHigh) << 32 | gpuIDLow;
+}
+
 std::string GetMachineModel()
 {
     io_service_t platformExpert = IOServiceGetMatchingService(
@@ -106,6 +152,44 @@ bool GetPCIDevices(std::vector<GPUDeviceInfo> *devices)
     return true;
 }
 
+void SetActiveGPUIndex(SystemInfo *info)
+{
+    VendorID activeVendor;
+    DeviceID activeDevice;
+
+    uint64_t gpuID = GetGpuIDFromDisplayID(kCGDirectMainDisplay);
+
+    if (gpuID == 0)
+        return;
+
+    CFMutableDictionaryRef matchDictionary = IORegistryEntryIDMatching(gpuID);
+    io_service_t gpuEntry = IOServiceGetMatchingService(kIOMasterPortDefault, matchDictionary);
+
+    if (gpuEntry == IO_OBJECT_NULL)
+    {
+        IOObjectRelease(gpuEntry);
+        return;
+    }
+
+    if (!(GetEntryProperty(gpuEntry, CFSTR("vendor-id"), &activeVendor) &&
+          GetEntryProperty(gpuEntry, CFSTR("device-id"), &activeDevice)))
+    {
+        IOObjectRelease(gpuEntry);
+        return;
+    }
+
+    IOObjectRelease(gpuEntry);
+
+    for (size_t i = 0; i < info->gpus.size(); ++i)
+    {
+        if (info->gpus[i].vendorId == activeVendor && info->gpus[i].deviceId == activeDevice)
+        {
+            info->activeGPUIndex = static_cast<int>(i);
+            break;
+        }
+    }
+}
+
 }  // anonymous namespace
 
 bool GetSystemInfo(SystemInfo *info)
@@ -127,7 +211,16 @@ bool GetSystemInfo(SystemInfo *info)
         return false;
     }
 
-    FindActiveGPU(info);
+    // Call the generic GetDualGPUInfo function to initialize info fields
+    // such as isOptimus, isAMDSwitchable, and the activeGPUIndex
+    GetDualGPUInfo(info);
+
+    // Then override the activeGPUIndex field of info to reflect the current
+    // GPU instead of the non-intel GPU
+    if (@available(macOS 10.13, *))
+    {
+        SetActiveGPUIndex(info);
+    }
 
     // Figure out whether this is a dual-GPU system.
     //

src/gpu_info_util/SystemInfo_win.cpp

@@ -88,8 +88,8 @@ bool GetSystemInfo(SystemInfo *info)
         return false;
     }
 
-    // Call FindActiveGPU to populate activeGPUIndex, isOptimus, and isAMDSwitchable.
-    FindActiveGPU(info);
+    // Call GetDualGPUInfo to populate activeGPUIndex, isOptimus, and isAMDSwitchable.
+    GetDualGPUInfo(info);
 
     // Override activeGPUIndex. The first index returned by EnumAdapters is the active GPU. We
     // can override the heuristic to find the active GPU

src/tests/test_utils/angle_test_instantiate.cpp

@@ -112,6 +112,15 @@ SystemInfo *GetTestSystemInfo()
             std::cerr << "Warning: incomplete system info collection.\n";
         }
 
+        // On dual-GPU Macs we want the active GPU to always appear to be the
+        // high-performance GPU for tests.
+        // We can call the generic GPU info collector which selects the
+        // non-Intel GPU as the active one on dual-GPU machines.
+        if (IsOSX())
+        {
+            GetDualGPUInfo(sSystemInfo);
+        }
+
         // Print complete system info when available.
         // Seems to trip up Android test expectation parsing.
         // Also don't print info when a config is selected to prevent test spam.