OLD | NEW |
---|---|
(Empty) | |
1 #!/usr/bin/env python | |
2 # Copyright 2017 The Chromium Authors. All rights reserved. | |
3 # Use of this source code is governed by a BSD-style license that can be | |
4 # found in the LICENSE file. | |
5 | |
6 import json | |
7 import os | |
8 import platform | |
9 import sys | |
10 from subprocess import call | |
11 | |
12 """Generate data struct from GPU blacklist and driver bug workarounds json.""" | |
13 | |
14 _LICENSE = """// Copyright 2017 The Chromium Authors. All rights reserved. | |
15 // Use of this source code is governed by a BSD-style license that can be | |
16 // found in the LICENSE file. | |
17 | |
18 """ | |
19 | |
20 _DO_NOT_EDIT_WARNING = """// This file is auto-generated from | |
21 // gpu/config/process_json.py | |
22 // It's formatted by clang-format using chromium coding style: | |
23 // clang-format -i -style=chromium filename | |
24 // DO NOT EDIT! | |
25 | |
26 """ | |
27 | |
28 | |
29 def load_software_rendering_list_features(feature_type_filename): | |
30 header_file = open(feature_type_filename, 'rb') | |
31 start = False | |
32 features = [] | |
33 for line in header_file: | |
34 if line.startswith('enum GpuFeatureType {'): | |
35 assert not start | |
36 start = True | |
37 continue | |
38 if not start: | |
39 continue | |
40 line = line.strip() | |
41 line = line.split(' ', 1)[0] | |
42 line = line.split(',', 1)[0] | |
43 if line.startswith('NUMBER_OF_GPU_FEATURE_TYPES'): | |
44 assert start | |
45 start = False | |
46 break | |
47 elif line.startswith('GPU_FEATURE_TYPE_'): | |
48 name = line[len('GPU_FEATURE_TYPE_'):] | |
49 features.append(name.lower()) | |
50 else: | |
51 assert False | |
52 assert not start | |
53 assert len(features) > 0 | |
54 header_file.close() | |
55 return features | |
56 | |
57 | |
58 def load_gpu_driver_bug_workarounds(workaround_type_filename): | |
59 header_file = open(workaround_type_filename, 'rb') | |
60 start = False | |
61 workaround = None | |
62 workarounds = [] | |
63 for line in header_file: | |
64 if line.startswith('#define GPU_DRIVER_BUG_WORKAROUNDS(GPU_OP)'): | |
65 assert not start | |
66 start = True | |
67 continue | |
68 if not start: | |
69 continue | |
70 line = line.strip() | |
71 if line.startswith('GPU_OP('): | |
72 assert not workaround | |
73 workaround = line[len('GPU_OP('):] | |
74 workaround = workaround.split(',', 1)[0].lower() | |
75 continue | |
76 if workaround: | |
77 line = line.split(')', 1)[0] | |
78 assert line == workaround | |
79 workarounds.append(line) | |
80 workaround = None | |
81 continue | |
82 start = False | |
83 break | |
84 assert not start | |
85 assert len(workarounds) > 0 | |
86 header_file.close() | |
87 return workarounds | |
88 | |
89 | |
90 def get_feature_set(features, total_feature_set): | |
91 assert len(features) > 0 | |
92 feature_set = set([]) | |
93 for feature in features: | |
94 if feature == 'all': | |
95 feature_set = set(total_feature_set) | |
96 elif isinstance(feature, dict): | |
97 for key in feature: | |
98 if key == 'exceptions': | |
99 for exception in feature['exceptions']: | |
100 assert exception in feature_set | |
101 feature_set.remove(exception) | |
102 else: | |
103 raise KeyException('only exceptions are allowed') | |
104 else: | |
105 assert feature in total_feature_set | |
106 feature_set.add(feature) | |
107 return feature_set | |
108 | |
109 | |
110 def write_features(entry_id, feature_set, feature_name_prefix, | |
111 data_helper_file): | |
112 data_helper_file.write('const int kFeatureListForEntry%d[%d] = {\n' % | |
113 (entry_id, len(feature_set))) | |
114 for feature in feature_set: | |
115 data_helper_file.write(feature_name_prefix + feature.upper()) | |
116 data_helper_file.write(',\n') | |
117 data_helper_file.write('};\n\n') | |
118 | |
119 | |
120 def write_string_list(entry_id, is_exception, exception_id, name_tag, data, | |
Ken Russell (switch to Gerrit)
2017/03/31 02:37:06
nit: this doesn't seem to be called with anything
Zhenyao Mo
2017/03/31 19:14:14
Done.
| |
121 data_file, data_helper_file): | |
122 if data: | |
123 var_name = 'k' + name_tag + 'ForEntry' + str(entry_id) | |
124 if is_exception: | |
125 var_name += 'Exception' + str(exception_id) | |
126 # define the list | |
127 data_helper_file.write('const char* %s[%d] = {\n' % (var_name, len(data))) | |
128 for item in data: | |
129 write_string(item, data_helper_file) | |
130 data_helper_file.write(',\n') | |
131 data_helper_file.write('};\n\n') | |
132 # use the list | |
133 data_file.write('arraysize(%s), // %s size\n' % (var_name, name_tag)) | |
134 data_file.write('%s, // %s\n' % (var_name, name_tag)) | |
135 else: | |
136 data_file.write('0, // %s size\n' % name_tag) | |
137 data_file.write('nullptr, // %s\n' % name_tag) | |
138 | |
139 | |
140 def write_gl_strings(entry_id, is_exception, exception_id, data, | |
141 data_file, data_helper_file): | |
142 if data: | |
143 var_name = 'kGLStringsForEntry' + str(entry_id) | |
144 if is_exception: | |
145 var_name += 'Exception' + str(exception_id) | |
146 # define the GL strings | |
147 data_helper_file.write('const GpuControlList::GLStrings %s = {\n' % | |
148 var_name) | |
149 for item in data: | |
150 write_string(item, data_helper_file) | |
151 data_helper_file.write(',\n') | |
152 data_helper_file.write('};\n\n') | |
153 # reference the GL strings | |
154 data_file.write('&%s, // GL strings\n' % var_name) | |
155 else: | |
156 data_file.write('nullptr, // GL strings\n') | |
157 | |
158 | |
159 def write_version(version_info, name_tag, data_file): | |
160 op = '' | |
161 style = '' | |
162 version1 = '' | |
163 version2 = '' | |
164 if version_info: | |
165 op = version_info['op'] | |
166 if 'style' in version_info: | |
167 style = version_info['style'] | |
168 version1 = version_info['value'] | |
169 if 'value2' in version_info: | |
170 version2 = version_info['value2'] | |
171 data_file.write('{') | |
172 op_map = { | |
173 '=': 'kEQ', | |
174 '<': 'kLT', | |
175 '<=': 'kLE', | |
176 '>': 'kGT', | |
177 '>=': 'kGE', | |
178 'any': 'kAny', | |
179 'between': 'kBetween', | |
180 '': 'kUnknown', | |
181 } | |
182 assert op_map.has_key(op) | |
183 data_file.write('GpuControlList::%s, ' % op_map[op]) | |
184 style_map = { | |
185 'lexical': 'Lexical', | |
186 'numerical': 'Numerical', | |
187 '': 'Numerical', | |
188 } | |
189 assert style_map.has_key(style) | |
190 data_file.write('GpuControlList::kVersionStyle%s, ' % style_map[style]) | |
191 write_string(version1, data_file) | |
192 data_file.write(', ') | |
193 write_string(version2, data_file) | |
194 data_file.write('}, // %s\n' % name_tag) | |
195 | |
196 | |
197 def write_driver_info(entry_id, is_exception, exception_id, driver_vendor, | |
198 driver_version, driver_date, data_file, data_helper_file): | |
199 var_name = 'kDriverInfoForEntry' + str(entry_id) | |
200 if is_exception: | |
201 var_name += 'Exception' + str(exception_id) | |
202 # define the GL strings | |
203 data_helper_file.write('const GpuControlList::DriverInfo %s = {\n' % | |
204 var_name) | |
205 write_string_value(driver_vendor, 'driver_vendor', data_helper_file) | |
206 write_version(driver_version, 'driver_version', data_helper_file) | |
207 write_version(driver_date, 'driver_date', data_helper_file) | |
208 data_helper_file.write('};\n\n') | |
209 # reference the GL strings | |
210 data_file.write('&%s, // driver info\n' % var_name) | |
211 | |
212 | |
213 def write_number_list(entry_id, data_type, name_tag, data, is_exception, | |
214 exception_id, data_file, data_helper_file): | |
215 if data: | |
216 var_name = 'k' + name_tag + 'ForEntry' + str(entry_id) | |
217 if is_exception: | |
218 var_name += 'Exception' + str(exception_id) | |
219 # define the list | |
220 data_helper_file.write('const %s %s[%d] = {\n' % | |
221 (data_type, var_name, len(data))) | |
222 for item in data: | |
223 data_helper_file.write(str(item)) | |
224 data_helper_file.write(',\n') | |
225 data_helper_file.write('};\n\n') | |
226 # reference the list | |
227 data_file.write('arraysize(%s), // %s size\n' % (var_name, name_tag)) | |
228 data_file.write('%s, // %s\n' % (var_name, name_tag)) | |
229 else: | |
230 data_file.write('0, // %s size\n' % name_tag) | |
231 data_file.write('nullptr, // %s\n' % name_tag) | |
232 | |
233 | |
234 def write_string(string, data_file): | |
235 if string == '': | |
236 data_file.write('nullptr') | |
237 else: | |
238 data_file.write('"%s"' % string.replace('\\', '\\\\')) | |
239 | |
240 | |
241 def write_string_value(string, name_tag, data_file): | |
242 write_string(string, data_file) | |
243 data_file.write(', // %s\n' % name_tag) | |
244 | |
245 | |
246 def write_boolean_value(value, name_tag, data_file): | |
247 data_file.write('%s, // %s\n' % (str(value).lower(), name_tag)) | |
248 | |
249 | |
250 def write_machine_model_info(entry_id, is_exception, exception_id, | |
251 machine_model_name, machine_model_version, | |
252 data_file, data_helper_file): | |
253 model_name_var_name = None | |
254 if machine_model_name: | |
255 model_name_var_name = 'kMachineModelNameForEntry' + str(entry_id) | |
256 if is_exception: | |
257 model_name_var_name += 'Exception' + str(exception_id) | |
258 data_helper_file.write('const char* %s[%d] = {\n' % | |
259 (model_name_var_name, len(machine_model_name))) | |
260 for item in machine_model_name: | |
261 write_string(item, data_helper_file) | |
262 data_helper_file.write(',\n') | |
263 data_helper_file.write('};\n\n') | |
264 var_name = None | |
265 if machine_model_name or machine_model_version: | |
266 var_name = 'kMachineModelInfoForEntry' + str(entry_id) | |
267 if is_exception: | |
268 var_name += 'Exception' + str(exception_id) | |
269 # define machine model info | |
270 data_helper_file.write( | |
271 'const GpuControlList::MachineModelInfo %s = {\n' % var_name) | |
272 if machine_model_name: | |
273 data_helper_file.write('arraysize(%s), // machine model name size\n' % | |
274 model_name_var_name) | |
275 data_helper_file.write('%s, // machine model names\n' % | |
276 model_name_var_name) | |
277 else: | |
278 data_helper_file.write('0, // machine model name size\n') | |
279 data_helper_file.write('nullptr, // machine model names\n') | |
280 write_version(machine_model_version, 'machine model version', | |
281 data_helper_file) | |
282 data_helper_file.write('};\n\n') | |
283 # reference the machine model info | |
284 data_file.write('&%s, // machine model info\n' % var_name) | |
285 else: | |
286 data_file.write('nullptr, // machine model info\n') | |
287 | |
288 | |
289 def write_os_type(os_type, data_file): | |
290 map = { | |
291 'win': 'kOsWin', | |
292 'macosx': 'kOsMacosx', | |
293 'android': 'kOsAndroid', | |
294 'linux': 'kOsLinux', | |
295 'chromeos': 'kOsChromeOS', | |
296 '': 'kOsAny', | |
297 } | |
298 assert map.has_key(os_type) | |
299 data_file.write('GpuControlList::%s, // os_type\n' % map[os_type]) | |
300 | |
301 | |
302 def write_multi_gpu_category(multi_gpu_category, data_file): | |
303 map = { | |
304 'primary': 'Primary', | |
305 'secondary': 'Secondary', | |
306 'active': 'Active', | |
307 'any': 'Any', | |
308 '': 'None', | |
309 } | |
310 assert map.has_key(multi_gpu_category) | |
311 data_file.write( | |
312 'GpuControlList::kMultiGpuCategory%s, // multi_gpu_category\n' % | |
313 map[multi_gpu_category]) | |
314 | |
315 | |
316 def write_multi_gpu_style(multi_gpu_style, data_file): | |
317 map = { | |
318 'optimus': 'Optimus', | |
319 'amd_switchable': 'AMDSwitchable', | |
320 'amd_switchable_discrete': 'AMDSwitchableDiscrete', | |
321 'amd_switchable_integrated': 'AMDSwitchableIntegrated', | |
322 '': 'None', | |
323 } | |
324 assert map.has_key(multi_gpu_style) | |
325 data_file.write( | |
326 'GpuControlList::kMultiGpuStyle%s, // multi_gpu_style\n' % | |
327 map[multi_gpu_style]) | |
328 | |
329 | |
330 def write_gl_type(gl_type, data_file): | |
331 map = { | |
332 'gl': 'GL', | |
333 'gles': 'GLES', | |
334 'angle': 'ANGLE', | |
335 '': 'None', | |
336 } | |
337 assert map.has_key(gl_type) | |
338 data_file.write('GpuControlList::kGLType%s, // gl_type\n' % map[gl_type]) | |
339 | |
340 | |
341 def write_conditions(entry_id, is_exception, exception_id, entry, | |
342 data_file, data_helper_file, data_exception_file): | |
343 os_type = '' | |
344 os_version = None | |
345 vendor_id = 0 | |
346 device_id = None | |
347 multi_gpu_category = '' | |
348 multi_gpu_style = '' | |
349 driver_vendor = '' | |
350 driver_version = None | |
351 driver_date = None | |
352 gl_renderer = '' | |
353 gl_vendor = '' | |
354 gl_extensions = '' | |
355 gl_version_string = '' | |
356 gl_type = '' | |
357 gl_version = None | |
358 pixel_shader_version = None | |
359 in_process_gpu = False | |
360 gl_reset_notification_strategy = None | |
361 direct_rendering = True | |
362 gpu_count = None | |
363 machine_model_name = None | |
364 machine_model_version = None | |
365 exception_count = 0 | |
366 exception_var = 'nullptr' | |
367 # process the entry | |
368 for key in entry: | |
369 if key == 'id': | |
370 assert not is_exception | |
371 assert entry['id'] == entry_id | |
372 continue | |
373 elif key == 'description': | |
374 assert not is_exception | |
375 continue | |
376 elif key == 'features': | |
377 assert not is_exception | |
378 continue | |
379 elif key == 'disabled_extensions': | |
380 assert not is_exception | |
381 continue | |
382 elif key == 'comment': | |
383 continue | |
384 elif key == 'webkit_bugs': | |
385 assert not is_exception | |
386 continue | |
387 elif key == 'cr_bugs': | |
388 assert not is_exception | |
389 continue | |
390 elif key == 'os': | |
391 os_info = entry[key] | |
392 os_type = os_info['type'] | |
393 if 'version' in os_info: | |
394 os_version = os_info['version'] | |
395 elif key == 'vendor_id': | |
396 vendor_id = int(entry[key], 0) | |
397 elif key == 'device_id': | |
398 device_id = entry[key] | |
399 elif key == 'multi_gpu_category': | |
400 multi_gpu_category = entry[key] | |
401 elif key == 'multi_gpu_style': | |
402 multi_gpu_style = entry[key] | |
403 elif key == 'driver_vendor': | |
404 driver_vendor = entry[key] | |
405 elif key == 'driver_version': | |
406 driver_version = entry[key] | |
407 elif key == 'driver_date': | |
408 driver_date = entry[key] | |
409 elif key == 'gl_vendor': | |
410 gl_vendor = entry[key] | |
411 elif key == 'gl_renderer': | |
412 gl_renderer = entry[key] | |
413 elif key == 'gl_version_string': | |
414 gl_version_string = entry[key] | |
415 elif key == 'gl_type': | |
416 gl_type = entry[key] | |
417 elif key == 'gl_version': | |
418 gl_version = entry[key] | |
419 elif key == 'gl_extensions': | |
420 gl_extensions = entry[key] | |
421 elif key == 'pixel_shader_version': | |
422 pixel_shader_version = entry[key] | |
423 elif key == 'in_process_gpu': | |
424 assert entry[key] | |
425 in_process_gpu = True | |
426 elif key == 'gl_reset_notification_strategy': | |
427 gl_reset_notification_strategy = entry[key] | |
428 elif key == 'direct_rendering': | |
429 assert not entry[key] | |
430 direct_rendering = False | |
431 elif key == 'gpu_count': | |
432 gpu_count = entry[key] | |
433 elif key == 'machine_model_name': | |
434 machine_model_name = entry[key] | |
435 elif key == 'machine_model_version': | |
436 machine_model_version = entry[key] | |
437 elif key == 'exceptions': | |
438 assert not is_exception | |
439 assert exception_count == 0 | |
440 else: | |
441 raise ValueError('unknown key: ' + key + ' in entry ' + str(entry)) | |
442 # write out the entry | |
443 write_os_type(os_type, data_file) | |
444 write_version(os_version, 'os_version', data_file) | |
445 data_file.write(format(vendor_id, '#04x')) | |
446 data_file.write(', // vendor_id\n') | |
447 write_number_list(entry_id, 'uint32_t', 'DeviceIDs', device_id, is_exception, | |
448 exception_id, data_file, data_helper_file) | |
449 write_multi_gpu_category(multi_gpu_category, data_file) | |
450 write_multi_gpu_style(multi_gpu_style, data_file) | |
451 # group driver info | |
452 if driver_vendor != '' or driver_version != None or driver_date != None: | |
453 write_driver_info(entry_id, is_exception, exception_id, driver_vendor, | |
454 driver_version, driver_date, data_file, data_helper_file) | |
455 else: | |
456 data_file.write('nullptr, // driver info\n') | |
457 # group GL strings | |
458 gl_strings = None | |
459 if (gl_vendor != '' or gl_renderer != '' or gl_extensions != '' or | |
460 gl_version_string != ''): | |
461 gl_strings = [gl_vendor, gl_renderer, gl_extensions, gl_version_string] | |
462 write_gl_strings(entry_id, is_exception, exception_id, gl_strings, | |
463 data_file, data_helper_file) | |
464 # group machine model info | |
465 write_machine_model_info(entry_id, is_exception, exception_id, | |
466 machine_model_name, machine_model_version, | |
467 data_file, data_helper_file) | |
468 # group a bunch of less used conditions | |
469 if (gl_version != None or pixel_shader_version != None or in_process_gpu or | |
470 gl_reset_notification_strategy != None or (not direct_rendering) or | |
471 gpu_count != None): | |
472 write_entry_more_data(entry_id, is_exception, exception_id, gl_type, | |
473 gl_version, pixel_shader_version, in_process_gpu, | |
474 gl_reset_notification_strategy, direct_rendering, | |
475 gpu_count, data_file, data_helper_file) | |
476 else: | |
477 data_file.write('nullptr, // more conditions\n') | |
478 | |
479 | |
480 def write_entry_more_data(entry_id, is_exception, exception_id, gl_type, | |
481 gl_version, pixel_shader_version, in_process_gpu, | |
482 gl_reset_notification_strategy, direct_rendering, | |
483 gpu_count, data_file, data_helper_file): | |
484 # write more data | |
485 var_name = 'kMoreForEntry' + str(entry_id) | |
486 if is_exception: | |
487 var_name += 'Exception' + str(exception_id) | |
488 data_helper_file.write('const GpuControlList::More %s = {\n' % var_name) | |
489 write_gl_type(gl_type, data_helper_file) | |
490 write_version(gl_version, 'gl_version', data_helper_file) | |
491 write_version(pixel_shader_version, 'pixel_shader_version', data_helper_file) | |
492 write_boolean_value(in_process_gpu, 'in_process_gpu', data_helper_file) | |
493 if not gl_reset_notification_strategy: | |
494 gl_reset_notification_strategy = '0' | |
495 data_helper_file.write('%s, // gl_reset_notification_strategy\n' % | |
496 gl_reset_notification_strategy) | |
497 write_boolean_value(direct_rendering, 'direct_rendering', data_helper_file) | |
498 write_version(gpu_count, 'gpu_count', data_helper_file) | |
499 data_helper_file.write('};\n\n') | |
500 # reference more data in entry | |
501 data_file.write('&%s, // more data\n' % var_name) | |
502 | |
503 | |
504 def write_entry(entry, total_feature_set, feature_name_prefix, | |
505 data_file, data_helper_file, data_exception_file): | |
506 data_file.write('{\n') | |
507 # ID | |
508 entry_id = entry['id'] | |
509 data_file.write('%d, // id\n' % entry_id) | |
510 data_file.write('"%s",\n' % entry['description']); | |
511 # Features | |
512 if 'features' in entry: | |
513 features = entry['features'] | |
514 feature_set = get_feature_set(features, total_feature_set) | |
515 data_file.write('arraysize(kFeatureListForEntry%d), // features size\n' % | |
516 entry_id) | |
517 data_file.write('kFeatureListForEntry%d, // features\n' % entry_id) | |
518 write_features(entry_id, feature_set, feature_name_prefix, data_helper_file) | |
519 else: | |
520 data_file.write('0, // feature size\n') | |
521 data_file.write('nullptr, // features\n') | |
522 # Disabled extensions | |
523 disabled_extensions = None | |
524 if 'disabled_extensions' in entry: | |
525 disabled_extensions = entry['disabled_extensions'] | |
526 write_string_list(entry_id, False, -1, 'DisabledExtensions', | |
527 disabled_extensions, data_file, data_helper_file) | |
528 # webkit_bugs are skipped because there is only one entry that has it. | |
529 # cr_bugs | |
530 cr_bugs = None | |
531 if 'cr_bugs' in entry: | |
532 cr_bugs = entry['cr_bugs'] | |
533 write_number_list(entry_id, 'uint32_t', 'CrBugs', cr_bugs, False, -1, | |
534 data_file, data_helper_file) | |
535 # Conditions | |
536 data_file.write('{\n') | |
537 write_conditions(entry_id, False, -1, entry, data_file, data_helper_file, | |
538 data_exception_file) | |
539 data_file.write('},\n') | |
540 # Exceptions | |
541 if 'exceptions' in entry: | |
542 exceptions = entry['exceptions'] | |
543 exception_count = len(exceptions) | |
544 exception_var = 'kExceptionsForEntry' + str(entry_id) | |
545 data_exception_file.write('const GpuControlList::Conditions %s[%d] = {\n' % | |
546 (exception_var, exception_count)) | |
547 for index in range(exception_count): | |
548 exception = exceptions[index] | |
549 if 'device_id' in exception and 'vendor_id' not in exception: | |
550 assert 'vendor_id' in entry | |
551 exception['vendor_id'] = entry['vendor_id'] | |
552 data_exception_file.write('{\n') | |
553 write_conditions(entry_id, True, index, exception, | |
554 data_exception_file, data_helper_file, None) | |
555 data_exception_file.write('},\n') | |
556 data_exception_file.write('};\n\n') | |
557 data_file.write('arraysize(%s), // exceptions count\n' % exception_var) | |
558 data_file.write('%s, // exceptions\n' % exception_var) | |
559 else: | |
560 data_file.write('0, // exceptions count\n') | |
561 data_file.write('nullptr, // exceptions\n') | |
562 # END | |
563 data_file.write('},\n') | |
564 | |
565 | |
566 def format_files(generated_files): | |
567 formatter = "clang-format" | |
568 if platform.system() == "Windows": | |
569 formatter += ".bat" | |
570 for filename in generated_files: | |
571 call([formatter, "-i", "-style=chromium", filename]) | |
572 | |
573 | |
574 def write_header_file_guard(file, filename, path, begin): | |
575 token = (path.upper().replace('/', '_') + '_' + | |
576 filename.upper().replace('.', '_') + '_') | |
577 if begin: | |
578 file.write('#ifndef %s\n#define %s\n\n' % (token, token)) | |
579 else: | |
580 file.write('\n#endif // %s\n' % token) | |
581 | |
582 | |
583 def process_json_file(json_filename, list_tag, | |
584 feature_header_filename, total_features, feature_tag, | |
585 output_header_filename, output_data_filename, | |
586 output_helper_filename, output_exception_filename, path, | |
587 export_tag): | |
588 current_dir = os.getcwd() | |
589 os.chdir('../../' + path) # assume python script is under gou/config | |
Ken Russell (switch to Gerrit)
2017/03/31 02:37:06
typo here and throughout: gou -> gpu
Also, I was
Zhenyao Mo
2017/03/31 19:14:14
Done
| |
590 | |
591 json_file = open(json_filename, 'rb') | |
592 json_data = json.load(json_file) | |
593 json_file.close() | |
594 data_file = open(output_data_filename, 'wb') | |
595 data_file.write(_LICENSE) | |
596 data_file.write(_DO_NOT_EDIT_WARNING) | |
597 data_file.write('#include "%s/%s"\n\n' % (path, output_header_filename)) | |
598 data_file.write('#include "%s/%s"\n' % (path, output_helper_filename)) | |
599 data_file.write('#include "%s/%s"\n\n' % (path, output_exception_filename)) | |
600 data_helper_file = open(output_helper_filename, 'wb') | |
601 data_helper_file.write(_LICENSE) | |
602 data_helper_file.write(_DO_NOT_EDIT_WARNING) | |
603 write_header_file_guard(data_helper_file, output_helper_filename, path, True) | |
604 data_helper_file.write('#include "gpu/config/%s"\n\n' % | |
605 feature_header_filename) | |
606 data_helper_file.write('namespace gpu {\n') | |
607 data_exception_file = open(output_exception_filename, 'wb') | |
608 data_exception_file.write(_LICENSE) | |
609 data_exception_file.write(_DO_NOT_EDIT_WARNING) | |
610 write_header_file_guard(data_exception_file, output_exception_filename, path, | |
611 True) | |
612 data_exception_file.write('namespace gpu {\n') | |
613 data_file.write('namespace gpu {\n\n') | |
614 data_file.write('const char k%sVersion[] = "%s";\n\n' % | |
615 (list_tag, json_data['version'])) | |
616 entry_count = len(json_data['entries']) | |
617 data_file.write('const size_t k%sEntryCount = %d;\n' % | |
618 (list_tag, entry_count)) | |
619 data_file.write('const GpuControlList::Entry k%sEntries[%d] = {\n' % | |
620 (list_tag, entry_count)) | |
621 ids = [] | |
622 for index in range(entry_count): | |
623 entry = json_data['entries'][index] | |
624 entry_id = entry['id'] | |
625 assert entry_id not in ids | |
626 ids.append(entry_id) | |
627 write_entry(entry, total_features, feature_tag, | |
628 data_file, data_helper_file, data_exception_file) | |
629 data_file.write('};\n') | |
630 data_file.write('} // namespace gpu\n') | |
631 data_file.close() | |
632 data_helper_file.write('} // namespace gpu\n') | |
633 write_header_file_guard(data_helper_file, output_helper_filename, path, False) | |
634 data_helper_file.close() | |
635 data_exception_file.write('} // namespace gpu\n') | |
636 write_header_file_guard(data_exception_file, output_exception_filename, path, | |
637 False) | |
638 data_exception_file.close() | |
639 data_header_file = open(output_header_filename, 'wb') | |
640 data_header_file.write(_LICENSE) | |
641 data_header_file.write(_DO_NOT_EDIT_WARNING) | |
642 write_header_file_guard(data_header_file, output_header_filename, path, True) | |
643 if export_tag == 'CONTENT_EXPORT ': | |
644 data_header_file.write('#include "content/common/content_export.h"\n') | |
645 data_header_file.write('#include "gpu/config/gpu_control_list.h"\n\n') | |
646 data_header_file.write('\n') | |
647 data_header_file.write('namespace gpu {\n') | |
648 data_header_file.write('%sextern const char k%sVersion[];\n' % | |
649 (export_tag, list_tag)) | |
650 data_header_file.write('%sextern const size_t k%sEntryCount;\n' % | |
651 (export_tag, list_tag)) | |
652 data_header_file.write( | |
653 '%sextern const GpuControlList::Entry k%sEntries[];\n' % | |
654 (export_tag, list_tag)) | |
655 data_header_file.write('} // namespace gpu\n') | |
656 write_header_file_guard(data_header_file, output_header_filename, path, False) | |
657 data_header_file.close() | |
658 format_files([output_header_filename, output_data_filename, | |
659 output_helper_filename, output_exception_filename]) | |
660 | |
661 os.chdir(current_dir) | |
662 | |
663 | |
664 def process_software_rendering_list(): | |
665 total_features = load_software_rendering_list_features('gpu_feature_type.h') | |
666 process_json_file('software_rendering_list.json', 'SoftwareRenderingList', | |
667 'gpu_feature_type.h', total_features, 'GPU_FEATURE_TYPE_', | |
668 'software_rendering_list_autogen.h', | |
669 'software_rendering_list_autogen.cc', | |
670 'software_rendering_list_arrays_and_structs_autogen.h', | |
671 'software_rendering_list_exceptions_autogen.h', | |
672 'gpu/config', 'GPU_EXPORT ') | |
673 | |
674 | |
675 def process_gpu_driver_bug_list(): | |
676 total_features = load_gpu_driver_bug_workarounds( | |
677 'gpu_driver_bug_workaround_type.h') | |
678 process_json_file('gpu_driver_bug_list.json', 'GpuDriverBugList', | |
679 'gpu_driver_bug_workaround_type.h', total_features, '', | |
680 'gpu_driver_bug_list_autogen.h', | |
681 'gpu_driver_bug_list_autogen.cc', | |
682 'gpu_driver_bug_list_arrays_and_structs_autogen.h', | |
683 'gpu_driver_bug_list_exceptions_autogen.h', | |
684 'gpu/config', 'GPU_EXPORT ') | |
685 | |
686 | |
687 def process_gpu_control_list_testing(): | |
688 total_features = ['test_feature_0', 'test_feature_1', 'test_feature_2'] | |
689 process_json_file('gpu_control_list_testing.json', 'GpuControlListTesting', | |
690 'gpu_control_list_testing_data.h', total_features, '', | |
691 'gpu_control_list_testing_autogen.h', | |
692 'gpu_control_list_testing_autogen.cc', | |
693 'gpu_control_list_testing_arrays_and_structs_autogen.h', | |
694 'gpu_control_list_testing_exceptions_autogen.h', | |
695 'gpu/config', '') | |
696 | |
697 | |
698 def process_gpu_data_manager_testing(): | |
699 total_features = load_software_rendering_list_features('gpu_feature_type.h') | |
700 process_json_file('gpu_data_manager_testing.json', 'GpuDataManagerTesting', | |
701 'gpu_feature_type.h', total_features, 'GPU_FEATURE_TYPE_', | |
702 'gpu_data_manager_testing_autogen.h', | |
703 'gpu_data_manager_testing_autogen.cc', | |
704 'gpu_data_manager_testing_arrays_and_structs_autogen.h', | |
705 'gpu_data_manager_testing_exceptions_autogen.h', | |
706 'content/browser/gpu', '') | |
707 | |
708 | |
709 def write_test_entry_enums(input_json_filename, output_entry_enums_filename, | |
710 path, list_tag): | |
711 current_dir = os.getcwd() | |
712 os.chdir('../../' + path) # assume python script is under gou/config | |
713 | |
714 json_file = open(input_json_filename, 'rb') | |
715 json_data = json.load(json_file) | |
716 json_file.close() | |
717 | |
718 enum_file = open(output_entry_enums_filename, 'wb') | |
719 enum_file.write(_LICENSE) | |
720 enum_file.write(_DO_NOT_EDIT_WARNING) | |
721 write_header_file_guard(enum_file, output_entry_enums_filename, path, True) | |
722 enum_file.write('namespace gpu {\n') | |
723 enum_file.write('enum %sEntryEnum {\n' % list_tag) | |
724 entry_count = len(json_data['entries']) | |
725 for index in range(entry_count): | |
726 entry = json_data['entries'][index] | |
727 entry_id = entry['id'] | |
728 description = entry['description'] | |
729 assert(index + 1 == int(entry_id)) | |
730 description = 'k' + description | |
731 description = description.replace('.', '_') | |
732 enum_file.write(' %s = %d,\n' % (description, index)) | |
733 enum_file.write('};\n') | |
734 enum_file.write('} // namespace gpu\n') | |
735 write_header_file_guard(enum_file, output_entry_enums_filename, path, False) | |
736 enum_file.close() | |
737 format_files([output_entry_enums_filename]) | |
738 | |
739 os.chdir(current_dir) | |
740 | |
741 | |
742 def main(): | |
743 dir_path = os.path.dirname(os.path.realpath(__file__)) | |
744 os.chdir(dir_path) | |
745 process_software_rendering_list() | |
746 process_gpu_driver_bug_list() | |
747 process_gpu_control_list_testing() | |
748 write_test_entry_enums('gpu_control_list_testing.json', | |
749 'gpu_control_list_testing_entry_enums_autogen.h', | |
750 'gpu/config', | |
751 'GpuControlListTesting') | |
752 process_gpu_data_manager_testing() | |
753 write_test_entry_enums('gpu_data_manager_testing.json', | |
754 'gpu_data_manager_testing_entry_enums_autogen.h', | |
755 'content/browser/gpu', | |
756 'GpuDataManagerTesting') | |
757 | |
758 | |
759 if __name__ == '__main__': | |
760 sys.exit(main()) | |
OLD | NEW |