1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
|
// Copyright 2013 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "gpu/config/gpu_driver_bug_list.h"
#include "base/check_op.h"
#include "gpu/config/gpu_driver_bug_list_autogen.h"
#include "gpu/config/gpu_driver_bug_workaround_type.h"
#include "gpu/config/gpu_switches.h"
#include "gpu/config/gpu_util.h"
namespace gpu {
namespace {
struct GpuDriverBugWorkaroundInfo {
GpuDriverBugWorkaroundType type;
const char* name;
};
const std::array<GpuDriverBugWorkaroundInfo,
NUMBER_OF_GPU_DRIVER_BUG_WORKAROUND_TYPES>
kFeatureList = {{
#define GPU_OP(type, name) { type, #name },
GPU_DRIVER_BUG_WORKAROUNDS(GPU_OP)
#undef GPU_OP
}};
} // namespace anonymous
GpuDriverBugList::GpuDriverBugList(base::span<const GpuControlList::Entry> data)
: GpuControlList(data) {}
GpuDriverBugList::~GpuDriverBugList() = default;
// static
std::unique_ptr<GpuDriverBugList> GpuDriverBugList::Create() {
return Create(GetGpuDriverBugListEntries());
}
// static
std::unique_ptr<GpuDriverBugList> GpuDriverBugList::Create(
base::span<const GpuControlList::Entry> data) {
std::unique_ptr<GpuDriverBugList> list(new GpuDriverBugList(data));
DCHECK_EQ(NUMBER_OF_GPU_DRIVER_BUG_WORKAROUND_TYPES, kFeatureList.size());
for (const auto& feature : kFeatureList) {
list->AddSupportedFeature(feature.name, feature.type);
}
return list;
}
std::string GpuDriverBugWorkaroundTypeToString(
GpuDriverBugWorkaroundType type) {
if (type < NUMBER_OF_GPU_DRIVER_BUG_WORKAROUND_TYPES)
return kFeatureList[type].name;
else
return "unknown";
}
// static
void GpuDriverBugList::AppendWorkaroundsFromCommandLine(
std::set<int>* workarounds,
const base::CommandLine& command_line) {
DCHECK(workarounds);
for (const auto& feature : kFeatureList) {
if (command_line.HasSwitch(feature.name)) {
// Check for disabling workaround flag.
if (command_line.GetSwitchValueASCII(feature.name) == "0") {
workarounds->erase(feature.type);
continue;
}
// Removing conflicting workarounds.
switch (feature.type) {
case FORCE_HIGH_PERFORMANCE_GPU:
workarounds->erase(FORCE_LOW_POWER_GPU);
workarounds->insert(FORCE_HIGH_PERFORMANCE_GPU);
break;
case FORCE_LOW_POWER_GPU:
workarounds->erase(FORCE_HIGH_PERFORMANCE_GPU);
workarounds->insert(FORCE_LOW_POWER_GPU);
break;
default:
workarounds->insert(feature.type);
break;
}
}
}
}
// static
void GpuDriverBugList::AppendAllWorkarounds(
std::vector<const char*>* workarounds) {
DCHECK_EQ(NUMBER_OF_GPU_DRIVER_BUG_WORKAROUND_TYPES, kFeatureList.size());
DCHECK(workarounds->empty());
workarounds->resize(NUMBER_OF_GPU_DRIVER_BUG_WORKAROUND_TYPES);
size_t i = 0;
for (const auto& feature : kFeatureList) {
(*workarounds)[i++] = feature.name;
}
}
// static
bool GpuDriverBugList::AreEntryIndicesValid(
const std::vector<uint32_t>& entry_indices) {
return GpuControlList::AreEntryIndicesValid(
entry_indices, GetGpuDriverBugListEntries().size());
}
} // namespace gpu
|
