gpu/config/gpu_control_list_unittest.cc

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <vector>
   6
   7 #include "base/memory/scoped_ptr.h"
   8 #include "gpu/config/gpu_control_list.h"
   9 #include "gpu/config/gpu_info.h"
  10 #include "testing/gtest/include/gtest/gtest.h"
  11
  12 const char kOsVersion[] = "10.6.4";
  13 const uint32 kIntelVendorId = 0x8086;
  14 const uint32 kNvidiaVendorId = 0x10de;
  15 const uint32 kAmdVendorId = 0x10de;
  16
  17 #define LONG_STRING_CONST(...) #__VA_ARGS__
  18
  19 #define EXPECT_EMPTY_SET(feature_set) EXPECT_EQ(0u, feature_set.size())
  20 #define EXPECT_SINGLE_FEATURE(feature_set, feature) \
  21     EXPECT_TRUE(feature_set.size() == 1 && feature_set.count(feature) == 1)
  22
  23 namespace gpu {
  24
  25 enum TestFeatureType {
  26   TEST_FEATURE_0 = 1,
  27   TEST_FEATURE_1 = 1 << 2,
  28   TEST_FEATURE_2 = 1 << 3,
  29 };
  30
  31 class GpuControlListTest : public testing::Test {
  32  public:
  33   GpuControlListTest() { }
  34
  35   ~GpuControlListTest() override {}
  36
  37   const GPUInfo& gpu_info() const {
  38     return gpu_info_;
  39   }
  40
  41   GpuControlList* Create() {
  42     GpuControlList* rt = new GpuControlList();
  43     rt->AddSupportedFeature("test_feature_0", TEST_FEATURE_0);
  44     rt->AddSupportedFeature("test_feature_1", TEST_FEATURE_1);
  45     rt->AddSupportedFeature("test_feature_2", TEST_FEATURE_2);
  46     return rt;
  47   }
  48
  49  protected:
  50   void SetUp() override {
  51     gpu_info_.gpu.vendor_id = kNvidiaVendorId;
  52     gpu_info_.gpu.device_id = 0x0640;
  53     gpu_info_.driver_vendor = "NVIDIA";
  54     gpu_info_.driver_version = "1.6.18";
  55     gpu_info_.driver_date = "7-14-2009";
  56     gpu_info_.machine_model_name = "MacBookPro";
  57     gpu_info_.machine_model_version = "7.1";
  58     gpu_info_.gl_vendor = "NVIDIA Corporation";
  59     gpu_info_.gl_renderer = "NVIDIA GeForce GT 120 OpenGL Engine";
  60   }
  61
  62   void TearDown() override {}
  63
  64  private:
  65   GPUInfo gpu_info_;
  66 };
  67
  68 TEST_F(GpuControlListTest, DefaultControlListSettings) {
  69   scoped_ptr<GpuControlList> control_list(Create());
  70   // Default control list settings: all feature are allowed.
  71   std::set<int> features = control_list->MakeDecision(
  72       GpuControlList::kOsMacosx, kOsVersion, gpu_info());
  73   EXPECT_EMPTY_SET(features);
  74 }
  75
  76 TEST_F(GpuControlListTest, EmptyControlList) {
  77   // Empty list: all features are allowed.
  78   const std::string empty_list_json = LONG_STRING_CONST(
  79       {
  80         "name": "gpu control list",
  81         "version": "2.5",
  82         "entries": [
  83         ]
  84       }
  85   );
  86   scoped_ptr<GpuControlList> control_list(Create());
  87
  88   EXPECT_TRUE(control_list->LoadList(empty_list_json,
  89                                      GpuControlList::kAllOs));
  90   EXPECT_EQ("2.5", control_list->version());
  91   std::set<int> features = control_list->MakeDecision(
  92       GpuControlList::kOsMacosx, kOsVersion, gpu_info());
  93   EXPECT_EMPTY_SET(features);
  94 }
  95
  96 TEST_F(GpuControlListTest, DetailedEntryAndInvalidJson) {
  97   // exact setting.
  98   const std::string exact_list_json = LONG_STRING_CONST(
  99       {
 100         "name": "gpu control list",
 101         "version": "0.1",
 102         "entries": [
 103           {
 104             "id": 5,
 105             "os": {
 106               "type": "macosx",
 107               "version": {
 108                 "op": "=",
 109                 "value": "10.6.4"
 110               }
 111             },
 112             "vendor_id": "0x10de",
 113             "device_id": ["0x0640"],
 114             "driver_version": {
 115               "op": "=",
 116               "value": "1.6.18"
 117             },
 118             "features": [
 119               "test_feature_0"
 120             ]
 121           }
 122         ]
 123       }
 124   );
 125   scoped_ptr<GpuControlList> control_list(Create());
 126
 127   EXPECT_TRUE(control_list->LoadList(exact_list_json, GpuControlList::kAllOs));
 128   std::set<int> features = control_list->MakeDecision(
 129       GpuControlList::kOsMacosx, kOsVersion, gpu_info());
 130   EXPECT_SINGLE_FEATURE(features, TEST_FEATURE_0);
 131
 132   // Invalid json input should not change the current control_list settings.
 133   const std::string invalid_json = "invalid";
 134
 135   EXPECT_FALSE(control_list->LoadList(invalid_json, GpuControlList::kAllOs));
 136   features = control_list->MakeDecision(
 137       GpuControlList::kOsMacosx, kOsVersion, gpu_info());
 138   EXPECT_SINGLE_FEATURE(features, TEST_FEATURE_0);
 139   std::vector<uint32> entries;
 140   control_list->GetDecisionEntries(&entries, false);
 141   ASSERT_EQ(1u, entries.size());
 142   EXPECT_EQ(5u, entries[0]);
 143   EXPECT_EQ(5u, control_list->max_entry_id());
 144 }
 145
 146 TEST_F(GpuControlListTest, VendorOnAllOsEntry) {
 147   // ControlList a vendor on all OS.
 148   const std::string vendor_json = LONG_STRING_CONST(
 149       {
 150         "name": "gpu control list",
 151         "version": "0.1",
 152         "entries": [
 153           {
 154             "id": 1,
 155             "vendor_id": "0x10de",
 156             "features": [
 157               "test_feature_0"
 158             ]
 159           }
 160         ]
 161       }
 162   );
 163   scoped_ptr<GpuControlList> control_list(Create());
 164
 165   // ControlList entries won't be filtered to the current OS only upon loading.
 166   EXPECT_TRUE(control_list->LoadList(vendor_json, GpuControlList::kAllOs));
 167   std::set<int> features = control_list->MakeDecision(
 168       GpuControlList::kOsMacosx, kOsVersion, gpu_info());
 169   EXPECT_SINGLE_FEATURE(features, TEST_FEATURE_0);
 170   features = control_list->MakeDecision(
 171       GpuControlList::kOsWin, kOsVersion, gpu_info());
 172   EXPECT_SINGLE_FEATURE(features, TEST_FEATURE_0);
 173   features = control_list->MakeDecision(
 174       GpuControlList::kOsLinux, kOsVersion, gpu_info());
 175   EXPECT_SINGLE_FEATURE(features, TEST_FEATURE_0);
 176 #if defined(OS_WIN) || defined(OS_LINUX) || defined(OS_MACOSX) || \
 177     defined(OS_OPENBSD)
 178   // ControlList entries will be filtered to the current OS only upon loading.
 179   EXPECT_TRUE(control_list->LoadList(
 180       vendor_json, GpuControlList::kCurrentOsOnly));
 181   features = control_list->MakeDecision(
 182       GpuControlList::kOsMacosx, kOsVersion, gpu_info());
 183   EXPECT_SINGLE_FEATURE(features, TEST_FEATURE_0);
 184   features = control_list->MakeDecision(
 185       GpuControlList::kOsWin, kOsVersion, gpu_info());
 186   EXPECT_SINGLE_FEATURE(features, TEST_FEATURE_0);
 187   features = control_list->MakeDecision(
 188       GpuControlList::kOsLinux, kOsVersion, gpu_info());
 189   EXPECT_SINGLE_FEATURE(features, TEST_FEATURE_0);
 190 #endif
 191 }
 192
 193 TEST_F(GpuControlListTest, UnknownField) {
 194   const std::string unknown_field_json = LONG_STRING_CONST(
 195       {
 196         "name": "gpu control list",
 197         "version": "0.1",
 198         "entries": [
 199           {
 200             "id": 1,
 201             "unknown_field": 0,
 202             "features": [
 203               "test_feature_1"
 204             ]
 205           },
 206           {
 207             "id": 2,
 208             "features": [
 209               "test_feature_0"
 210             ]
 211           }
 212         ]
 213       }
 214   );
 215   scoped_ptr<GpuControlList> control_list(Create());
 216
 217   EXPECT_FALSE(control_list->LoadList(
 218       unknown_field_json, GpuControlList::kAllOs));
 219 }
 220
 221 TEST_F(GpuControlListTest, UnknownExceptionField) {
 222   const std::string unknown_exception_field_json = LONG_STRING_CONST(
 223       {
 224         "name": "gpu control list",
 225         "version": "0.1",
 226         "entries": [
 227           {
 228             "id": 1,
 229             "unknown_field": 0,
 230             "features": [
 231               "test_feature_2"
 232             ]
 233           },
 234           {
 235             "id": 2,
 236             "exceptions": [
 237               {
 238                 "unknown_field": 0
 239               }
 240             ],
 241             "features": [
 242               "test_feature_1"
 243             ]
 244           },
 245           {
 246             "id": 3,
 247             "features": [
 248               "test_feature_0"
 249             ]
 250           }
 251         ]
 252       }
 253   );
 254   scoped_ptr<GpuControlList> control_list(Create());
 255
 256   EXPECT_FALSE(control_list->LoadList(
 257       unknown_exception_field_json, GpuControlList::kAllOs));
 258 }
 259
 260 TEST_F(GpuControlListTest, DisabledEntry) {
 261   const std::string disabled_json = LONG_STRING_CONST(
 262       {
 263         "name": "gpu control list",
 264         "version": "0.1",
 265         "entries": [
 266           {
 267             "id": 1,
 268             "disabled": true,
 269             "features": [
 270               "test_feature_0"
 271             ]
 272           }
 273         ]
 274       }
 275   );
 276   scoped_ptr<GpuControlList> control_list(Create());
 277   EXPECT_TRUE(control_list->LoadList(disabled_json, GpuControlList::kAllOs));
 278   std::set<int> features = control_list->MakeDecision(
 279       GpuControlList::kOsWin, kOsVersion, gpu_info());
 280   EXPECT_EMPTY_SET(features);
 281   std::vector<uint32> flag_entries;
 282   control_list->GetDecisionEntries(&flag_entries, false);
 283   EXPECT_EQ(0u, flag_entries.size());
 284   control_list->GetDecisionEntries(&flag_entries, true);
 285   EXPECT_EQ(1u, flag_entries.size());
 286 }
 287
 288 TEST_F(GpuControlListTest, NeedsMoreInfo) {
 289   const std::string json = LONG_STRING_CONST(
 290       {
 291         "name": "gpu control list",
 292         "version": "0.1",
 293         "entries": [
 294           {
 295             "id": 1,
 296             "os": {
 297               "type": "win"
 298             },
 299             "vendor_id": "0x10de",
 300             "driver_version": {
 301               "op": "<",
 302               "value": "12"
 303             },
 304             "features": [
 305               "test_feature_0"
 306             ]
 307           }
 308         ]
 309       }
 310   );
 311   GPUInfo gpu_info;
 312   gpu_info.gpu.vendor_id = kNvidiaVendorId;
 313
 314   scoped_ptr<GpuControlList> control_list(Create());
 315   EXPECT_TRUE(control_list->LoadList(json, GpuControlList::kAllOs));
 316
 317   std::set<int> features = control_list->MakeDecision(
 318       GpuControlList::kOsWin, kOsVersion, gpu_info);
 319   EXPECT_EMPTY_SET(features);
 320   EXPECT_TRUE(control_list->needs_more_info());
 321   std::vector<uint32> decision_entries;
 322   control_list->GetDecisionEntries(&decision_entries, false);
 323   EXPECT_EQ(0u, decision_entries.size());
 324
 325   gpu_info.driver_version = "11";
 326   features = control_list->MakeDecision(
 327       GpuControlList::kOsWin, kOsVersion, gpu_info);
 328   EXPECT_SINGLE_FEATURE(features, TEST_FEATURE_0);
 329   EXPECT_FALSE(control_list->needs_more_info());
 330   control_list->GetDecisionEntries(&decision_entries, false);
 331   EXPECT_EQ(1u, decision_entries.size());
 332 }
 333
 334 TEST_F(GpuControlListTest, NeedsMoreInfoForExceptions) {
 335   const std::string json = LONG_STRING_CONST(
 336       {
 337         "name": "gpu control list",
 338         "version": "0.1",
 339         "entries": [
 340           {
 341             "id": 1,
 342             "os": {
 343               "type": "linux"
 344             },
 345             "vendor_id": "0x8086",
 346             "exceptions": [
 347               {
 348                 "gl_renderer": ".*mesa.*"
 349               }
 350             ],
 351             "features": [
 352               "test_feature_0"
 353             ]
 354           }
 355         ]
 356       }
 357   );
 358   GPUInfo gpu_info;
 359   gpu_info.gpu.vendor_id = kIntelVendorId;
 360
 361   scoped_ptr<GpuControlList> control_list(Create());
 362   EXPECT_TRUE(control_list->LoadList(json, GpuControlList::kAllOs));
 363
 364   // The case this entry does not apply.
 365   std::set<int> features = control_list->MakeDecision(
 366       GpuControlList::kOsMacosx, kOsVersion, gpu_info);
 367   EXPECT_EMPTY_SET(features);
 368   EXPECT_FALSE(control_list->needs_more_info());
 369
 370   // The case this entry might apply, but need more info.
 371   features = control_list->MakeDecision(
 372       GpuControlList::kOsLinux, kOsVersion, gpu_info);
 373   EXPECT_EMPTY_SET(features);
 374   EXPECT_TRUE(control_list->needs_more_info());
 375
 376   // The case we have full info, and the exception applies (so the entry
 377   // does not apply).
 378   gpu_info.gl_renderer = "mesa";
 379   features = control_list->MakeDecision(
 380       GpuControlList::kOsLinux, kOsVersion, gpu_info);
 381   EXPECT_EMPTY_SET(features);
 382   EXPECT_FALSE(control_list->needs_more_info());
 383
 384   // The case we have full info, and this entry applies.
 385   gpu_info.gl_renderer = "my renderer";
 386   features = control_list->MakeDecision(GpuControlList::kOsLinux, kOsVersion,
 387       gpu_info);
 388   EXPECT_SINGLE_FEATURE(features, TEST_FEATURE_0);
 389   EXPECT_FALSE(control_list->needs_more_info());
 390 }
 391
 392 TEST_F(GpuControlListTest, IgnorableEntries) {
 393   // If an entry will not change the control_list decisions, then it should not
 394   // trigger the needs_more_info flag.
 395   const std::string json = LONG_STRING_CONST(
 396       {
 397         "name": "gpu control list",
 398         "version": "0.1",
 399         "entries": [
 400           {
 401             "id": 1,
 402             "os": {
 403               "type": "linux"
 404             },
 405             "vendor_id": "0x8086",
 406             "features": [
 407               "test_feature_0"
 408             ]
 409           },
 410           {
 411             "id": 2,
 412             "os": {
 413               "type": "linux"
 414             },
 415             "vendor_id": "0x8086",
 416             "driver_version": {
 417               "op": "<",
 418               "value": "10.7"
 419             },
 420             "features": [
 421               "test_feature_0"
 422             ]
 423           }
 424         ]
 425       }
 426   );
 427   GPUInfo gpu_info;
 428   gpu_info.gpu.vendor_id = kIntelVendorId;
 429
 430   scoped_ptr<GpuControlList> control_list(Create());
 431   EXPECT_TRUE(control_list->LoadList(json, GpuControlList::kAllOs));
 432   std::set<int> features = control_list->MakeDecision(
 433       GpuControlList::kOsLinux, kOsVersion, gpu_info);
 434   EXPECT_SINGLE_FEATURE(features, TEST_FEATURE_0);
 435   EXPECT_FALSE(control_list->needs_more_info());
 436 }
 437
 438 TEST_F(GpuControlListTest, ExceptionWithoutVendorId) {
 439   const std::string json = LONG_STRING_CONST(
 440       {
 441         "name": "gpu control list",
 442         "version": "0.1",
 443         "entries": [
 444           {
 445             "id": 1,
 446             "os": {
 447               "type": "linux"
 448             },
 449             "vendor_id": "0x8086",
 450             "exceptions": [
 451               {
 452                 "device_id": ["0x2a06"],
 453                 "driver_version": {
 454                   "op": ">=",
 455                   "value": "8.1"
 456                 }
 457               },
 458               {
 459                 "device_id": ["0x2a02"],
 460                 "driver_version": {
 461                   "op": ">=",
 462                   "value": "9.1"
 463                 }
 464               }
 465             ],
 466             "features": [
 467               "test_feature_0"
 468             ]
 469           }
 470         ]
 471       }
 472   );
 473   GPUInfo gpu_info;
 474   gpu_info.gpu.vendor_id = kIntelVendorId;
 475   gpu_info.gpu.device_id = 0x2a02;
 476   gpu_info.driver_version = "9.1";
 477
 478   scoped_ptr<GpuControlList> control_list(Create());
 479   EXPECT_TRUE(control_list->LoadList(json, GpuControlList::kAllOs));
 480
 481   std::set<int> features = control_list->MakeDecision(
 482       GpuControlList::kOsLinux, kOsVersion, gpu_info);
 483   EXPECT_EMPTY_SET(features);
 484
 485   gpu_info.driver_version = "9.0";
 486   features = control_list->MakeDecision(
 487       GpuControlList::kOsLinux, kOsVersion, gpu_info);
 488   EXPECT_SINGLE_FEATURE(features, TEST_FEATURE_0);
 489 }
 490
 491 TEST_F(GpuControlListTest, AMDSwitchable) {
 492   GPUInfo gpu_info;
 493   gpu_info.amd_switchable = true;
 494   gpu_info.gpu.vendor_id = kAmdVendorId;
 495   gpu_info.gpu.device_id = 0x6760;
 496   GPUInfo::GPUDevice integrated_gpu;
 497   integrated_gpu.vendor_id = kIntelVendorId;
 498   integrated_gpu.device_id = 0x0116;
 499   gpu_info.secondary_gpus.push_back(integrated_gpu);
 500
 501   {  // amd_switchable_discrete entry
 502     const std::string json= LONG_STRING_CONST(
 503         {
 504           "name": "gpu control list",
 505           "version": "0.1",
 506           "entries": [
 507             {
 508               "id": 1,
 509               "os": {
 510                 "type": "win"
 511               },
 512               "multi_gpu_style": "amd_switchable_discrete",
 513               "features": [
 514                 "test_feature_0"
 515               ]
 516             }
 517           ]
 518         }
 519     );
 520
 521     scoped_ptr<GpuControlList> control_list(Create());
 522     EXPECT_TRUE(control_list->LoadList(json, GpuControlList::kAllOs));
 523
 524     // Integrated GPU is active
 525     gpu_info.gpu.active = false;
 526     gpu_info.secondary_gpus[0].active = true;
 527     std::set<int> features = control_list->MakeDecision(
 528         GpuControlList::kOsWin, kOsVersion, gpu_info);
 529     EXPECT_EMPTY_SET(features);
 530
 531     // Discrete GPU is active
 532     gpu_info.gpu.active = true;
 533     gpu_info.secondary_gpus[0].active = false;
 534     features = control_list->MakeDecision(
 535         GpuControlList::kOsWin, kOsVersion, gpu_info);
 536     EXPECT_SINGLE_FEATURE(features, TEST_FEATURE_0);
 537   }
 538
 539   {  // amd_switchable_integrated entry
 540     const std::string json= LONG_STRING_CONST(
 541         {
 542           "name": "gpu control list",
 543           "version": "0.1",
 544           "entries": [
 545             {
 546               "id": 1,
 547               "os": {
 548                 "type": "win"
 549               },
 550               "multi_gpu_style": "amd_switchable_integrated",
 551               "features": [
 552                 "test_feature_0"
 553               ]
 554             }
 555           ]
 556         }
 557     );
 558
 559     scoped_ptr<GpuControlList> control_list(Create());
 560     EXPECT_TRUE(control_list->LoadList(json, GpuControlList::kAllOs));
 561
 562     // Discrete GPU is active
 563     gpu_info.gpu.active = true;
 564     gpu_info.secondary_gpus[0].active = false;
 565     std::set<int> features = control_list->MakeDecision(
 566         GpuControlList::kOsWin, kOsVersion, gpu_info);
 567     EXPECT_EMPTY_SET(features);
 568
 569     // Integrated GPU is active
 570     gpu_info.gpu.active = false;
 571     gpu_info.secondary_gpus[0].active = true;
 572     features = control_list->MakeDecision(
 573         GpuControlList::kOsWin, kOsVersion, gpu_info);
 574     EXPECT_SINGLE_FEATURE(features, TEST_FEATURE_0);
 575
 576     // For non AMD switchable
 577     gpu_info.amd_switchable = false;
 578     features = control_list->MakeDecision(
 579         GpuControlList::kOsWin, kOsVersion, gpu_info);
 580     EXPECT_EMPTY_SET(features);
 581   }
 582 }
 583
 584 TEST_F(GpuControlListTest, DisabledExtensionTest) {
 585   // exact setting.
 586   const std::string exact_list_json = LONG_STRING_CONST(
 587       {
 588         "name": "gpu control list",
 589         "version": "0.1",
 590         "entries": [
 591           {
 592             "id": 1,
 593             "os": {
 594               "type": "win"
 595             },
 596             "disabled_extensions": [
 597               "test_extension2",
 598               "test_extension1"
 599             ]
 600           },
 601           {
 602             "id": 2,
 603               "os": {
 604                 "type": "win"
 605               },
 606             "disabled_extensions": [
 607               "test_extension3",
 608               "test_extension2"
 609             ]
 610           }
 611         ]
 612       }
 613   );
 614   scoped_ptr<GpuControlList> control_list(Create());
 615
 616   EXPECT_TRUE(control_list->LoadList(exact_list_json, GpuControlList::kAllOs));
 617   GPUInfo gpu_info;
 618   control_list->MakeDecision(GpuControlList::kOsWin, kOsVersion, gpu_info);
 619
 620   std::vector<std::string> disabled_extensions =
 621       control_list->GetDisabledExtensions();
 622
 623   ASSERT_EQ(3u, disabled_extensions.size());
 624   ASSERT_STREQ("test_extension1", disabled_extensions[0].c_str());
 625   ASSERT_STREQ("test_extension2", disabled_extensions[1].c_str());
 626   ASSERT_STREQ("test_extension3", disabled_extensions[2].c_str());
 627 }
 628
 629 }  // namespace gpu