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