Blame - glave-generate.py - platform/external/vulkan-validation-layers

2014-12-16 18:37:04 -0700

[diff] [blame]

290

def _generate_init_funcs(self):

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

291

init_tracer = []

Jon Ashburn

2014-12-16 18:37:04 -0700

[diff] [blame]

292

init_tracer.append('void send_xgl_api_version_packet()\n{')

293

init_tracer.append(' struct_xglApiVersion* pPacket;')

294

init_tracer.append(' glv_trace_packet_header* pHeader;')

295

init_tracer.append(' pHeader = glv_create_trace_packet(GLV_TID_XGL, GLV_TPI_XGL_xglApiVersion, sizeof(struct_xglApiVersion), 0);')

296

init_tracer.append(' pPacket = interpret_body_as_xglApiVersion(pHeader, FALSE);')

297

init_tracer.append(' pPacket->version = XGL_API_VERSION;')

298

init_tracer.append(' FINISH_TRACE_PACKET();\n}\n')

299

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

300

init_tracer.append('void InitTracer()\n{')

Jon Ashburn

0fed675

2015-01-09 17:36:10 -0700

[diff] [blame]

301

init_tracer.append('char *ipAddr = glv_get_global_var("GLVLIB_TRACE_IPADDR");')

302

init_tracer.append('if (ipAddr == NULL)')

303

init_tracer.append(' ipAddr = "127.0.0.1";')

304

init_tracer.append(' gMessageStream = glv_MessageStream_create(FALSE, ipAddr, GLV_BASE_PORT + GLV_TID_XGL);')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

305

init_tracer.append(' glv_trace_set_trace_file(glv_FileLike_create_msg(gMessageStream));')

306

init_tracer.append('// glv_tracelog_set_log_file(glv_FileLike_create_file(fopen("glv_log_traceside.txt","w")));')

Jon Ashburn

2014-12-16 18:37:04 -0700

[diff] [blame]

307

init_tracer.append(' glv_tracelog_set_tracer_id(GLV_TID_XGL);')

308

init_tracer.append(' send_xgl_api_version_packet();\n}\n')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

309

return "\n".join(init_tracer)

310

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

311

def _gen_unmap_memory(self):

312

um_body = []

313

um_body.append('GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglUnmapMemory(')

314

um_body.append(' XGL_GPU_MEMORY mem)')

315

um_body.append('{')

316

um_body.append(' glv_trace_packet_header* pHeader;')

317

um_body.append(' XGL_RESULT result;')

318

um_body.append(' struct_xglUnmapMemory* pPacket;')

319

um_body.append(' XGLAllocInfo *entry;')

320

um_body.append(' SEND_ENTRYPOINT_PARAMS("xglUnmapMemory(mem %p)\\n", mem);')

321

um_body.append(' // insert into packet the data that was written by CPU between the xglMapMemory call and here')

322

um_body.append(' // Note must do this prior to the real xglUnMap() or else may get a FAULT')

323

um_body.append(' entry = find_mem_info_entry(mem);')

324

um_body.append(' CREATE_TRACE_PACKET(xglUnmapMemory, (entry) ? entry->size : 0);')

325

um_body.append(' pPacket = interpret_body_as_xglUnmapMemory(pHeader);')

326

um_body.append(' if (entry)')

327

um_body.append(' {')

328

um_body.append(' assert(entry->handle == mem);')

329

um_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**) &(pPacket->pData), entry->size, entry->pData);')

330

um_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pData));')

331

um_body.append(' entry->pData = NULL;')

332

um_body.append(' }')

333

um_body.append(' result = real_xglUnmapMemory(mem);')

334

um_body.append(' pPacket->mem = mem;')

335

um_body.append(' pPacket->result = result;')

336

um_body.append(' FINISH_TRACE_PACKET();')

337

um_body.append(' return result;')

338

um_body.append('}\n')

339

return "\n".join(um_body)

340

Tobin Ehlis

2015-02-05 11:29:45 -0700

[diff] [blame]

341

# Generate functions used to trace API calls and store the input and result data into a packet

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

342

def _generate_trace_funcs(self):

343

func_body = []

344

for proto in self.protos:

Tobin Ehlis

2015-01-15 17:53:54 -0700

[diff] [blame]

345

if 'UnmapMemory' == proto.name:

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

346

func_body.append(self._gen_unmap_memory())

347

elif 'Dbg' not in proto.name and 'Wsi' not in proto.name:

348

packet_update_txt = ''

349

return_txt = ''

350

packet_size = ''

351

in_data_size = False # flag when we need to capture local input size variable for in/out size

352

buff_ptr_indices = []

353

func_body.append('GLVTRACER_EXPORT %s XGLAPI __HOOKED_xgl%s(' % (proto.ret, proto.name))

354

for p in proto.params: # TODO : For all of the ptr types, check them for NULL and return 0 is NULL

355

if 'color' == p.name:

356

func_body.append(' %s %s[4],' % (p.ty.replace('[4]', ''), p.name))

357

else:

358

func_body.append(' %s %s,' % (p.ty, p.name))

359

if '*' in p.ty and 'pSysMem' != p.name and 'pReserved' != p.name:

360

if 'pData' == p.name:

361

if 'dataSize' == proto.params[proto.params.index(p)-1].name:

362

packet_size += 'dataSize + '

363

elif 'counterCount' == proto.params[proto.params.index(p)-1].name:

Tobin Ehlis

2015-01-15 17:53:54 -0700

[diff] [blame]

364

packet_size += 'sizeof(%s) + ' % p.ty.strip('*').replace('const ', '')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

365

else:

366

packet_size += '((pDataSize != NULL && pData != NULL) ? *pDataSize : 0) + '

Tobin Ehlis

2015-01-15 17:53:54 -0700

[diff] [blame]

367

elif '**' in p.ty and 'void' in p.ty:

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

368

packet_size += 'sizeof(void*) + '

Tobin Ehlis

2015-01-15 17:53:54 -0700

[diff] [blame]

369

elif 'void' in p.ty:

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

370

packet_size += 'sizeof(%s) + ' % p.name

Tobin Ehlis

2015-01-15 17:53:54 -0700

[diff] [blame]

371

elif 'char' in p.ty:

Chia-I Wu

2014-12-27 15:16:07 +0800

[diff] [blame]

372

packet_size += '((%s != NULL) ? strlen(%s) + 1 : 0) + ' % (p.name, p.name)

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

373

elif 'DEVICE_CREATE_INFO' in p.ty:

374

packet_size += 'calc_size_XGL_DEVICE_CREATE_INFO(pCreateInfo) + '

375

elif 'pDataSize' in p.name:

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

376

packet_size += '((pDataSize != NULL) ? sizeof(size_t) : 0) + '

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

377

in_data_size = True;

378

elif 'IMAGE_SUBRESOURCE' in p.ty and 'pSubresource' == p.name:

379

packet_size += '((pSubresource != NULL) ? sizeof(XGL_IMAGE_SUBRESOURCE) : 0) + '

380

else:

Tobin Ehlis

2015-01-15 17:53:54 -0700

[diff] [blame]

381

packet_size += 'sizeof(%s) + ' % p.ty.strip('*').replace('const ', '')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

382

buff_ptr_indices.append(proto.params.index(p))

383

else:

384

if 'color' == p.name:

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

385

packet_update_txt += ' memcpy((void*)pPacket->color, color, 4 * sizeof(uint32_t));\n'

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

386

else:

387

packet_update_txt += ' pPacket->%s = %s;\n' % (p.name, p.name)

388

if 'Count' in p.name and proto.params[-1].name != p.name and p.name not in ['queryCount', 'vertexCount', 'indexCount', 'startCounter'] and proto.name not in ['CmdLoadAtomicCounters', 'CmdSaveAtomicCounters']:

Tobin Ehlis

2015-01-15 17:53:54 -0700

[diff] [blame]

389

if '*' in p.ty:

390

packet_size += '*%s*' % p.name

391

else:

392

packet_size += '%s*' % p.name

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

393

if '' == packet_size:

394

packet_size = '0'

395

else:

396

packet_size = packet_size.strip(' + ')

397

func_body[-1] = func_body[-1].replace(',', ')')

398

func_body.append('{\n glv_trace_packet_header* pHeader;')

Tobin Ehlis

2015-01-15 17:53:54 -0700

[diff] [blame]

399

if 'void' not in proto.ret or '*' in proto.ret:

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

400

func_body.append(' %s result;' % proto.ret)

401

return_txt = 'result = '

402

if in_data_size:

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

403

func_body.append(' size_t dataSizeIn = (pDataSize == NULL) ? 0 : *pDataSize;')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

404

func_body.append(' struct_xgl%s* pPacket = NULL;' % proto.name)

Jon Ashburn

2015-02-02 12:39:24 -0700

[diff] [blame]

405

# TODO: handle xglGetXXX where pDataSize is not a valid input

406

# functions that have non-standard sequence of packet creation and calling real function

407

# NOTE: Anytime we call the function first, need to add custom code for correctly tracking API call time

408

if 'CreateInstance' == proto.name:

Tobin Ehlis

2015-02-03 14:41:26 -0700

[diff] [blame]

409

func_body.append(' uint64_t startTime;')

Jon Ashburn

2015-02-02 12:39:24 -0700

[diff] [blame]

410

func_body.append(' glv_platform_thread_once(&gInitOnce, InitTracer);')

411

func_body.append(' SEND_ENTRYPOINT_ID(xgl%s);' % proto.name)

412

func_body.append(' if (real_xglCreateInstance == xglCreateInstance)')

413

func_body.append(' {')

414

func_body.append(' glv_platform_get_next_lib_sym((void **) &real_xglCreateInstance,"xglCreateInstance");')

415

func_body.append(' }')

Tobin Ehlis

2015-02-03 14:41:26 -0700

[diff] [blame]

416

func_body.append(' startTime = glv_get_time();')

417

func_body.append(' %sreal_xgl%s;' % (return_txt, proto.c_call()))

Jon Ashburn

2015-02-02 12:39:24 -0700

[diff] [blame]

418

func_body.append(' CREATE_TRACE_PACKET(xgl%s, sizeof(XGL_INSTANCE) + calc_size_XGL_APPLICATION_INFO(pAppInfo) + ((pAllocCb == NULL) ? 0 :sizeof(XGL_ALLOC_CALLBACKS)));' % (proto.name))

Tobin Ehlis

2015-02-03 14:41:26 -0700

[diff] [blame]

419

func_body.append(' pHeader->entrypoint_begin_time = startTime;')

Jon Ashburn

2015-02-02 12:39:24 -0700

[diff] [blame]

420

func_body.append(' if (isHooked == FALSE) {')

421

func_body.append(' AttachHooks();')

422

func_body.append(' AttachHooks_xgldbg();')

423

func_body.append(' AttachHooks_xglwsix11ext();')

424

func_body.append(' }')

Jon Ashburn

2015-02-02 12:39:24 -0700

[diff] [blame]

425

elif 'EnumerateGpus' == proto.name:

426

func_body.append(' uint64_t startTime;')

427

func_body.append(' SEND_ENTRYPOINT_ID(xgl%s);' % proto.name)

428

func_body.append(' startTime = glv_get_time();')

429

func_body.append(' %sreal_xgl%s;' % (return_txt, proto.c_call()))

430

func_body.append(' CREATE_TRACE_PACKET(xglEnumerateGpus, sizeof(uint32_t) + ((pGpus && pGpuCount) ? *pGpuCount * sizeof(XGL_PHYSICAL_GPU) : 0));')

431

func_body.append(' pHeader->entrypoint_begin_time = startTime;')

432

elif 'EnumerateLayers' == proto.name:

433

func_body.append(' uint64_t startTime;')

434

func_body.append(' SEND_ENTRYPOINT_ID(xgl%s);' % proto.name)

435

func_body.append(' startTime = glv_get_time();')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

436

func_body.append(' %sreal_xgl%s;' % (return_txt, proto.c_call()))

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

437

func_body.append(' size_t totStringSize = 0;')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

438

func_body.append(' uint32_t i = 0;')

439

func_body.append(' for (i = 0; i < *pOutLayerCount; i++)')

Chia-I Wu

2014-12-27 15:16:07 +0800

[diff] [blame]

440

func_body.append(' totStringSize += (pOutLayers[i] != NULL) ? strlen(pOutLayers[i]) + 1: 0;')

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

441

func_body.append(' CREATE_TRACE_PACKET(xgl%s, totStringSize + sizeof(size_t));' % (proto.name))

Jon Ashburn

2015-02-02 12:39:24 -0700

[diff] [blame]

442

func_body.append(' pHeader->entrypoint_begin_time = startTime;')

Tobin Ehlis

2015-01-20 13:50:59 -0700

[diff] [blame]

443

elif 'AllocDescriptorSets' == proto.name:

Jon Ashburn

2015-02-02 12:39:24 -0700

[diff] [blame]

444

func_body.append(' uint64_t startTime;')

445

func_body.append(' SEND_ENTRYPOINT_ID(xgl%s);' % proto.name)

446

func_body.append(' startTime = glv_get_time();')

Tobin Ehlis

2015-01-20 13:50:59 -0700

[diff] [blame]

447

func_body.append(' %sreal_xgl%s;' % (return_txt, proto.c_call()))

448

func_body.append(' size_t customSize = (*pCount <= 0) ? (sizeof(XGL_DESCRIPTOR_SET)) : (*pCount * sizeof(XGL_DESCRIPTOR_SET));')

449

func_body.append(' CREATE_TRACE_PACKET(xglAllocDescriptorSets, sizeof(XGL_DESCRIPTOR_SET_LAYOUT) + customSize + sizeof(uint32_t));')

Jon Ashburn

2015-02-02 12:39:24 -0700

[diff] [blame]

450

func_body.append(' pHeader->entrypoint_begin_time = startTime;')

Jon Ashburn

2015-02-04 08:50:35 -0700

[diff] [blame]

451

elif proto.name in ['CreateShader', 'CreateFramebuffer', 'CreateRenderPass', 'BeginCommandBuffer', 'CreateDynamicViewportState',

Jon Ashburn

2015-02-04 09:32:59 -0700

[diff] [blame]

452

'AllocMemory', 'CreateGraphicsPipeline', 'CreateComputePipeline', 'UpdateDescriptors', 'CreateDescriptorSetLayout',

Tobin Ehlis

2015-02-05 11:29:45 -0700

[diff] [blame]

453

'CreateDescriptorRegion', 'CmdWaitEvents', 'CmdPipelineBarrier']:

Jon Ashburn

2015-02-02 12:39:24 -0700

[diff] [blame]

454

# these are regular case as far as sequence of tracing but custom sizes

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

455

func_body.append(' size_t customSize;')

456

if 'CreateShader' == proto.name:

457

func_body.append(' customSize = (pCreateInfo != NULL) ? pCreateInfo->codeSize : 0;')

458

func_body.append(' CREATE_TRACE_PACKET(xglCreateShader, sizeof(XGL_SHADER_CREATE_INFO) + sizeof(XGL_SHADER) + customSize);')

459

elif 'CreateGraphicsPipeline' == proto.name:

460

func_body.append(' customSize = calculate_pipeline_state_size(pCreateInfo->pNext);')

461

func_body.append(' CREATE_TRACE_PACKET(xglCreateGraphicsPipeline, sizeof(XGL_GRAPHICS_PIPELINE_CREATE_INFO) + sizeof(XGL_PIPELINE) + customSize);')

Tobin Ehlis

2015-02-03 14:41:26 -0700

[diff] [blame]

462

elif 'UpdateDescriptors' == proto.name:

463

func_body.append(' customSize = calculate_update_descriptors_size(pUpdateChain);')

464

func_body.append(' CREATE_TRACE_PACKET(xglUpdateDescriptors, sizeof(XGL_DESCRIPTOR_SET) + customSize);')

465

elif 'CreateDescriptorSetLayout' == proto.name:

466

func_body.append(' customSize = calculate_create_ds_layout_size(pSetLayoutInfoList);')

467

# NOTE : Just allocating enough packet size to account for largest array of uints

Jon Ashburn

7fd7eff

2015-02-04 10:55:47 -0700

[diff] [blame]

468

func_body.append(' CREATE_TRACE_PACKET(xglCreateDescriptorSetLayout, XGL_SHADER_STAGE_COMPUTE * sizeof(uint32_t) + sizeof(XGL_DESCRIPTOR_SET_LAYOUT) + customSize);')

Jon Ashburn

2015-01-02 18:28:26 -0700

[diff] [blame]

469

elif 'CreateFramebuffer' == proto.name:

470

func_body.append(' int dsSize = (pCreateInfo != NULL && pCreateInfo->pDepthStencilAttachment != NULL) ? sizeof(XGL_DEPTH_STENCIL_BIND_INFO) : 0;')

Tobin Ehlis

2015-02-05 11:29:45 -0700

[diff] [blame]

471

func_body.append(' uint32_t colorCount = (pCreateInfo != NULL && pCreateInfo->pColorAttachments != NULL) ? pCreateInfo->colorAttachmentCount : 0;')

Jon Ashburn

2015-01-02 18:28:26 -0700

[diff] [blame]

472

func_body.append(' customSize = colorCount * sizeof(XGL_COLOR_ATTACHMENT_BIND_INFO) + dsSize;')

473

func_body.append(' CREATE_TRACE_PACKET(xglCreateFramebuffer, sizeof(XGL_FRAMEBUFFER_CREATE_INFO) + sizeof(XGL_FRAMEBUFFER) + customSize);')

474

elif 'CreateRenderPass' == proto.name:

475

# HACK ALERT, TODO this API currently has insufficient parameters to determine the count of the colorLoadOps, colorStoreOps, in the CREATE_INFO struct

476

# assume number of colorAttachments == 1 for now rather than tracing code keeping a list of framebuffer objects with colorAttachmentCounts

Tobin Ehlis

2015-02-05 11:29:45 -0700

[diff] [blame]

477

func_body.append(' uint32_t colorCount = (pCreateInfo != NULL && pCreateInfo->pColorLoadOps != NULL && pCreateInfo->pColorStoreOps != NULL && pCreateInfo->pColorLoadClearValues != NULL) ? 1 : 0; //TODO fixme')

Jon Ashburn

2015-01-02 18:28:26 -0700

[diff] [blame]

478

func_body.append(' customSize = colorCount * (sizeof(XGL_ATTACHMENT_LOAD_OP) + sizeof(XGL_ATTACHMENT_STORE_OP) + sizeof(XGL_CLEAR_COLOR));')

479

func_body.append(' CREATE_TRACE_PACKET(xglCreateRenderPass, sizeof(XGL_RENDER_PASS_CREATE_INFO) + sizeof(XGL_RENDER_PASS) + customSize);')

480

elif 'BeginCommandBuffer' == proto.name:

481

func_body.append(' customSize = calculate_begin_cmdbuf_size(pBeginInfo->pNext);')

482

func_body.append(' CREATE_TRACE_PACKET(xglBeginCommandBuffer, sizeof(XGL_CMD_BUFFER_BEGIN_INFO) + customSize);')

Jon Ashburn

2015-02-04 08:50:35 -0700

[diff] [blame]

483

elif 'CreateDynamicViewportState' == proto.name:

Tobin Ehlis

2015-02-05 11:29:45 -0700

[diff] [blame]

484

func_body.append(' uint32_t vpCount = (pCreateInfo != NULL && pCreateInfo->pViewports != NULL) ? pCreateInfo->viewportCount : 0;')

485

func_body.append(' uint32_t scCount = (pCreateInfo != NULL && pCreateInfo->pScissors != NULL) ? pCreateInfo->scissorCount : 0;')

Jon Ashburn

2015-02-04 08:50:35 -0700

[diff] [blame]

486

func_body.append(' customSize = vpCount * sizeof(XGL_VIEWPORT) + scCount * sizeof(XGL_RECT);')

487

func_body.append(' CREATE_TRACE_PACKET(xglCreateDynamicViewportState, sizeof(XGL_DYNAMIC_VP_STATE_CREATE_INFO) + sizeof(XGL_DYNAMIC_VP_STATE_OBJECT) + customSize);')

Jon Ashburn

2015-02-03 07:33:48 -0700

[diff] [blame]

488

elif 'AllocMemory' == proto.name:

489

func_body.append(' customSize = calculate_alloc_memory_size(pAllocInfo->pNext);')

490

func_body.append(' CREATE_TRACE_PACKET(xglAllocMemory, sizeof(XGL_MEMORY_ALLOC_INFO) + sizeof(XGL_GPU_MEMORY) + customSize);')

Jon Ashburn

2015-02-04 09:32:59 -0700

[diff] [blame]

491

elif 'CreateDescriptorRegion' == proto.name:

Tobin Ehlis

2015-02-05 11:29:45 -0700

[diff] [blame]

492

func_body.append(' uint32_t rgCount = (pCreateInfo != NULL && pCreateInfo->pTypeCount != NULL) ? pCreateInfo->count : 0;')

Jon Ashburn

2015-02-04 09:32:59 -0700

[diff] [blame]

493

func_body.append(' customSize = rgCount * sizeof(XGL_DESCRIPTOR_TYPE_COUNT);')

494

func_body.append(' CREATE_TRACE_PACKET(xglCreateDescriptorRegion, sizeof(XGL_DESCRIPTOR_REGION_CREATE_INFO) + sizeof(XGL_DESCRIPTOR_REGION) + customSize);')

Tobin Ehlis

2015-02-05 11:29:45 -0700

[diff] [blame]

495

elif proto.name in ['CmdWaitEvents', 'CmdPipelineBarrier']:

496

event_array_type = 'XGL_EVENT'

497

if 'CmdPipelineBarrier' == proto.name:

498

event_array_type = 'XGL_SET_EVENT'

499

func_body.append(' uint32_t eventCount = (%s != NULL && %s->pEvents != NULL) ? %s->eventCount : 0;' % (proto.params[-1].name, proto.params[-1].name, proto.params[-1].name))

500

func_body.append(' uint32_t mbCount = (%s != NULL && %s->ppMemBarriers != NULL) ? %s->memBarrierCount : 0;' % (proto.params[-1].name, proto.params[-1].name, proto.params[-1].name))

501

func_body.append(' customSize = (eventCount * sizeof(%s)) + (mbCount * 2 * sizeof(void*));' % event_array_type)

502

func_body.append(' CREATE_TRACE_PACKET(xgl%s, sizeof(%s) + customSize);' % (proto.name, proto.params[-1].ty.strip('*').replace('const ', '')))

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

503

else: #'CreateComputePipeline'

504

func_body.append(' customSize = calculate_pipeline_state_size(pCreateInfo->pNext);')

505

func_body.append(' CREATE_TRACE_PACKET(xglCreateComputePipeline, sizeof(XGL_COMPUTE_PIPELINE_CREATE_INFO) + sizeof(XGL_PIPELINE) + customSize + calculate_pipeline_shader_size(&pCreateInfo->cs));')

506

func_body.append(' %sreal_xgl%s;' % (return_txt, proto.c_call()))

507

else:

508

func_body.append(' CREATE_TRACE_PACKET(xgl%s, %s);' % (proto.name, packet_size))

509

func_body.append(' %sreal_xgl%s;' % (return_txt, proto.c_call()))

510

func_body.append(' pPacket = interpret_body_as_xgl%s(pHeader);' % proto.name)

511

func_body.append(packet_update_txt.strip('\n'))

512

if 'MapMemory' == proto.name: # Custom code for MapMem case

513

func_body.append(' if (ppData != NULL)')

514

func_body.append(' {')

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

515

func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->ppData), sizeof(void*), *ppData);')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

516

func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->ppData));')

517

func_body.append(' add_data_to_mem_info(mem, *ppData);')

518

func_body.append(' }')

519

func_body.append(' pPacket->result = result;')

520

func_body.append(' FINISH_TRACE_PACKET();')

521

elif 'EnumerateLayers' == proto.name: #custom code for EnumerateLayers case

522

func_body.append(' pPacket->gpu = gpu;')

523

func_body.append(' pPacket->maxLayerCount = maxLayerCount;')

524

func_body.append(' pPacket->maxStringSize = maxStringSize;')

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

525

func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pOutLayerCount), sizeof(size_t), pOutLayerCount);')

Mark Lobodzinski

953a169

2015-01-09 15:12:03 -0600

[diff] [blame]

526

func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pOutLayerCount));')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

527

func_body.append(' for (i = 0; i < *pOutLayerCount; i++) {')

Chia-I Wu

2014-12-27 15:16:07 +0800

[diff] [blame]

528

func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pOutLayers[i]), ((pOutLayers[i] != NULL) ? strlen(pOutLayers[i]) + 1 : 0), pOutLayers[i]);')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

529

func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pOutLayers[i]));')

530

func_body.append(' }')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

531

532

func_body.append(' pPacket->pReserved = pReserved;')

533

func_body.append(' pPacket->result = result;')

534

func_body.append(' FINISH_TRACE_PACKET();')

535

else:

536

# TODO : Clean this up. Too much custom code and branching.

537

for idx in buff_ptr_indices:

538

if 'DEVICE_CREATE_INFO' in proto.params[idx].ty:

539

func_body.append(' add_XGL_DEVICE_CREATE_INFO_to_packet(pHeader, (XGL_DEVICE_CREATE_INFO**) &(pPacket->pCreateInfo), pCreateInfo);')

Jon Ashburn

2015-02-03 08:57:28 -0700

[diff] [blame]

540

elif 'APPLICATION_INFO' in proto.params[idx].ty:

541

func_body.append(' add_XGL_APPLICATION_INFO_to_packet(pHeader, (XGL_APPLICATION_INFO**)&(pPacket->pAppInfo), pAppInfo);')

Tobin Ehlis

2015-01-15 17:53:54 -0700

[diff] [blame]

542

elif 'char' in proto.params[idx].ty:

Chia-I Wu

2014-12-27 15:16:07 +0800

[diff] [blame]

543

func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), ((%s != NULL) ? strlen(%s) + 1 : 0), %s);' % (proto.params[idx].name, proto.params[idx].name, proto.params[idx].name, proto.params[idx].name))

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

544

elif 'Count' in proto.params[idx-1].name and 'queryCount' != proto.params[idx-1].name:

Tobin Ehlis

2015-01-15 17:53:54 -0700

[diff] [blame]

545

deref = ''

546

if '*' in proto.params[idx-1].ty:

547

deref = '*'

548

func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), %s%s*sizeof(%s), %s);' % (proto.params[idx].name, deref, proto.params[idx-1].name, proto.params[idx].ty.strip('*').replace('const ', ''), proto.params[idx].name))

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

549

elif 'dataSize' == proto.params[idx].name:

550

func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), dataSize, %s);' % (proto.params[idx].name, proto.params[idx].name))

551

elif 'pDataSize' == proto.params[idx].name:

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

552

func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), sizeof(size_t), &dataSizeIn);' % (proto.params[idx].name))

Tobin Ehlis

2015-01-20 13:50:59 -0700

[diff] [blame]

553

elif 'pDescriptorSets' == proto.params[idx].name and 'AllocDescriptorSets' == proto.name:

554

func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pDescriptorSets), customSize, pDescriptorSets);')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

555

elif 'pData' == proto.params[idx].name:

556

if 'dataSize' == proto.params[idx-1].name:

557

func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), dataSize, %s);' % (proto.params[idx].name, proto.params[idx].name))

558

elif in_data_size:

559

func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), dataSizeIn, %s);' % (proto.params[idx].name, proto.params[idx].name))

560

else:

561

func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), (pDataSize != NULL && pData != NULL) ? *pDataSize : 0, %s);' % (proto.params[idx].name, proto.params[idx].name))

Jon Ashburn

2015-02-03 17:47:58 -0700

[diff] [blame]

562

elif 'pUpdateChain' == proto.params[idx].name:

Jon Ashburn

2015-02-04 12:57:25 -0700

[diff] [blame]

563

pass

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

564

else:

Tobin Ehlis

2015-01-15 17:53:54 -0700

[diff] [blame]

565

func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), sizeof(%s), %s);' % (proto.params[idx].name, proto.params[idx].ty.strip('*').replace('const ', ''), proto.params[idx].name))

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

566

# Some custom add_* and finalize_* function calls for Create* API calls

Jon Ashburn

2015-02-04 08:50:35 -0700

[diff] [blame]

567

if proto.name in ['CreateShader', 'CreateFramebuffer', 'CreateRenderPass', 'BeginCommandBuffer', 'CreateDynamicViewportState',

Jon Ashburn

2015-02-04 09:32:59 -0700

[diff] [blame]

568

'AllocMemory', 'UpdateDescriptors', 'CreateDescriptorSetLayout', 'CreateGraphicsPipeline', 'CreateComputePipeline',

Tobin Ehlis

2015-02-05 11:29:45 -0700

[diff] [blame]

569

'CreateDescriptorRegion', 'CmdWaitEvents', 'CmdPipelineBarrier']:

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

570

if 'CreateShader' == proto.name:

571

func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pCode), customSize, pCreateInfo->pCode);')

572

func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pCode));')

Jon Ashburn

2015-01-02 18:28:26 -0700

[diff] [blame]

573

elif 'CreateFramebuffer' == proto.name:

574

func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pColorAttachments), colorCount * sizeof(XGL_COLOR_ATTACHMENT_BIND_INFO), pCreateInfo->pColorAttachments);')

575

func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pDepthStencilAttachment), dsSize, pCreateInfo->pDepthStencilAttachment);')

576

func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pColorAttachments));')

577

func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pDepthStencilAttachment));')

578

elif 'CreateRenderPass' == proto.name:

579

func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pColorLoadOps), colorCount * sizeof(XGL_ATTACHMENT_LOAD_OP), pCreateInfo->pColorLoadOps);')

580

func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pColorStoreOps), colorCount * sizeof(XGL_ATTACHMENT_STORE_OP), pCreateInfo->pColorStoreOps);')

581

func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pColorLoadClearValues), colorCount * sizeof(XGL_CLEAR_COLOR), pCreateInfo->pColorLoadClearValues);')

582

func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pColorLoadOps));')

583

func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pColorStoreOps));')

584

func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pColorLoadClearValues));')

585

elif 'BeginCommandBuffer' == proto.name:

Jon Ashburn

2015-02-03 07:33:48 -0700

[diff] [blame]

586

func_body.append(' add_begin_cmdbuf_to_trace_packet(pHeader, (void**)&(pPacket->pBeginInfo->pNext), pBeginInfo->pNext);')

Jon Ashburn

2015-02-04 08:50:35 -0700

[diff] [blame]

587

elif 'CreateDynamicViewportState' == proto.name:

Jon Ashburn

2015-02-04 09:32:59 -0700

[diff] [blame]

588

func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pViewports), vpCount * sizeof(XGL_VIEWPORT), pCreateInfo->pViewports);')

Jon Ashburn

2015-02-04 08:50:35 -0700

[diff] [blame]

589

func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pScissors), scCount * sizeof(XGL_RECT), pCreateInfo->pScissors);')

590

func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pViewports));')

591

func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pScissors));')

Jon Ashburn

2015-02-03 07:33:48 -0700

[diff] [blame]

592

elif 'AllocMemory' == proto.name:

593

func_body.append(' add_alloc_memory_to_trace_packet(pHeader, (void**)&(pPacket->pAllocInfo->pNext), pAllocInfo->pNext);')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

594

elif 'CreateGraphicsPipeline' == proto.name:

Jon Ashburn

2015-02-03 07:33:48 -0700

[diff] [blame]

595

func_body.append(' add_pipeline_state_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pNext), pCreateInfo->pNext);')

Tobin Ehlis

2015-02-03 14:41:26 -0700

[diff] [blame]

596

elif 'UpdateDescriptors' == proto.name:

597

func_body.append(' add_update_descriptors_to_trace_packet(pHeader, (void**)&(pPacket->pUpdateChain), pUpdateChain);')

598

elif 'CreateDescriptorSetLayout' == proto.name:

Jon Ashburn

280bb68

2015-02-09 09:43:26 -0700

[diff] [blame^]

599

func_body.append(' if (pSetLayoutInfoList)')

600

func_body.append(' add_create_ds_layout_to_trace_packet(pHeader, (void**)&(pPacket->pSetLayoutInfoList->pNext), pSetLayoutInfoList->pNext);')

Jon Ashburn

2015-02-04 09:32:59 -0700

[diff] [blame]

601

elif 'CreateDescriptorRegion' == proto.name:

602

func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pTypeCount), rgCount * sizeof(XGL_DESCRIPTOR_TYPE_COUNT), pCreateInfo->pTypeCount);')

603

func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pCreateInfo->pTypeCount));')

Tobin Ehlis

2015-02-05 11:29:45 -0700

[diff] [blame]

604

elif proto.name in ['CmdWaitEvents', 'CmdPipelineBarrier']:

605

event_array_type = 'XGL_EVENT'

606

if 'CmdPipelineBarrier' == proto.name:

607

event_array_type = 'XGL_SET_EVENT'

608

func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s->pEvents), eventCount * sizeof(%s), %s->pEvents);' % (proto.params[-1].name, event_array_type, proto.params[-1].name))

609

func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->%s->pEvents));' % (proto.params[-1].name))

610

func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s->ppMemBarriers), mbCount * sizeof(void*), %s->ppMemBarriers);' % (proto.params[-1].name, proto.params[-1].name))

611

func_body.append(' uint32_t i;')

612

func_body.append(' for (i = 0; i < mbCount; i++) {')

613

func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s->ppMemBarriers[i]), sizeof(void*), %s->ppMemBarriers[i]);' % (proto.params[-1].name, proto.params[-1].name))

614

func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->%s->ppMemBarriers[i]));' % (proto.params[-1].name))

615

func_body.append(' }')

616

func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->%s->ppMemBarriers));' % (proto.params[-1].name))

Jon Ashburn

2015-02-04 09:32:59 -0700

[diff] [blame]

617

else: #'CreateComputePipeline'

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

618

func_body.append(' add_pipeline_state_to_trace_packet(pHeader, (void**)&(pPacket->pCreateInfo->pNext), pCreateInfo->pNext);')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

619

func_body.append(' add_pipeline_shader_to_trace_packet(pHeader, (XGL_PIPELINE_SHADER*)&pPacket->pCreateInfo->cs, &pCreateInfo->cs);')

620

func_body.append(' finalize_pipeline_shader_address(pHeader, &pPacket->pCreateInfo->cs);')

Tobin Ehlis

2015-01-15 17:53:54 -0700

[diff] [blame]

621

if 'void' not in proto.ret or '*' in proto.ret:

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

622

func_body.append(' pPacket->result = result;')

623

for idx in buff_ptr_indices:

Jon Ashburn

2015-02-04 12:57:25 -0700

[diff] [blame]

624

if ('DEVICE_CREATE_INFO' not in proto.params[idx].ty) and ('APPLICATION_INFO' not in proto.params[idx].ty) and ('pUpdateChain' != proto.params[idx].name):

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

625

func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->%s));' % (proto.params[idx].name))

626

func_body.append(' FINISH_TRACE_PACKET();')

627

if 'AllocMemory' in proto.name:

628

func_body.append(' add_new_handle_to_mem_info(*pMem, pAllocInfo->allocationSize, NULL);')

629

elif 'FreeMemory' in proto.name:

630

func_body.append(' rm_handle_from_mem_info(mem);')

Tobin Ehlis

2015-01-15 17:53:54 -0700

[diff] [blame]

631

if 'void' not in proto.ret or '*' in proto.ret:

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

632

func_body.append(' return result;')

633

func_body.append('}\n')

634

return "\n".join(func_body)

635

636

def _generate_trace_funcs_ext(self, func_class='Wsi'):

637

thread_once_funcs = ['DbgRegisterMsgCallback', 'DbgUnregisterMsgCallback', 'DbgSetGlobalOption']

638

func_body = []

639

for proto in self.protos:

640

if func_class in proto.name:

641

packet_update_txt = ''

642

return_txt = ''

643

packet_size = ''

644

buff_ptr_indices = []

645

func_body.append('GLVTRACER_EXPORT %s XGLAPI __HOOKED_xgl%s(' % (proto.ret, proto.name))

646

for p in proto.params: # TODO : For all of the ptr types, check them for NULL and return 0 is NULL

647

func_body.append(' %s %s,' % (p.ty, p.name))

648

if 'Size' in p.name:

649

packet_size += p.name

650

if '*' in p.ty and 'pSysMem' != p.name:

Tobin Ehlis

2015-01-15 17:53:54 -0700

[diff] [blame]

651

if 'char' in p.ty:

Chia-I Wu

2014-12-27 15:16:07 +0800

[diff] [blame]

652

packet_size += '((%s != NULL) ? strlen(%s) + 1 : 0) + ' % (p.name, p.name)

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

653

elif 'Size' not in packet_size:

Tobin Ehlis

2015-01-15 17:53:54 -0700

[diff] [blame]

654

packet_size += 'sizeof(%s) + ' % p.ty.strip('*').replace('const ', '')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

655

buff_ptr_indices.append(proto.params.index(p))

656

if 'pConnectionInfo' in p.name:

657

packet_size += '((pConnectionInfo->pConnection != NULL) ? sizeof(void *) : 0)'

658

else:

659

packet_update_txt += ' pPacket->%s = %s;\n' % (p.name, p.name)

660

if '' == packet_size:

661

packet_size = '0'

662

else:

663

packet_size = packet_size.strip(' + ')

664

func_body[-1] = func_body[-1].replace(',', ')')

665

func_body.append('{\n glv_trace_packet_header* pHeader;')

Tobin Ehlis

2015-01-15 17:53:54 -0700

[diff] [blame]

666

if 'void' not in proto.ret or '*' in proto.ret:

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

667

func_body.append(' %s result;' % proto.ret)

668

return_txt = 'result = '

669

func_body.append(' struct_xgl%s* pPacket = NULL;' % proto.name)

670

if proto.name in thread_once_funcs:

671

func_body.append(' glv_platform_thread_once(&gInitOnce, InitTracer);')

672

func_body.append(' SEND_ENTRYPOINT_ID(xgl%s);' % proto.name)

673

func_body.append(' CREATE_TRACE_PACKET(xgl%s, %s);' % (proto.name, packet_size))

674

func_body.append(' %sreal_xgl%s;' % (return_txt, proto.c_call()))

675

func_body.append(' pPacket = interpret_body_as_xgl%s(pHeader);' % proto.name)

676

func_body.append(packet_update_txt.strip('\n'))

677

for idx in buff_ptr_indices:

Tobin Ehlis

2015-01-15 17:53:54 -0700

[diff] [blame]

678

if 'char' in proto.params[idx].ty:

Chia-I Wu

2014-12-27 15:16:07 +0800

[diff] [blame]

679

func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), ((%s != NULL) ? strlen(%s) + 1 : 0), %s);' % (proto.params[idx].name, proto.params[idx].name, proto.params[idx].name, proto.params[idx].name))

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

680

elif 'Size' in proto.params[idx-1].name:

681

func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), %s, %s);' % (proto.params[idx].name, proto.params[idx-1].name, proto.params[idx].name))

682

else:

Tobin Ehlis

2015-01-15 17:53:54 -0700

[diff] [blame]

683

func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->%s), sizeof(%s), %s);' % (proto.params[idx].name, proto.params[idx].ty.strip('*').replace('const ', ''), proto.params[idx].name))

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

684

if 'WsiX11AssociateConnection' in proto.name:

685

func_body.append(' if (pConnectionInfo->pConnection != NULL) {')

686

func_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**) &(pPacket->pConnectionInfo->pConnection), sizeof(void *), pConnectionInfo->pConnection);')

687

func_body.append(' glv_finalize_buffer_address(pHeader, (void**) &(pPacket->pConnectionInfo->pConnection));')

688

func_body.append(' }')

Tobin Ehlis

2015-01-15 17:53:54 -0700

[diff] [blame]

689

if 'void' not in proto.ret or '*' in proto.ret:

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

690

func_body.append(' pPacket->result = result;')

691

for idx in buff_ptr_indices:

692

func_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->%s));' % (proto.params[idx].name))

693

func_body.append(' FINISH_TRACE_PACKET();')

Tobin Ehlis

2015-01-15 17:53:54 -0700

[diff] [blame]

694

if 'void' not in proto.ret or '*' in proto.ret:

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

695

func_body.append(' return result;')

696

func_body.append('}\n')

697

return "\n".join(func_body)

698

699

def _generate_helper_funcs(self):

700

hf_body = []

701

hf_body.append('// Support for shadowing CPU mapped memory')

702

hf_body.append('typedef struct _XGLAllocInfo {')

703

hf_body.append(' XGL_GPU_SIZE size;')

704

hf_body.append(' XGL_GPU_MEMORY handle;')

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

705

hf_body.append(' void *pData;')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

706

hf_body.append(' BOOL valid;')

707

hf_body.append('} XGLAllocInfo;')

708

hf_body.append('typedef struct _XGLMemInfo {')

709

hf_body.append(' unsigned int numEntrys;')

710

hf_body.append(' XGLAllocInfo *pEntrys;')

711

hf_body.append(' XGLAllocInfo *pLastMapped;')

712

hf_body.append(' unsigned int capacity;')

713

hf_body.append('} XGLMemInfo;')

714

hf_body.append('')

715

hf_body.append('static XGLMemInfo mInfo = {0, NULL, NULL, 0};')

716

hf_body.append('')

717

hf_body.append('static void init_mem_info_entrys(XGLAllocInfo *ptr, const unsigned int num)')

718

hf_body.append('{')

719

hf_body.append(' unsigned int i;')

720

hf_body.append(' for (i = 0; i < num; i++)')

721

hf_body.append(' {')

722

hf_body.append(' XGLAllocInfo *entry = ptr + i;')

723

hf_body.append(' entry->pData = NULL;')

724

hf_body.append(' entry->size = 0;')

725

hf_body.append(' entry->handle = NULL;')

726

hf_body.append(' entry->valid = FALSE;')

hf_body.append(' }')

hf_body.append('}')

hf_body.append('')

hf_body.append('static void init_mem_info()')

731

hf_body.append('{')

732

hf_body.append(' mInfo.numEntrys = 0;')

733

hf_body.append(' mInfo.capacity = 1024;')

734

hf_body.append(' mInfo.pLastMapped = NULL;')

735

hf_body.append('')

736

hf_body.append(' mInfo.pEntrys = GLV_NEW_ARRAY(XGLAllocInfo, mInfo.capacity);')

737

hf_body.append('')

738

hf_body.append(' if (mInfo.pEntrys == NULL)')

739

hf_body.append(' glv_LogError("init_mem_info() malloc failed\\n");')

740

hf_body.append(' else')

741

hf_body.append(' init_mem_info_entrys(mInfo.pEntrys, mInfo.capacity);')

742

hf_body.append('}')

743

hf_body.append('')

744

hf_body.append('static void delete_mem_info()')

745

hf_body.append('{')

746

hf_body.append(' GLV_DELETE(mInfo.pEntrys);')

747

hf_body.append(' mInfo.pEntrys = NULL;')

748

hf_body.append(' mInfo.numEntrys = 0;')

749

hf_body.append(' mInfo.capacity = 0;')

750

hf_body.append(' mInfo.pLastMapped = NULL;')

751

hf_body.append('}')

752

hf_body.append('')

753

hf_body.append('static XGLAllocInfo * get_mem_info_entry()')

754

hf_body.append('{')

755

hf_body.append(' unsigned int i;')

756

hf_body.append(' XGLAllocInfo *entry;')

757

hf_body.append(' if (mInfo.numEntrys > mInfo.capacity)')

758

hf_body.append(' {')

759

hf_body.append(' glv_LogError("get_mem_info_entry() bad internal state numEntrys\\n");')

760

hf_body.append(' return NULL;')

761

hf_body.append(' }')

762

hf_body.append('')

763

hf_body.append(' if (mInfo.numEntrys == mInfo.capacity)')

764

hf_body.append(' { // grow the array 2x')

765

hf_body.append(' mInfo.capacity *= 2;')

766

hf_body.append(' mInfo.pEntrys = (XGLAllocInfo *) GLV_REALLOC(mInfo.pEntrys, mInfo.capacity * sizeof(XGLAllocInfo));')

767

hf_body.append(' //init the newly added entrys')

768

hf_body.append(' init_mem_info_entrys(mInfo.pEntrys + mInfo.capacity / 2, mInfo.capacity / 2);')

769

hf_body.append(' }')

770

hf_body.append('')

771

hf_body.append(' assert(mInfo.numEntrys < mInfo.capacity);')

772

hf_body.append(' entry = mInfo.pEntrys;')

773

hf_body.append(' for (i = 0; i < mInfo.capacity; i++)')

774

hf_body.append(' {')

775

hf_body.append(' if ((entry + i)->valid == FALSE)')

776

hf_body.append(' return entry + i;')

777

hf_body.append(' }')

778

hf_body.append('')

779

hf_body.append(' glv_LogError("get_mem_info_entry() did not find an entry\\n");')

780

hf_body.append(' return NULL;')

781

hf_body.append('}')

782

hf_body.append('')

783

hf_body.append('static XGLAllocInfo * find_mem_info_entry(const XGL_GPU_MEMORY handle)')

784

hf_body.append('{')

785

hf_body.append(' XGLAllocInfo *entry = mInfo.pEntrys;')

786

hf_body.append(' unsigned int i;')

787

hf_body.append(' if (mInfo.pLastMapped && mInfo.pLastMapped->handle == handle && mInfo.pLastMapped->valid)')

788

hf_body.append(' return mInfo.pLastMapped;')

789

hf_body.append(' for (i = 0; i < mInfo.numEntrys; i++)')

790

hf_body.append(' {')

791

hf_body.append(' if ((entry + i)->valid && (handle == (entry + i)->handle))')

792

hf_body.append(' return entry + i;')

793

hf_body.append(' }')

794

hf_body.append('')

795

hf_body.append(' return NULL;')

796

hf_body.append('}')

797

hf_body.append('')

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

798

hf_body.append('static void add_new_handle_to_mem_info(const XGL_GPU_MEMORY handle, XGL_GPU_SIZE size, void *pData)')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

799

hf_body.append('{')

800

hf_body.append(' XGLAllocInfo *entry;')

801

hf_body.append('')

802

hf_body.append(' if (mInfo.capacity == 0)')

803

hf_body.append(' init_mem_info();')

804

hf_body.append('')

805

hf_body.append(' entry = get_mem_info_entry();')

806

hf_body.append(' if (entry)')

807

hf_body.append(' {')

808

hf_body.append(' entry->valid = TRUE;')

809

hf_body.append(' entry->handle = handle;')

810

hf_body.append(' entry->size = size;')

811

hf_body.append(' entry->pData = pData; // NOTE: xglFreeMemory will free this mem, so no malloc()')

812

hf_body.append(' mInfo.numEntrys++;')

813

hf_body.append(' }')

814

hf_body.append('}')

815

hf_body.append('')

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

816

hf_body.append('static void add_data_to_mem_info(const XGL_GPU_MEMORY handle, void *pData)')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

817

hf_body.append('{')

818

hf_body.append(' XGLAllocInfo *entry = find_mem_info_entry(handle);')

819

hf_body.append('')

820

hf_body.append(' if (entry)')

821

hf_body.append(' {')

822

hf_body.append(' entry->pData = pData;')

823

hf_body.append(' }')

824

hf_body.append(' mInfo.pLastMapped = entry;')

825

hf_body.append('}')

826

hf_body.append('')

827

hf_body.append('static void rm_handle_from_mem_info(const XGL_GPU_MEMORY handle)')

828

hf_body.append('{')

829

hf_body.append(' XGLAllocInfo *entry = find_mem_info_entry(handle);')

830

hf_body.append('')

831

hf_body.append(' if (entry)')

832

hf_body.append(' {')

833

hf_body.append(' entry->valid = FALSE;')

834

hf_body.append(' entry->pData = NULL;')

835

hf_body.append(' entry->size = 0;')

836

hf_body.append(' entry->handle = NULL;')

837

hf_body.append('')

838

hf_body.append(' mInfo.numEntrys--;')

839

hf_body.append(' if (entry == mInfo.pLastMapped)')

840

hf_body.append(' mInfo.pLastMapped = NULL;')

841

hf_body.append(' if (mInfo.numEntrys == 0)')

842

hf_body.append(' delete_mem_info();')

843

hf_body.append(' }')

844

hf_body.append('}')

845

hf_body.append('')

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

846

hf_body.append('static void add_begin_cmdbuf_to_trace_packet(glv_trace_packet_header* pHeader, void** ppOut, const void* pIn)')

Jon Ashburn

2015-01-02 18:28:26 -0700

[diff] [blame]

847

hf_body.append('{')

848

hf_body.append(' const XGL_CMD_BUFFER_BEGIN_INFO* pInNow = pIn;')

849

hf_body.append(' XGL_CMD_BUFFER_BEGIN_INFO** ppOutNext = (XGL_CMD_BUFFER_BEGIN_INFO**)ppOut;')

850

hf_body.append(' while (pInNow != NULL)')

851

hf_body.append(' {')

852

hf_body.append(' XGL_CMD_BUFFER_BEGIN_INFO** ppOutNow = ppOutNext;')

853

hf_body.append(' ppOutNext = NULL;')

854

hf_body.append('')

855

hf_body.append(' switch (pInNow->sType)')

856

hf_body.append(' {')

857

hf_body.append(' case XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO:')

858

hf_body.append(' {')

859

hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO), pInNow);')

860

hf_body.append(' ppOutNext = (XGL_CMD_BUFFER_BEGIN_INFO**)&(*ppOutNow)->pNext;')

861

hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')

862

hf_body.append(' break;')

863

hf_body.append(' }')

864

hf_body.append(' default:')

Jon Ashburn

2015-02-03 07:33:48 -0700

[diff] [blame]

865

hf_body.append(' assert(!"Encountered an unexpected type in cmdbuffer_begin_info list");')

Jon Ashburn

2015-01-02 18:28:26 -0700

[diff] [blame]

866

hf_body.append(' }')

867

hf_body.append(' pInNow = (XGL_CMD_BUFFER_BEGIN_INFO*)pInNow->pNext;')

868

hf_body.append(' }')

869

hf_body.append(' return;')

870

hf_body.append('}')

Tobin Ehlis

2015-01-22 12:29:31 -0700

[diff] [blame]

871

hf_body.append('')

Jon Ashburn

2015-01-02 18:28:26 -0700

[diff] [blame]

872

hf_body.append('static size_t calculate_begin_cmdbuf_size(const XGL_CMD_BUFFER_BEGIN_INFO* pNext)')

873

hf_body.append('{')

874

hf_body.append(' size_t siz = 0;')

875

hf_body.append(' while (pNext != NULL)')

876

hf_body.append(' {')

877

hf_body.append(' switch (pNext->sType)')

878

hf_body.append(' {')

879

hf_body.append(' case XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO:')

880

hf_body.append(' {')

881

hf_body.append(' siz += sizeof(XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO);')

882

hf_body.append(' break;')

883

hf_body.append(' }')

884

hf_body.append(' default:')

885

hf_body.append(' glv_LogError("calculate_begin_cmdbuf_size() bad internal state sType\\n");')

886

hf_body.append(' break;')

887

hf_body.append(' }')

888

hf_body.append(' pNext = (XGL_CMD_BUFFER_BEGIN_INFO*)pNext->pNext;')

889

hf_body.append(' }')

890

hf_body.append(' return siz;')

891

hf_body.append('}')

892

hf_body.append('')

Jon Ashburn

2015-02-03 07:33:48 -0700

[diff] [blame]

893

hf_body.append('static void add_alloc_memory_to_trace_packet(glv_trace_packet_header* pHeader, void** ppOut, const void* pIn)')

894

hf_body.append('{')

895

hf_body.append(' const XGL_MEMORY_ALLOC_INFO* pInNow = pIn;')

896

hf_body.append(' XGL_MEMORY_ALLOC_INFO** ppOutNext = (XGL_MEMORY_ALLOC_INFO**)ppOut;')

897

hf_body.append(' while (pInNow != NULL)')

898

hf_body.append(' {')

899

hf_body.append(' XGL_MEMORY_ALLOC_INFO** ppOutNow = ppOutNext;')

900

hf_body.append(' ppOutNext = NULL;')

901

hf_body.append('')

902

hf_body.append(' switch (pInNow->sType)')

903

hf_body.append(' {')

904

hf_body.append(' case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO:')

905

hf_body.append(' {')

906

hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_MEMORY_ALLOC_BUFFER_INFO), pInNow);')

907

hf_body.append(' ppOutNext = (XGL_MEMORY_ALLOC_INFO**)&(*ppOutNow)->pNext;')

908

hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')

909

hf_body.append(' break;')

910

hf_body.append(' }')

911

hf_body.append(' case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO:')

912

hf_body.append(' {')

913

hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_MEMORY_ALLOC_IMAGE_INFO), pInNow);')

914

hf_body.append(' ppOutNext = (XGL_MEMORY_ALLOC_INFO**)&(*ppOutNow)->pNext;')

915

hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')

916

hf_body.append(' break;')

917

hf_body.append(' }')

918

hf_body.append(' default:')

919

hf_body.append(' assert(!"Encountered an unexpected type in memory_alloc_info list");')

920

hf_body.append(' }')

921

hf_body.append(' pInNow = (XGL_MEMORY_ALLOC_INFO*)pInNow->pNext;')

922

hf_body.append(' }')

923

hf_body.append(' return;')

924

hf_body.append('}')

925

hf_body.append('')

926

hf_body.append('static size_t calculate_alloc_memory_size(const XGL_MEMORY_ALLOC_INFO* pNext)')

927

hf_body.append('{')

928

hf_body.append(' size_t siz = 0;')

929

hf_body.append(' while (pNext != NULL)')

930

hf_body.append(' {')

931

hf_body.append(' switch (pNext->sType)')

932

hf_body.append(' {')

933

hf_body.append(' case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO:')

934

hf_body.append(' {')

935

hf_body.append(' siz += sizeof(XGL_MEMORY_ALLOC_BUFFER_INFO);')

936

hf_body.append(' break;')

937

hf_body.append(' }')

938

hf_body.append(' case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO:')

939

hf_body.append(' {')

940

hf_body.append(' siz += sizeof(XGL_MEMORY_ALLOC_IMAGE_INFO);')

941

hf_body.append(' break;')

942

hf_body.append(' }')

943

hf_body.append(' default:')

944

hf_body.append(' glv_LogError("calculate_alloc_memory_size() bad internal state sType\\n");')

945

hf_body.append(' break;')

946

hf_body.append(' }')

947

hf_body.append(' pNext = (XGL_MEMORY_ALLOC_INFO*)pNext->pNext;')

948

hf_body.append(' }')

949

hf_body.append(' return siz;')

950

hf_body.append('}')

951

hf_body.append('')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

952

hf_body.append('static size_t calculate_pipeline_shader_size(const XGL_PIPELINE_SHADER* shader)')

953

hf_body.append('{')

954

hf_body.append(' size_t size = 0;')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

955

hf_body.append(' size += sizeof(XGL_PIPELINE_SHADER);')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

956

hf_body.append(' // constant buffers')

957

hf_body.append(' if (shader->linkConstBufferCount > 0 && shader->pLinkConstBufferInfo != NULL)')

958

hf_body.append(' {')

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

959

hf_body.append(' uint32_t i;')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

960

hf_body.append(' for (i = 0; i < shader->linkConstBufferCount; i++)')

961

hf_body.append(' {')

962

hf_body.append(' size += sizeof(XGL_LINK_CONST_BUFFER);')

963

hf_body.append(' size += shader->pLinkConstBufferInfo[i].bufferSize;')

964

hf_body.append(' }')

Tobin Ehlis

2015-01-16 15:13:34 -0700

[diff] [blame]

965

hf_body.append(' }')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

966

hf_body.append(' return size;')

967

hf_body.append('}')

968

hf_body.append('')

969

hf_body.append('static void add_pipeline_shader_to_trace_packet(glv_trace_packet_header* pHeader, XGL_PIPELINE_SHADER* packetShader, const XGL_PIPELINE_SHADER* paramShader)')

970

hf_body.append('{')

Tobin Ehlis

2015-01-16 15:13:34 -0700

[diff] [blame]

971

hf_body.append(' uint32_t i;')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

972

hf_body.append(' // constant buffers')

973

hf_body.append(' if (paramShader->linkConstBufferCount > 0 && paramShader->pLinkConstBufferInfo != NULL)')

974

hf_body.append(' {')

975

hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(packetShader->pLinkConstBufferInfo), sizeof(XGL_LINK_CONST_BUFFER) * paramShader->linkConstBufferCount, paramShader->pLinkConstBufferInfo);')

976

hf_body.append(' for (i = 0; i < paramShader->linkConstBufferCount; i++)')

977

hf_body.append(' {')

978

hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(packetShader->pLinkConstBufferInfo[i].pBufferData), packetShader->pLinkConstBufferInfo[i].bufferSize, paramShader->pLinkConstBufferInfo[i].pBufferData);')

hf_body.append(' }')

hf_body.append(' }')

hf_body.append('}')

hf_body.append('')

hf_body.append('static void finalize_pipeline_shader_address(glv_trace_packet_header* pHeader, const XGL_PIPELINE_SHADER* packetShader)')

984

hf_body.append('{')

Tobin Ehlis

2015-01-16 15:13:34 -0700

[diff] [blame]

985

hf_body.append(' uint32_t i;')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

986

hf_body.append(' // constant buffers')

987

hf_body.append(' if (packetShader->linkConstBufferCount > 0 && packetShader->pLinkConstBufferInfo != NULL)')

988

hf_body.append(' {')

989

hf_body.append(' for (i = 0; i < packetShader->linkConstBufferCount; i++)')

990

hf_body.append(' {')

991

hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(packetShader->pLinkConstBufferInfo[i].pBufferData));')

992

hf_body.append(' }')

993

hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(packetShader->pLinkConstBufferInfo));')

994

hf_body.append(' }')

995

hf_body.append('}')

996

hf_body.append('')

Tobin Ehlis

2015-02-03 14:41:26 -0700

[diff] [blame]

997

hf_body.append('static size_t calculate_create_ds_layout_size(const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pCreateInfo)')

998

hf_body.append('{')

999

hf_body.append(' size_t update_size = 0;')

1000

hf_body.append(' XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pTrav = (XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO*)pCreateInfo;')

1001

hf_body.append(' while (pTrav)')

1002

hf_body.append(' {')

1003

hf_body.append(' update_size += sizeof(XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO);')

1004

hf_body.append(' pTrav = (XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO*)pTrav->pNext;')

1005

hf_body.append(' }')

1006

hf_body.append(' return update_size;')

1007

hf_body.append('}')

1008

hf_body.append('')

1009

hf_body.append('static void add_create_ds_layout_to_trace_packet(glv_trace_packet_header* pHeader, void** ppOut, const void* pIn)')

1010

hf_body.append('{')

1011

hf_body.append(' const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pInNow = pIn;')

1012

hf_body.append(' XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO** ppOutNext = (XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO**)ppOut;')

1013

hf_body.append(' while (pInNow != NULL)')

1014

hf_body.append(' {')

1015

hf_body.append(' XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO** ppOutNow = ppOutNext;')

1016

hf_body.append(' ppOutNext = NULL;')

1017

hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO), pInNow);')

1018

hf_body.append(' ppOutNext = (XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO**)&(*ppOutNow)->pNext;')

1019

hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')

1020

hf_body.append(' pInNow = (XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO*)pInNow->pNext;')

1021

hf_body.append(' }')

1022

hf_body.append(' return;')

1023

hf_body.append('}')

1024

hf_body.append('')

1025

hf_body.append('static size_t calculate_update_descriptors_size(const void* pUpdateChain)')

1026

hf_body.append('{')

1027

hf_body.append(' const XGL_UPDATE_SAMPLERS* pNext = pUpdateChain;')

1028

hf_body.append(' size_t totalUpdateSize = 0;')

1029

hf_body.append(' while (pNext)')

1030

hf_body.append(' {')

1031

hf_body.append(' switch (pNext->sType)')

1032

hf_body.append(' {')

1033

hf_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:')

1034

hf_body.append(' {')

1035

hf_body.append(' totalUpdateSize += sizeof(XGL_UPDATE_SAMPLERS) + ((XGL_UPDATE_SAMPLERS*)pNext)->count * sizeof(XGL_SAMPLER);')

1036

hf_body.append(' break;')

1037

hf_body.append(' }')

1038

hf_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:')

1039

hf_body.append(' {')

1040

hf_body.append(' totalUpdateSize += sizeof(XGL_UPDATE_SAMPLER_TEXTURES) + ((XGL_UPDATE_SAMPLER_TEXTURES*)pNext)->count * (sizeof(XGL_SAMPLER_IMAGE_VIEW_INFO) + sizeof(XGL_IMAGE_VIEW_ATTACH_INFO));')

1041

hf_body.append(' break;')

1042

hf_body.append(' }')

1043

hf_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:')

1044

hf_body.append(' {')

Tobin Ehlis

2015-02-05 11:29:45 -0700

[diff] [blame]

1045

hf_body.append(' totalUpdateSize += sizeof(XGL_UPDATE_IMAGES) + (((XGL_UPDATE_IMAGES*)pNext)->count * (sizeof(XGL_IMAGE_VIEW_ATTACH_INFO) + sizeof(XGL_IMAGE_VIEW_ATTACH_INFO*)));')

Tobin Ehlis

2015-02-03 14:41:26 -0700

[diff] [blame]

1046

hf_body.append(' break;')

1047

hf_body.append(' }')

1048

hf_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:')

1049

hf_body.append(' {')

Tobin Ehlis

2015-02-05 11:29:45 -0700

[diff] [blame]

1050

hf_body.append(' totalUpdateSize += sizeof(XGL_UPDATE_BUFFERS) + (((XGL_UPDATE_BUFFERS*)pNext)->count * (sizeof(XGL_BUFFER_VIEW_ATTACH_INFO) + sizeof(XGL_BUFFER_VIEW_ATTACH_INFO*)));')

Tobin Ehlis

2015-02-03 14:41:26 -0700

[diff] [blame]

1051

hf_body.append(' break;')

1052

hf_body.append(' }')

1053

hf_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:')

1054

hf_body.append(' {')

1055

hf_body.append(' totalUpdateSize += sizeof(XGL_UPDATE_AS_COPY);')

1056

hf_body.append(' break;')

1057

hf_body.append(' }')

1058

hf_body.append(' default:')

1059

hf_body.append(' assert(0);')

1060

hf_body.append(' }')

1061

hf_body.append(' pNext = (XGL_UPDATE_SAMPLERS*)pNext->pNext;')

1062

hf_body.append(' }')

1063

hf_body.append(' return totalUpdateSize;')

1064

hf_body.append('}')

1065

hf_body.append('')

1066

hf_body.append('static void add_update_descriptors_to_trace_packet(glv_trace_packet_header* pHeader, void** ppOut, const void* pIn)')

1067

hf_body.append('{')

1068

hf_body.append(' const XGL_UPDATE_SAMPLERS* pInNow = pIn;')

1069

hf_body.append(' XGL_UPDATE_SAMPLERS** ppOutNext = (XGL_UPDATE_SAMPLERS**)ppOut;')

1070

hf_body.append(' while (pInNow != NULL)')

1071

hf_body.append(' {')

1072

hf_body.append(' XGL_UPDATE_SAMPLERS** ppOutNow = ppOutNext;')

1073

hf_body.append(' ppOutNext = NULL;')

1074

hf_body.append(' switch (pInNow->sType)')

1075

hf_body.append(' {')

1076

hf_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:')

1077

hf_body.append(' {')

1078

hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_UPDATE_SAMPLERS), pInNow);')

Jon Ashburn

2015-02-03 17:47:58 -0700

[diff] [blame]

1079

hf_body.append(' XGL_UPDATE_SAMPLERS* pPacket = (XGL_UPDATE_SAMPLERS*)*ppOutNow;')

Tobin Ehlis

2015-02-03 14:41:26 -0700

[diff] [blame]

1080

hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void **) &pPacket->pSamplers, ((XGL_UPDATE_SAMPLERS*)pInNow)->count * sizeof(XGL_SAMPLER), ((XGL_UPDATE_SAMPLERS*)pInNow)->pSamplers);')

1081

hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pSamplers));')

1082

hf_body.append(' ppOutNext = (XGL_UPDATE_SAMPLERS**)&(*ppOutNow)->pNext;')

1083

hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')

1084

hf_body.append(' break;')

1085

hf_body.append(' }')

1086

hf_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:')

1087

hf_body.append(' {')

1088

#hf_body.append(' totalUpdateSize += sizeof(XGL_UPDATE_SAMPLER_TEXTURES) + ((XGL_UPDATE_SAMPLER_TEXTURES*)pNext)->count * (sizeof(XGL_SAMPLER_IMAGE_VIEW_INFO) + sizeof(XGL_IMAGE_VIEW_ATTACH_INFO));')

Jon Ashburn

2015-02-03 17:47:58 -0700

[diff] [blame]

1089

hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_UPDATE_SAMPLER_TEXTURES), pInNow);')

1090

hf_body.append(' XGL_UPDATE_SAMPLER_TEXTURES* pPacket = (XGL_UPDATE_SAMPLER_TEXTURES*)*ppOutNow;')

Tobin Ehlis

2015-02-03 14:41:26 -0700

[diff] [blame]

1091

hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void **) &pPacket->pSamplerImageViews, ((XGL_UPDATE_SAMPLER_TEXTURES*)pInNow)->count * sizeof(XGL_SAMPLER_IMAGE_VIEW_INFO), ((XGL_UPDATE_SAMPLER_TEXTURES*)pInNow)->pSamplerImageViews);')

Tobin Ehlis

2015-02-03 14:41:26 -0700

[diff] [blame]

1092

# TODO : This is still broken. How to update the original XGL_SAMPLER_IMAGE_VIEW_INFO struct ptrs to have correct address for newly added XGL_IMAGE_VIEW_ATTACH_INFO blocks below?

1093

hf_body.append(' uint32_t i;')

1094

hf_body.append(' for (i = 0; i < ((XGL_UPDATE_SAMPLER_TEXTURES*)pInNow)->count; i++) {')

Jon Ashburn

2015-02-04 12:57:25 -0700

[diff] [blame]

1095

hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void **) &pPacket->pSamplerImageViews[i].pImageView, sizeof(XGL_IMAGE_VIEW_ATTACH_INFO), ((XGL_UPDATE_SAMPLER_TEXTURES*)pInNow)->pSamplerImageViews[i].pImageView);')

Jon Ashburn

2015-02-03 17:47:58 -0700

[diff] [blame]

1096

hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pSamplerImageViews[i].pImageView));')

Tobin Ehlis

2015-02-03 14:41:26 -0700

[diff] [blame]

1097

hf_body.append(' }')

Jon Ashburn

2015-02-03 17:47:58 -0700

[diff] [blame]

1098

hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pSamplerImageViews));')

Tobin Ehlis

2015-02-03 14:41:26 -0700

[diff] [blame]

1099

hf_body.append(' ppOutNext = (XGL_UPDATE_SAMPLERS**)&(*ppOutNow)->pNext;')

1100

hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')

1101

hf_body.append(' break;')

1102

hf_body.append(' }')

1103

hf_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:')

1104

hf_body.append(' {')

1105

hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_UPDATE_IMAGES), pInNow);')

Jon Ashburn

2015-02-03 17:47:58 -0700

[diff] [blame]

1106

hf_body.append(' XGL_UPDATE_IMAGES* pPacket = (XGL_UPDATE_IMAGES*)*ppOutNow;')

Jon Ashburn

2015-02-04 16:26:30 -0700

[diff] [blame]

1107

hf_body.append(' uint32_t i;')

1108

hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void **) &pPacket->pImageViews, ((XGL_UPDATE_IMAGES*)pInNow)->count * sizeof(XGL_IMAGE_VIEW_ATTACH_INFO *), ((XGL_UPDATE_IMAGES*)pInNow)->pImageViews);')

1109

hf_body.append(' for (i = 0; i < ((XGL_UPDATE_IMAGES*)pInNow)->count; i++) {')

1110

hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void **) &pPacket->pImageViews[i], sizeof(XGL_IMAGE_VIEW_ATTACH_INFO), ((XGL_UPDATE_IMAGES*)pInNow)->pImageViews[i]);')

1111

hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pImageViews[i]));')

1112

hf_body.append(' }')

Tobin Ehlis

2015-02-03 14:41:26 -0700

[diff] [blame]

1113

hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pImageViews));')

1114

hf_body.append(' ppOutNext = (XGL_UPDATE_SAMPLERS**)&(*ppOutNow)->pNext;')

1115

hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')

1116

hf_body.append(' break;')

1117

hf_body.append(' }')

1118

hf_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:')

1119

hf_body.append(' {')

1120

hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_UPDATE_BUFFERS), pInNow);')

Jon Ashburn

2015-02-03 17:47:58 -0700

[diff] [blame]

1121

hf_body.append(' XGL_UPDATE_BUFFERS* pPacket = (XGL_UPDATE_BUFFERS*)*ppOutNow;')

Jon Ashburn

2015-02-04 16:26:30 -0700

[diff] [blame]

1122

hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void **) &pPacket->pBufferViews, ((XGL_UPDATE_BUFFERS*)pInNow)->count * sizeof(XGL_BUFFER_VIEW_ATTACH_INFO *), ((XGL_UPDATE_BUFFERS*)pInNow)->pBufferViews);')

1123

hf_body.append(' uint32_t i;')

1124

hf_body.append(' for (i = 0; i < ((XGL_UPDATE_BUFFERS*)pInNow)->count; i++) {')

1125

hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void **) &pPacket->pBufferViews[i], sizeof(XGL_BUFFER_VIEW_ATTACH_INFO), ((XGL_UPDATE_BUFFERS*)pInNow)->pBufferViews[i]);')

1126

hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pBufferViews[i]));')

1127

hf_body.append(' }')

Tobin Ehlis

2015-02-03 14:41:26 -0700

[diff] [blame]

1128

hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pBufferViews));')

1129

hf_body.append(' ppOutNext = (XGL_UPDATE_SAMPLERS**)&(*ppOutNow)->pNext;')

1130

hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')

1131

hf_body.append(' break;')

1132

hf_body.append(' }')

1133

hf_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:')

1134

hf_body.append(' {')

1135

hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_UPDATE_AS_COPY), pInNow);')

1136

hf_body.append(' ppOutNext = (XGL_UPDATE_SAMPLERS**)&(*ppOutNow)->pNext;')

1137

hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')

1138

hf_body.append(' break;')

1139

hf_body.append(' }')

1140

hf_body.append(' default:')

1141

hf_body.append(' assert(0);')

1142

hf_body.append(' }')

1143

hf_body.append(' pInNow = (XGL_UPDATE_SAMPLERS*)pInNow->pNext;')

1144

hf_body.append(' }')

1145

hf_body.append(' return;')

1146

hf_body.append('}')

1147

hf_body.append('')

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

1148

hf_body.append('static size_t calculate_pipeline_state_size(const void* pState)')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

1149

hf_body.append('{')

1150

hf_body.append(' const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pNext = pState;')

1151

hf_body.append(' size_t totalStateSize = 0;')

1152

hf_body.append(' while (pNext)')

1153

hf_body.append(' {')

1154

hf_body.append(' switch (pNext->sType)')

1155

hf_body.append(' {')

Tobin Ehlis

2015-01-15 17:53:54 -0700

[diff] [blame]

1156

pipe_state_list = ['IA_STATE_CREATE_INFO',

1157

'TESS_STATE_CREATE_INFO',

1158

'RS_STATE_CREATE_INFO',

1159

'DS_STATE_CREATE_INFO',

Tobin Ehlis

2015-01-15 17:53:54 -0700

[diff] [blame]

1160

'VP_STATE_CREATE_INFO',

1161

'MS_STATE_CREATE_INFO'

1162

]

1163

for pipe_state in pipe_state_list:

1164

hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_%s:' % pipe_state)

1165

hf_body.append(' totalStateSize += sizeof(XGL_PIPELINE_%s);' % pipe_state)

1166

hf_body.append(' break;')

Jon Ashburn

2015-02-03 17:47:58 -0700

[diff] [blame]

1167

hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:')

1168

hf_body.append(' {')

1169

hf_body.append(' totalStateSize += (sizeof(XGL_PIPELINE_CB_STATE_CREATE_INFO) + ((XGL_PIPELINE_CB_STATE_CREATE_INFO *) pNext)->attachmentCount * sizeof(XGL_PIPELINE_CB_ATTACHMENT_STATE));')

1170

hf_body.append(' break;')

1171

hf_body.append(' }')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

1172

hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:')

1173

hf_body.append(' {')

1174

hf_body.append(' const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pShaderStage = (const XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pNext;')

1175

hf_body.append(' totalStateSize += (sizeof(XGL_PIPELINE_SHADER_STAGE_CREATE_INFO) + calculate_pipeline_shader_size(&pShaderStage->shader));')

1176

hf_body.append(' break;')

1177

hf_body.append(' }')

1178

hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:')

1179

hf_body.append(' {')

1180

hf_body.append(' const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO* pVi = (const XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO*)pNext;')

1181

hf_body.append(' totalStateSize += sizeof(XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO) + pVi->bindingCount * sizeof(XGL_VERTEX_INPUT_BINDING_DESCRIPTION)')

1182

hf_body.append(' + pVi->attributeCount * sizeof(XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION);')

1183

hf_body.append(' break;')

1184

hf_body.append(' }')

1185

hf_body.append(' default:')

1186

hf_body.append(' assert(0);')

1187

hf_body.append(' }')

1188

hf_body.append(' pNext = (XGL_GRAPHICS_PIPELINE_CREATE_INFO*)pNext->pNext;')

1189

hf_body.append(' }')

1190

hf_body.append(' return totalStateSize;')

1191

hf_body.append('}')

1192

hf_body.append('')

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

1193

hf_body.append('static void add_pipeline_state_to_trace_packet(glv_trace_packet_header* pHeader, void** ppOut, const void* pIn)')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

1194

hf_body.append('{')

1195

hf_body.append(' const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pInNow = pIn;')

1196

hf_body.append(' XGL_GRAPHICS_PIPELINE_CREATE_INFO** ppOutNext = (XGL_GRAPHICS_PIPELINE_CREATE_INFO**)ppOut;')

1197

hf_body.append(' while (pInNow != NULL)')

1198

hf_body.append(' {')

1199

hf_body.append(' XGL_GRAPHICS_PIPELINE_CREATE_INFO** ppOutNow = ppOutNext;')

1200

hf_body.append(' ppOutNext = NULL;')

1201

hf_body.append('')

1202

hf_body.append(' switch (pInNow->sType)')

1203

hf_body.append(' {')

Tobin Ehlis

2015-01-15 17:53:54 -0700

[diff] [blame]

1204

for pipe_state in pipe_state_list:

1205

hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_%s:' % pipe_state)

1206

hf_body.append(' {')

1207

hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_PIPELINE_%s), pInNow);' % pipe_state)

1208

hf_body.append(' ppOutNext = (XGL_GRAPHICS_PIPELINE_CREATE_INFO**)&(*ppOutNow)->pNext;')

1209

hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')

1210

hf_body.append(' break;')

1211

hf_body.append(' }')

Jon Ashburn

2015-02-03 17:47:58 -0700

[diff] [blame]

1212

hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:')

1213

hf_body.append(' {')

1214

hf_body.append(' XGL_PIPELINE_CB_STATE_CREATE_INFO *pPacket = NULL;')

1215

hf_body.append(' XGL_PIPELINE_CB_STATE_CREATE_INFO *pIn = NULL;')

1216

hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_PIPELINE_CB_STATE_CREATE_INFO), pInNow);')

1217

hf_body.append(' pPacket = (XGL_PIPELINE_CB_STATE_CREATE_INFO*) *ppOutNow;')

1218

hf_body.append(' pIn = (XGL_PIPELINE_CB_STATE_CREATE_INFO*) pInNow;')

1219

hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void **) &pPacket->pAttachments, pIn->attachmentCount * sizeof(XGL_PIPELINE_CB_ATTACHMENT_STATE), pIn->pAttachments);')

1220

hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pAttachments));')

1221

hf_body.append(' ppOutNext = (XGL_GRAPHICS_PIPELINE_CREATE_INFO**)&(*ppOutNow)->pNext;')

1222

hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')

1223

hf_body.append(' break;')

1224

hf_body.append(' }')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

1225

hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:')

1226

hf_body.append(' {')

1227

hf_body.append(' XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pPacket = NULL;')

1228

hf_body.append(' XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pInPacket = NULL;')

1229

hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_PIPELINE_SHADER_STAGE_CREATE_INFO), pInNow);')

1230

hf_body.append(' pPacket = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*) *ppOutNow;')

1231

hf_body.append(' pInPacket = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*) pInNow;')

1232

hf_body.append(' add_pipeline_shader_to_trace_packet(pHeader, &pPacket->shader, &pInPacket->shader);')

1233

hf_body.append(' finalize_pipeline_shader_address(pHeader, &pPacket->shader);')

1234

hf_body.append(' ppOutNext = (XGL_GRAPHICS_PIPELINE_CREATE_INFO**)&(*ppOutNow)->pNext;')

1235

hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')

1236

hf_body.append(' break;')

1237

hf_body.append(' }')

1238

hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:')

1239

hf_body.append(' {')

1240

hf_body.append(' XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO *pPacket = NULL;')

1241

hf_body.append(' XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO *pIn = NULL;')

1242

hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(ppOutNow), sizeof(XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO), pInNow);')

1243

hf_body.append(' pPacket = (XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO*) *ppOutNow;')

1244

hf_body.append(' pIn = (XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO*) pInNow;')

1245

hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void **) &pPacket->pVertexBindingDescriptions, pIn->bindingCount * sizeof(XGL_VERTEX_INPUT_BINDING_DESCRIPTION), pIn->pVertexBindingDescriptions);')

1246

hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pVertexBindingDescriptions));')

1247

hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void **) &pPacket->pVertexAttributeDescriptions, pIn->attributeCount * sizeof(XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION), pIn->pVertexAttributeDescriptions);')

1248

hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pVertexAttributeDescriptions));')

1249

hf_body.append(' ppOutNext = (XGL_GRAPHICS_PIPELINE_CREATE_INFO**)&(*ppOutNow)->pNext;')

1250

hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)(ppOutNow));')

1251

hf_body.append(' break;')

1252

hf_body.append(' }')

1253

hf_body.append(' default:')

1254

hf_body.append(' assert(!"Encountered an unexpected type in pipeline state list");')

1255

hf_body.append(' }')

1256

hf_body.append(' pInNow = (XGL_GRAPHICS_PIPELINE_CREATE_INFO*)pInNow->pNext;')

1257

hf_body.append(' }')

1258

hf_body.append(' return;')

1259

hf_body.append('}')

1260

return "\n".join(hf_body)

1261

1262

def _generate_packet_id_enum(self):

1263

pid_enum = []

1264

pid_enum.append('enum GLV_TRACE_PACKET_ID_XGL')

1265

pid_enum.append('{')

1266

first_func = True

1267

for proto in self.protos:

1268

if first_func:

1269

first_func = False

Jon Ashburn

2014-12-16 18:37:04 -0700

[diff] [blame]

1270

pid_enum.append(' GLV_TPI_XGL_xglApiVersion = GLV_TPI_BEGIN_API_HERE,')

1271

pid_enum.append(' GLV_TPI_XGL_xgl%s,' % proto.name)

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

1272

else:

1273

pid_enum.append(' GLV_TPI_XGL_xgl%s,' % proto.name)

1274

pid_enum.append('};\n')

1275

return "\n".join(pid_enum)

1276

1277

def _generate_stringify_func(self):

1278

func_body = []

1279

func_body.append('static const char *stringify_xgl_packet_id(const enum GLV_TRACE_PACKET_ID_XGL id, const glv_trace_packet_header* pHeader)')

1280

func_body.append('{')

1281

func_body.append(' static char str[1024];')

1282

func_body.append(' switch(id) {')

Jon Ashburn

2014-12-16 18:37:04 -0700

[diff] [blame]

1283

func_body.append(' case GLV_TPI_XGL_xglApiVersion:')

1284

func_body.append(' {')

1285

func_body.append(' struct_xglApiVersion* pPacket = (struct_xglApiVersion*)(pHeader->pBody);')

1286

func_body.append(' snprintf(str, 1024, "xglApiVersion = 0x%x", pPacket->version);')

1287

func_body.append(' return str;')

1288

func_body.append(' }')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

1289

for proto in self.protos:

1290

func_body.append(' case GLV_TPI_XGL_xgl%s:' % proto.name)

1291

func_body.append(' {')

1292

func_str = 'xgl%s(' % proto.name

1293

print_vals = ''

1294

create_func = False

1295

if 'Create' in proto.name or 'Alloc' in proto.name or 'MapMemory' in proto.name:

1296

create_func = True

1297

for p in proto.params:

1298

last_param = False

1299

if (p.name == proto.params[-1].name):

1300

last_param = True

1301

if last_param and create_func: # last param of create func

1302

(pft, pfi) = self._get_printf_params(p.ty,'pPacket->%s' % p.name, True)

1303

else:

1304

(pft, pfi) = self._get_printf_params(p.ty, 'pPacket->%s' % p.name, False)

1305

if last_param == True:

1306

func_str += '%s = %s)' % (p.name, pft)

1307

print_vals += ', %s' % (pfi)

1308

else:

1309

func_str += '%s = %s, ' % (p.name, pft)

1310

print_vals += ', %s' % (pfi)

1311

func_body.append(' struct_xgl%s* pPacket = (struct_xgl%s*)(pHeader->pBody);' % (proto.name, proto.name))

1312

func_body.append(' snprintf(str, 1024, "%s"%s);' % (func_str, print_vals))

1313

func_body.append(' return str;')

1314

func_body.append(' }')

1315

func_body.append(' default:')

1316

func_body.append(' return NULL;')

1317

func_body.append(' }')

1318

func_body.append('};\n')

1319

return "\n".join(func_body)

1320

1321

def _generate_interp_func(self):

1322

interp_func_body = []

1323

interp_func_body.append('static glv_trace_packet_header* interpret_trace_packet_xgl(glv_trace_packet_header* pHeader)')

1324

interp_func_body.append('{')

1325

interp_func_body.append(' if (pHeader == NULL)')

1326

interp_func_body.append(' {')

1327

interp_func_body.append(' return NULL;')

1328

interp_func_body.append(' }')

1329

interp_func_body.append(' switch (pHeader->packet_id)')

1330

interp_func_body.append(' {')

Jon Ashburn

2014-12-16 18:37:04 -0700

[diff] [blame]

1331

interp_func_body.append(' case GLV_TPI_XGL_xglApiVersion:\n {')

1332

interp_func_body.append(' return interpret_body_as_xglApiVersion(pHeader, TRUE)->header;\n }')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

1333

for proto in self.protos:

1334

interp_func_body.append(' case GLV_TPI_XGL_xgl%s:\n {' % proto.name)

1335

header_prefix = 'h'

1336

if 'Wsi' in proto.name or 'Dbg' in proto.name:

1337

header_prefix = 'pH'

1338

interp_func_body.append(' return interpret_body_as_xgl%s(pHeader)->%seader;\n }' % (proto.name, header_prefix))

1339

interp_func_body.append(' default:')

1340

interp_func_body.append(' return NULL;')

1341

interp_func_body.append(' }')

1342

interp_func_body.append(' return NULL;')

1343

interp_func_body.append('}')

1344

return "\n".join(interp_func_body)

1345

1346

def _generate_struct_util_funcs(self):

1347

pid_enum = []

1348

pid_enum.append('//=============================================================================')

1349

pid_enum.append('static uint64_t calc_size_XGL_APPLICATION_INFO(const XGL_APPLICATION_INFO* pStruct)')

1350

pid_enum.append('{')

Chia-I Wu

2014-12-27 15:16:07 +0800

[diff] [blame]

1351

pid_enum.append(' return ((pStruct == NULL) ? 0 : sizeof(XGL_APPLICATION_INFO)) + strlen(pStruct->pAppName) + 1 + strlen(pStruct->pEngineName) + 1;')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

1352

pid_enum.append('}\n')

1353

pid_enum.append('static void add_XGL_APPLICATION_INFO_to_packet(glv_trace_packet_header* pHeader, XGL_APPLICATION_INFO** ppStruct, const XGL_APPLICATION_INFO *pInStruct)')

1354

pid_enum.append('{')

1355

pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)ppStruct, sizeof(XGL_APPLICATION_INFO), pInStruct);')

Chia-I Wu

2014-12-27 15:16:07 +0800

[diff] [blame]

1356

pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&((*ppStruct)->pAppName), strlen(pInStruct->pAppName) + 1, pInStruct->pAppName);')

1357

pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&((*ppStruct)->pEngineName), strlen(pInStruct->pEngineName) + 1, pInStruct->pEngineName);')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

1358

pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)&((*ppStruct)->pAppName));')

1359

pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)&((*ppStruct)->pEngineName));')

1360

pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)&*ppStruct);')

1361

pid_enum.append('};\n')

1362

pid_enum.append('//=============================================================================\n')

1363

pid_enum.append('static uint64_t calc_size_XGL_DEVICE_CREATE_INFO(const XGL_DEVICE_CREATE_INFO* pStruct)')

1364

pid_enum.append('{')

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

1365

pid_enum.append(' uint64_t total_size_ppEnabledExtensionNames = pStruct->extensionCount * sizeof(char *);')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

1366

pid_enum.append(' uint32_t i;')

1367

pid_enum.append(' for (i = 0; i < pStruct->extensionCount; i++)')

1368

pid_enum.append(' {')

Chia-I Wu

2014-12-27 15:16:07 +0800

[diff] [blame]

1369

pid_enum.append(' total_size_ppEnabledExtensionNames += strlen(pStruct->ppEnabledExtensionNames[i]) + 1;')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

1370

pid_enum.append(' }')

Jon Ashburn

2015-01-09 17:30:41 -0700

[diff] [blame]

1371

pid_enum.append(' uint64_t total_size_layers = 0;')

1372

pid_enum.append(' XGL_LAYER_CREATE_INFO *pNext = ( XGL_LAYER_CREATE_INFO *) pStruct->pNext;')

1373

pid_enum.append(' while (pNext != NULL)')

1374

pid_enum.append(' {')

1375

pid_enum.append(' if ((pNext->sType == XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO) && pNext->layerCount > 0)')

1376

pid_enum.append(' {')

1377

pid_enum.append(' total_size_layers += sizeof(XGL_LAYER_CREATE_INFO);')

1378

pid_enum.append(' for (i = 0; i < pNext->layerCount; i++)')

1379

pid_enum.append(' {')

1380

pid_enum.append(' total_size_layers += strlen(pNext->ppActiveLayerNames[i]) + 1;')

1381

pid_enum.append(' }')

1382

pid_enum.append(' }')

1383

pid_enum.append(' pNext = ( XGL_LAYER_CREATE_INFO *) pNext->pNext;')

1384

pid_enum.append(' }')

1385

pid_enum.append(' return sizeof(XGL_DEVICE_CREATE_INFO) + (pStruct->queueRecordCount*sizeof(XGL_DEVICE_CREATE_INFO)) + total_size_ppEnabledExtensionNames + total_size_layers;')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

1386

pid_enum.append('}\n')

1387

pid_enum.append('static void add_XGL_DEVICE_CREATE_INFO_to_packet(glv_trace_packet_header* pHeader, XGL_DEVICE_CREATE_INFO** ppStruct, const XGL_DEVICE_CREATE_INFO *pInStruct)')

1388

pid_enum.append('{')

1389

pid_enum.append(' uint32_t i;')

1390

pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)ppStruct, sizeof(XGL_DEVICE_CREATE_INFO), pInStruct);')

1391

pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(*ppStruct)->pRequestedQueues, pInStruct->queueRecordCount*sizeof(XGL_DEVICE_CREATE_INFO), pInStruct->pRequestedQueues);')

1392

pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)&(*ppStruct)->pRequestedQueues);')

1393

pid_enum.append(' if (pInStruct->extensionCount > 0) ')

1394

pid_enum.append(' {')

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

1395

pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(&(*ppStruct)->ppEnabledExtensionNames), pInStruct->extensionCount * sizeof(char *), pInStruct->ppEnabledExtensionNames);')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

1396

pid_enum.append(' for (i = 0; i < pInStruct->extensionCount; i++)')

1397

pid_enum.append(' {')

Chia-I Wu

2014-12-27 15:16:07 +0800

[diff] [blame]

1398

pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(&((*ppStruct)->ppEnabledExtensionNames[i])), strlen(pInStruct->ppEnabledExtensionNames[i]) + 1, pInStruct->ppEnabledExtensionNames[i]);')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

1399

pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)(&((*ppStruct)->ppEnabledExtensionNames[i])));')

1400

pid_enum.append(' }')

1401

pid_enum.append(' glv_finalize_buffer_address(pHeader, (void **)&(*ppStruct)->ppEnabledExtensionNames);')

1402

pid_enum.append(' }')

Jon Ashburn

2015-01-09 17:30:41 -0700

[diff] [blame]

1403

pid_enum.append(' XGL_LAYER_CREATE_INFO *pNext = ( XGL_LAYER_CREATE_INFO *) pInStruct->pNext;')

1404

pid_enum.append(' while (pNext != NULL)')

1405

pid_enum.append(' {')

1406

pid_enum.append(' if ((pNext->sType == XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO) && pNext->layerCount > 0)')

1407

pid_enum.append(' {')

1408

pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(&((*ppStruct)->pNext)), sizeof(XGL_LAYER_CREATE_INFO), pNext);')

1409

pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)(&((*ppStruct)->pNext)));')

1410

pid_enum.append(' XGL_LAYER_CREATE_INFO **ppOutStruct = (XGL_LAYER_CREATE_INFO **) &((*ppStruct)->pNext);')

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

1411

pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(&(*ppOutStruct)->ppActiveLayerNames), pNext->layerCount * sizeof(char *), pNext->ppActiveLayerNames);')

Jon Ashburn

2015-01-09 17:30:41 -0700

[diff] [blame]

1412

pid_enum.append(' for (i = 0; i < pNext->layerCount; i++)')

1413

pid_enum.append(' {')

1414

pid_enum.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)(&((*ppOutStruct)->ppActiveLayerNames[i])), strlen(pNext->ppActiveLayerNames[i]) + 1, pNext->ppActiveLayerNames[i]);')

1415

pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)(&((*ppOutStruct)->ppActiveLayerNames[i])));')

1416

pid_enum.append(' }')

1417

pid_enum.append(' glv_finalize_buffer_address(pHeader, (void **)&(*ppOutStruct)->ppActiveLayerNames);')

1418

pid_enum.append(' }')

1419

pid_enum.append(' pNext = ( XGL_LAYER_CREATE_INFO *) pNext->pNext;')

1420

pid_enum.append(' }')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

1421

pid_enum.append(' glv_finalize_buffer_address(pHeader, (void**)ppStruct);')

1422

pid_enum.append('}\n')

1423

pid_enum.append('static XGL_DEVICE_CREATE_INFO* interpret_XGL_DEVICE_CREATE_INFO(glv_trace_packet_header* pHeader, intptr_t ptr_variable)')

1424

pid_enum.append('{')

1425

pid_enum.append(' XGL_DEVICE_CREATE_INFO* pXGL_DEVICE_CREATE_INFO = (XGL_DEVICE_CREATE_INFO*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)ptr_variable);\n')

1426

pid_enum.append(' if (pXGL_DEVICE_CREATE_INFO != NULL)')

1427

pid_enum.append(' {')

Jon Ashburn

2015-01-09 17:30:41 -0700

[diff] [blame]

1428

pid_enum.append(' uint32_t i;')

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

1429

pid_enum.append(' const char** pNames;')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

1430

pid_enum.append(' pXGL_DEVICE_CREATE_INFO->pRequestedQueues = (const XGL_DEVICE_QUEUE_CREATE_INFO*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pXGL_DEVICE_CREATE_INFO->pRequestedQueues);\n')

1431

pid_enum.append(' if (pXGL_DEVICE_CREATE_INFO->extensionCount > 0)')

1432

pid_enum.append(' {')

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

1433

pid_enum.append(' pXGL_DEVICE_CREATE_INFO->ppEnabledExtensionNames = (const char *const*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pXGL_DEVICE_CREATE_INFO->ppEnabledExtensionNames);')

1434

pid_enum.append(' pNames = (const char**)pXGL_DEVICE_CREATE_INFO->ppEnabledExtensionNames;')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

1435

pid_enum.append(' for (i = 0; i < pXGL_DEVICE_CREATE_INFO->extensionCount; i++)')

1436

pid_enum.append(' {')

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

1437

pid_enum.append(' pNames[i] = (const char*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)(pXGL_DEVICE_CREATE_INFO->ppEnabledExtensionNames[i]));')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

1438

pid_enum.append(' }')

1439

pid_enum.append(' }')

Jon Ashburn

2015-01-09 17:30:41 -0700

[diff] [blame]

1440

pid_enum.append(' XGL_LAYER_CREATE_INFO *pNext = ( XGL_LAYER_CREATE_INFO *) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pXGL_DEVICE_CREATE_INFO->pNext);')

1441

pid_enum.append(' while (pNext != NULL)')

1442

pid_enum.append(' {')

1443

pid_enum.append(' if ((pNext->sType == XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO) && pNext->layerCount > 0)')

1444

pid_enum.append(' {')

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

1445

pid_enum.append(' pNext->ppActiveLayerNames = (const char**) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)(pNext->ppActiveLayerNames));')

1446

pid_enum.append(' pNames = (const char**)pNext->ppActiveLayerNames;')

Jon Ashburn

2015-01-09 17:30:41 -0700

[diff] [blame]

1447

pid_enum.append(' for (i = 0; i < pNext->layerCount; i++)')

1448

pid_enum.append(' {')

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

1449

pid_enum.append(' pNames[i] = (const char*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)(pNext->ppActiveLayerNames[i]));')

Jon Ashburn

2015-01-09 17:30:41 -0700

[diff] [blame]

1450

pid_enum.append(' }')

1451

pid_enum.append(' }')

1452

pid_enum.append(' pNext = ( XGL_LAYER_CREATE_INFO *) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);')

1453

pid_enum.append(' }')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

1454

pid_enum.append(' }\n')

1455

pid_enum.append(' return pXGL_DEVICE_CREATE_INFO;')

1456

pid_enum.append('}\n')

1457

pid_enum.append('static void interpret_pipeline_shader(glv_trace_packet_header* pHeader, XGL_PIPELINE_SHADER* pShader)')

1458

pid_enum.append('{')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

1459

pid_enum.append(' if (pShader != NULL)')

1460

pid_enum.append(' {')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

1461

pid_enum.append(' // constant buffers')

1462

pid_enum.append(' if (pShader->linkConstBufferCount > 0)')

1463

pid_enum.append(' {')

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

1464

pid_enum.append(' uint32_t i;')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

1465

pid_enum.append(' pShader->pLinkConstBufferInfo = (const XGL_LINK_CONST_BUFFER*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pShader->pLinkConstBufferInfo);')

1466

pid_enum.append(' for (i = 0; i < pShader->linkConstBufferCount; i++)')

1467

pid_enum.append(' {')

1468

pid_enum.append(' XGL_LINK_CONST_BUFFER* pBuffer = (XGL_LINK_CONST_BUFFER*)pShader->pLinkConstBufferInfo;')

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

1469

pid_enum.append(' pBuffer[i].pBufferData = (const void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pShader->pLinkConstBufferInfo[i].pBufferData);')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

1470

pid_enum.append(' }')

1471

pid_enum.append(' }')

1472

pid_enum.append(' }')

1473

pid_enum.append('}\n')

1474

pid_enum.append('//=============================================================================')

1475

return "\n".join(pid_enum)

1476

Tobin Ehlis

2015-02-05 11:29:45 -0700

[diff] [blame]

1477

# Interpret functions used on replay to read in packets and interpret their contents

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

1478

def _generate_interp_funcs(self):

1479

# Custom txt for given function and parameter. First check if param is NULL, then insert txt if not

Tobin Ehlis

2015-02-05 11:29:45 -0700

[diff] [blame]

1480

# TODO : This code is now too large and complex, need to make codegen smarter for pointers embedded in struct params to handle those cases automatically

Tobin Ehlis

2015-01-16 15:13:34 -0700

[diff] [blame]

1481

custom_case_dict = { 'CreateInstance' : {'param': 'pAppInfo', 'txt': ['XGL_APPLICATION_INFO* pInfo = (XGL_APPLICATION_INFO*)pPacket->pAppInfo;\n',

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

1482

'pInfo->pAppName = (const char*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pAppInfo->pAppName);\n',

1483

'pInfo->pEngineName = (const char*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pAppInfo->pEngineName);']},

Jon Ashburn

2015-01-02 18:28:26 -0700

[diff] [blame]

1484

'CreateShader' : {'param': 'pCreateInfo', 'txt': ['XGL_SHADER_CREATE_INFO* pInfo = (XGL_SHADER_CREATE_INFO*)pPacket->pCreateInfo;\n',

1485

'pInfo->pCode = glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pCode);']},

Jon Ashburn

2015-02-04 08:50:35 -0700

[diff] [blame]

1486

'CreateDynamicViewportState' : {'param': 'pCreateInfo', 'txt': ['XGL_DYNAMIC_VP_STATE_CREATE_INFO* pInfo = (XGL_DYNAMIC_VP_STATE_CREATE_INFO*)pPacket->pCreateInfo;\n',

1487

'pInfo->pViewports = (XGL_VIEWPORT*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pViewports);\n',

1488

'pInfo->pScissors = (XGL_RECT*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pScissors);']},

Jon Ashburn

2015-01-02 18:28:26 -0700

[diff] [blame]

1489

'CreateFramebuffer' : {'param': 'pCreateInfo', 'txt': ['XGL_FRAMEBUFFER_CREATE_INFO* pInfo = (XGL_FRAMEBUFFER_CREATE_INFO*)pPacket->pCreateInfo;\n',

1490

'pInfo->pColorAttachments = (XGL_COLOR_ATTACHMENT_BIND_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pColorAttachments);\n',

1491

'pInfo->pDepthStencilAttachment = (XGL_DEPTH_STENCIL_BIND_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pDepthStencilAttachment);\n']},

1492

'CreateRenderPass' : {'param': 'pCreateInfo', 'txt': ['XGL_RENDER_PASS_CREATE_INFO* pInfo = (XGL_RENDER_PASS_CREATE_INFO*)pPacket->pCreateInfo;\n',

1493

'pInfo->pColorLoadOps = (XGL_ATTACHMENT_LOAD_OP*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pColorLoadOps);\n',

1494

'pInfo->pColorStoreOps = (XGL_ATTACHMENT_STORE_OP*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pColorStoreOps);\n',

1495

'pInfo->pColorLoadClearValues = (XGL_CLEAR_COLOR*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pColorLoadClearValues);\n']},

Jon Ashburn

2015-02-04 09:32:59 -0700

[diff] [blame]

1496

'CreateDescriptorRegion' : {'param': 'pCreateInfo', 'txt': ['XGL_DESCRIPTOR_REGION_CREATE_INFO* pInfo = (XGL_DESCRIPTOR_REGION_CREATE_INFO*)pPacket->pCreateInfo;\n',

1497

'pInfo->pTypeCount = (XGL_DESCRIPTOR_TYPE_COUNT*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pTypeCount);\n']},

Tobin Ehlis

2015-02-05 11:29:45 -0700

[diff] [blame]

1498

'CmdWaitEvents' : {'param': 'pWaitInfo', 'txt': ['XGL_EVENT_WAIT_INFO* pInfo = (XGL_EVENT_WAIT_INFO*)pPacket->pWaitInfo;\n',

1499

'pInfo->pEvents = (XGL_EVENT*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pWaitInfo->pEvents);\n',

1500

'pInfo->ppMemBarriers = (const void**) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pWaitInfo->ppMemBarriers);\n',

1501

'uint32_t i;\n',

1502

'for (i = 0; i < pInfo->memBarrierCount; i++) {\n',

1503

' void** ppLocalMemBarriers = (void**)&pInfo->ppMemBarriers[i];\n',

1504

' *ppLocalMemBarriers = (void*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pInfo->ppMemBarriers[i]);\n',

1505

'}']},

1506

'CmdPipelineBarrier' : {'param': 'pBarrier', 'txt': ['XGL_PIPELINE_BARRIER* pBarrier = (XGL_PIPELINE_BARRIER*)pPacket->pBarrier;\n',

1507

'pBarrier->pEvents = (XGL_SET_EVENT*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pBarrier->pEvents);\n',

1508

'pBarrier->ppMemBarriers = (const void**) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pBarrier->ppMemBarriers);\n',

1509

'uint32_t i;\n',

1510

'for (i = 0; i < pBarrier->memBarrierCount; i++) {\n',

1511

' void** ppLocalMemBarriers = (void**)&pBarrier->ppMemBarriers[i];\n',

1512

' *ppLocalMemBarriers = (void*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pBarrier->ppMemBarriers[i]);\n',

1513

'}']},

Jon Ashburn

7fd7eff

2015-02-04 10:55:47 -0700

[diff] [blame]

1514

'CreateDescriptorSetLayout' : {'param': 'pSetLayoutInfoList', 'txt': ['assert(pPacket->pSetLayoutInfoList->sType == XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO);\n',

1515

'// need to make a non-const pointer to the pointer so that we can properly change the original pointer to the interpretted one\n',

1516

'void** ppNextVoidPtr = (void**)&(pPacket->pSetLayoutInfoList->pNext);\n',

1517

'*ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pSetLayoutInfoList->pNext);\n',

1518

'XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pNext = (XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO*)pPacket->pSetLayoutInfoList->pNext;\n',

1519

'while (NULL != pNext)\n', '{\n',

1520

' switch(pNext->sType)\n', ' {\n',

1521

' case XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO:\n',

1522

' {\n',

1523

' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',

1524

' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',

' break;\n',

' }\n',

' default:\n',

' assert(!"Encountered an unexpected type in descriptor set layout create list");\n',

1529

' }\n',

1530

' pNext = (XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO*)pNext->pNext;\n',

1531

'}']},

Jon Ashburn

2015-01-02 18:28:26 -0700

[diff] [blame]

1532

'BeginCommandBuffer' : {'param': 'pBeginInfo', 'txt': ['assert(pPacket->pBeginInfo->sType == XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO);\n',

1533

'// need to make a non-const pointer to the pointer so that we can properly change the original pointer to the interpretted one\n',

Jon Ashburn

2015-02-03 07:33:48 -0700

[diff] [blame]

1534

'void** ppNextVoidPtr = (void**)&(pPacket->pBeginInfo->pNext);\n',

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

1535

'*ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pBeginInfo->pNext);\n',

Jon Ashburn

2015-01-02 18:28:26 -0700

[diff] [blame]

1536

'XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pNext = (XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO*)pPacket->pBeginInfo->pNext;\n',

Jon Ashburn

7fd7eff

2015-02-04 10:55:47 -0700

[diff] [blame]

1537

'while (NULL != pNext)\n', '{\n',

Jon Ashburn

2015-01-02 18:28:26 -0700

[diff] [blame]

1538

' switch(pNext->sType)\n', ' {\n',

1539

' case XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO:\n',

1540

' {\n',

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

1541

' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',

1542

' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',

Jon Ashburn

2015-01-02 18:28:26 -0700

[diff] [blame]

' break;\n',

' }\n',

' default:\n',

' assert(!"Encountered an unexpected type in begin command buffer list");\n',

1547

' }\n',

1548

' pNext = (XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO*)pNext->pNext;\n',

1549

'}']},

Jon Ashburn

2015-02-03 07:33:48 -0700

[diff] [blame]

1550

'AllocMemory' : {'param': 'pAllocInfo', 'txt': ['assert(pPacket->pAllocInfo->sType == XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO);\n',

1551

'XGL_MEMORY_ALLOC_INFO* pNext = (XGL_MEMORY_ALLOC_INFO*) pPacket->pAllocInfo->pNext;\n',

1552

'XGL_MEMORY_ALLOC_INFO** ppNext = (XGL_MEMORY_ALLOC_INFO**) &(pPacket->pAllocInfo->pNext);\n',

1553

'while (NULL != pNext)\n', '{\n',

Jon Ashburn

c8d73f1

2015-02-05 16:48:13 -0700

[diff] [blame]

1554

' *ppNext = (XGL_MEMORY_ALLOC_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext);\n',

Jon Ashburn

2015-02-03 07:33:48 -0700

[diff] [blame]

1555

' pNext = *ppNext;\n',

1556

' switch(pNext->sType)\n', ' {\n',

1557

' case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO:\n',

1558

' case XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO:\n',

1559

' {\n',

1560

' ppNext = (XGL_MEMORY_ALLOC_INFO **) &(pNext->pNext);\n',

Tobin Ehlis

c1afba0

2015-02-06 12:21:42 -0700

[diff] [blame]

1561

' *ppNext = (XGL_MEMORY_ALLOC_INFO*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',

Jon Ashburn

2015-02-03 07:33:48 -0700

[diff] [blame]

' break;\n',

' }\n',

' default:\n',

' assert(!"Encountered an unexpected type in alloc memory list");\n',

1566

' }\n',

1567

' pNext = (XGL_MEMORY_ALLOC_INFO*)pNext->pNext;\n',

1568

'}']},

Tobin Ehlis

9570fc4

2015-02-04 10:53:31 -0700

[diff] [blame]

1569

'UpdateDescriptors' : {'param': 'pUpdateChain', 'txt': ['XGL_UPDATE_SAMPLERS* pNext = (XGL_UPDATE_SAMPLERS*)pPacket->pUpdateChain;\n',

1570

'while ((NULL != pNext) && (XGL_NULL_HANDLE != pNext))\n', '{\n',

1571

' switch(pNext->sType)\n', ' {\n',

1572

' case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:\n',

1573

' {\n',

1574

' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',

1575

' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',

1576

' break;\n',

1577

' }\n',

1578

' case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:\n',

1579

' {\n',

1580

' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',

1581

' XGL_UPDATE_SAMPLERS* pUS = (XGL_UPDATE_SAMPLERS*)pNext;\n',

1582

' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',

1583

' pUS->pSamplers = (XGL_SAMPLER*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pUS->pSamplers);\n',

1584

' break;\n',

1585

' }\n',

1586

' case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:\n',

1587

' {\n',

1588

' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',

1589

' XGL_UPDATE_SAMPLER_TEXTURES* pUST = (XGL_UPDATE_SAMPLER_TEXTURES*)pNext;\n',

1590

' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',

1591

' pUST->pSamplerImageViews = (XGL_SAMPLER_IMAGE_VIEW_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pUST->pSamplerImageViews);\n',

1592

' uint32_t i;\n',

1593

' for (i = 0; i < pUST->count; i++) {\n',

1594

' XGL_IMAGE_VIEW_ATTACH_INFO** ppLocalImageView = (XGL_IMAGE_VIEW_ATTACH_INFO**)&pUST->pSamplerImageViews[i].pImageView;\n',

1595

' *ppLocalImageView = (XGL_IMAGE_VIEW_ATTACH_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pUST->pSamplerImageViews[i].pImageView);\n',

' }\n',

' break;\n',

' }\n',

' case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:\n',

1600

' {\n',

1601

' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',

1602

' XGL_UPDATE_IMAGES* pUI = (XGL_UPDATE_IMAGES*)pNext;\n',

1603

' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',

Jon Ashburn

2015-02-04 16:26:30 -0700

[diff] [blame]

1604

' XGL_IMAGE_VIEW_ATTACH_INFO** ppLocalImageView = (XGL_IMAGE_VIEW_ATTACH_INFO**)&pUI->pImageViews;\n',

1605

' *ppLocalImageView = (XGL_IMAGE_VIEW_ATTACH_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pUI->pImageViews);\n',

1606

' uint32_t i;\n',

1607

' for (i = 0; i < pUI->count; i++) {\n',

1608

' XGL_IMAGE_VIEW_ATTACH_INFO** ppLocalImageViews = (XGL_IMAGE_VIEW_ATTACH_INFO**)&pUI->pImageViews[i];\n',

1609

' *ppLocalImageViews = (XGL_IMAGE_VIEW_ATTACH_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pUI->pImageViews[i]);\n',

1610

' }\n',

Tobin Ehlis

9570fc4

2015-02-04 10:53:31 -0700

[diff] [blame]

1611

' break;\n',

1612

' }\n',

1613

' case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:\n',

1614

' {\n',

1615

' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',

1616

' XGL_UPDATE_BUFFERS* pUB = (XGL_UPDATE_BUFFERS*)pNext;\n',

1617

' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',

Jon Ashburn

2015-02-04 16:26:30 -0700

[diff] [blame]

1618

' XGL_BUFFER_VIEW_ATTACH_INFO** ppLocalBufferView = (XGL_BUFFER_VIEW_ATTACH_INFO**)&pUB->pBufferViews;\n',

1619

' *ppLocalBufferView = (XGL_BUFFER_VIEW_ATTACH_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pUB->pBufferViews);\n',

1620

' uint32_t i;\n',

1621

' for (i = 0; i < pUB->count; i++) {\n',

1622

' XGL_BUFFER_VIEW_ATTACH_INFO** ppLocalBufferViews = (XGL_BUFFER_VIEW_ATTACH_INFO**)&pUB->pBufferViews[i];\n',

1623

' *ppLocalBufferViews = (XGL_BUFFER_VIEW_ATTACH_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pUB->pBufferViews[i]);\n',

1624

' }\n',

Tobin Ehlis

9570fc4

2015-02-04 10:53:31 -0700

[diff] [blame]

' break;\n',

' }\n',

' default:\n',

' assert(!"Encountered an unexpected type in update descriptors pUpdateChain");\n',

1629

' }\n',

1630

' pNext = (XGL_UPDATE_SAMPLERS*)pNext->pNext;\n',

1631

'}']},

Jon Ashburn

2015-01-02 18:28:26 -0700

[diff] [blame]

1632

'CreateGraphicsPipeline' : {'param': 'pCreateInfo', 'txt': ['assert(pPacket->pCreateInfo->sType == XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO);\n',

1633

'// need to make a non-const pointer to the pointer so that we can properly change the original pointer to the interpretted one\n',

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

1634

'void** ppNextVoidPtr = (void**)&pPacket->pCreateInfo->pNext;\n',

1635

'*ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pNext);\n',

Jon Ashburn

2015-01-02 18:28:26 -0700

[diff] [blame]

1636

'XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pPacket->pCreateInfo->pNext;\n',

1637

'while ((NULL != pNext) && (XGL_NULL_HANDLE != pNext))\n', '{\n',

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

1638

' switch(pNext->sType)\n', ' {\n',

1639

' case XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO:\n',

1640

' case XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO:\n',

1641

' case XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO:\n',

Tobin Ehlis

2015-01-15 17:53:54 -0700

[diff] [blame]

1642

' case XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO:\n',

1643

' case XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO:\n',

1644

' case XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO:\n',

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

1645

' {\n',

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

1646

' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',

1647

' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

1648

' break;\n',

1649

' }\n',

Jon Ashburn

2015-02-03 17:47:58 -0700

[diff] [blame]

1650

' case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:\n',

1651

' {\n',

1652

' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',

1653

' XGL_PIPELINE_CB_STATE_CREATE_INFO *pCb = (XGL_PIPELINE_CB_STATE_CREATE_INFO *) pNext;\n',

1654

' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',

1655

' pCb->pAttachments = (XGL_PIPELINE_CB_ATTACHMENT_STATE*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pCb->pAttachments);\n',

1656

' break;\n',

1657

' }\n',

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

1658

' case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:\n',

1659

' {\n',

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

1660

' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',

1661

' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',

Tobin Ehlis

2015-01-16 15:13:34 -0700

[diff] [blame]

1662

' interpret_pipeline_shader(pHeader, &pNext->shader);\n',

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

1663

' break;\n',

1664

' }\n',

1665

' case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:\n',

1666

' {\n',

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

1667

' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

1668

' XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO *pVi = (XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO *) pNext;\n',

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

1669

' *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

1670

' pVi->pVertexBindingDescriptions = (XGL_VERTEX_INPUT_BINDING_DESCRIPTION*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVi->pVertexBindingDescriptions);\n',

1671

' pVi->pVertexAttributeDescriptions = (XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVi->pVertexAttributeDescriptions);\n',

' break;\n',

' }\n',

' default:\n',

' assert(!"Encountered an unexpected type in pipeline state list");\n',

1676

' }\n',

1677

' pNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pNext->pNext;\n',

1678

'}']},

Tobin Ehlis

2015-01-16 15:13:34 -0700

[diff] [blame]

1679

'CreateComputePipeline' : {'param': 'pCreateInfo', 'txt': ['interpret_pipeline_shader(pHeader, (XGL_PIPELINE_SHADER*)(&pPacket->pCreateInfo->cs));']}}

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

1680

if_body = []

Jon Ashburn

2014-12-16 18:37:04 -0700

[diff] [blame]

1681

if_body.append('typedef struct struct_xglApiVersion {')

1682

if_body.append(' glv_trace_packet_header* header;')

1683

if_body.append(' uint32_t version;')

1684

if_body.append('} struct_xglApiVersion;\n')

1685

if_body.append('static struct_xglApiVersion* interpret_body_as_xglApiVersion(glv_trace_packet_header* pHeader, BOOL check_version)')

1686

if_body.append('{')

1687

if_body.append(' struct_xglApiVersion* pPacket = (struct_xglApiVersion*)pHeader->pBody;')

1688

if_body.append(' pPacket->header = pHeader;')

1689

if_body.append(' if (check_version && pPacket->version != XGL_API_VERSION)')

1690

if_body.append(' glv_LogError("Trace file from older XGL version 0x%x, xgl replayer built from version 0x%x, replayer may fail\\n", pPacket->version, XGL_API_VERSION);')

1691

if_body.append(' return pPacket;')

1692

if_body.append('}\n')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

1693

for proto in self.protos:

1694

if 'Wsi' not in proto.name and 'Dbg' not in proto.name:

1695

if 'UnmapMemory' == proto.name:

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

1696

proto.params.append(xgl.Param("void*", "pData"))

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

1697

if_body.append('typedef struct struct_xgl%s {' % proto.name)

1698

if_body.append(' glv_trace_packet_header* header;')

1699

for p in proto.params:

1700

if '[4]' in p.ty:

1701

if_body.append(' %s %s[4];' % (p.ty.strip('[4]'), p.name))

1702

else:

1703

if_body.append(' %s %s;' % (p.ty, p.name))

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

1704

if 'void' != proto.ret:

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

1705

if_body.append(' %s result;' % proto.ret)

1706

if_body.append('} struct_xgl%s;\n' % proto.name)

1707

if_body.append('static struct_xgl%s* interpret_body_as_xgl%s(glv_trace_packet_header* pHeader)' % (proto.name, proto.name))

1708

if_body.append('{')

1709

if_body.append(' struct_xgl%s* pPacket = (struct_xgl%s*)pHeader->pBody;' % (proto.name, proto.name))

1710

if_body.append(' pPacket->header = pHeader;')

1711

for p in proto.params:

1712

if '*' in p.ty:

1713

if 'DEVICE_CREATE_INFO' in p.ty:

1714

if_body.append(' pPacket->%s = interpret_XGL_DEVICE_CREATE_INFO(pHeader, (intptr_t)pPacket->%s);' % (p.name, p.name))

1715

else:

1716

if_body.append(' pPacket->%s = (%s)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->%s);' % (p.name, p.ty, p.name))

1717

if proto.name in custom_case_dict and p.name == custom_case_dict[proto.name]['param']:

1718

if_body.append(' if (pPacket->%s != NULL)' % custom_case_dict[proto.name]['param'])

1719

if_body.append(' {')

1720

if_body.append(' %s' % " ".join(custom_case_dict[proto.name]['txt']))

1721

if_body.append(' }')

1722

if_body.append(' return pPacket;')

1723

if_body.append('}\n')

1724

return "\n".join(if_body)

1725

1726

def _generate_interp_funcs_ext(self, func_class='Wsi'):

1727

if_body = []

1728

for proto in self.protos:

1729

if func_class in proto.name:

1730

if_body.append('typedef struct struct_xgl%s {' % proto.name)

1731

if_body.append(' glv_trace_packet_header* pHeader;')

1732

for p in proto.params:

1733

if_body.append(' %s %s;' % (p.ty, p.name))

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

1734

if 'void' != proto.ret:

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

1735

if_body.append(' %s result;' % proto.ret)

1736

if_body.append('} struct_xgl%s;\n' % proto.name)

1737

if_body.append('static struct_xgl%s* interpret_body_as_xgl%s(glv_trace_packet_header* pHeader)' % (proto.name, proto.name))

1738

if_body.append('{')

1739

if_body.append(' struct_xgl%s* pPacket = (struct_xgl%s*)pHeader->pBody;' % (proto.name, proto.name))

1740

if_body.append(' pPacket->pHeader = pHeader;')

1741

for p in proto.params:

1742

if '*' in p.ty:

1743

if_body.append(' pPacket->%s = (%s)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->%s);' % (p.name, p.ty, p.name))

1744

if_body.append(' return pPacket;')

1745

if_body.append('}\n')

1746

return "\n".join(if_body)

1747

1748

def _generate_replay_class_decls(self):

1749

cd_body = []

1750

cd_body.append('class ApiReplay {')

1751

cd_body.append('public:')

1752

cd_body.append(' virtual ~ApiReplay() { }')

1753

cd_body.append(' virtual enum glv_replay::GLV_REPLAY_RESULT replay(glv_trace_packet_header * packet) = 0;')

1754

cd_body.append(' virtual int init(glv_replay::Display & disp) = 0;')

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

1755

cd_body.append(' virtual void push_validation_msg(XGL_VALIDATION_LEVEL validationLevel, XGL_BASE_OBJECT srcObject, size_t location, int32_t msgCode, const char* pMsg) = 0;')

Jon Ashburn

2014-12-18 17:03:34 -0700

[diff] [blame]

1756

cd_body.append(' virtual glv_replay::GLV_REPLAY_RESULT pop_validation_msgs() = 0;')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

1757

cd_body.append('};\n')

1758

cd_body.append('class xglDisplay: public glv_replay::DisplayImp {')

1759

cd_body.append('friend class xglReplay;')

1760

cd_body.append('public:')

1761

cd_body.append(' xglDisplay();')

1762

cd_body.append(' ~xglDisplay();')

1763

cd_body.append(' int init(const unsigned int gpu_idx);')

1764

cd_body.append(' int set_window(glv_window_handle hWindow, unsigned int width, unsigned int height);')

1765

cd_body.append(' int create_window(const unsigned int width, const unsigned int height);')

1766

cd_body.append(' void resize_window(const unsigned int width, const unsigned int height);')

1767

cd_body.append(' void process_event();')

1768

cd_body.append(' // XGL_DEVICE get_device() { return m_dev[m_gpuIdx];}')

1769

cd_body.append('#if defined(WIN32)')

1770

cd_body.append(' HWND get_window_handle() { return m_windowHandle; }')

1771

cd_body.append('#elif defined(PLATFORM_LINUX)')

1772

cd_body.append(' xcb_window_t get_window_handle() { return m_XcbWindow; }')

1773

cd_body.append('#endif')

1774

cd_body.append('private:')

1775

cd_body.append(' XGL_RESULT init_xgl(const unsigned int gpu_idx);')

1776

cd_body.append(' bool m_initedXGL;')

1777

cd_body.append('#if defined(WIN32)')

1778

cd_body.append(' HWND m_windowHandle;')

1779

cd_body.append('#elif defined(PLATFORM_LINUX)')

1780

cd_body.append(' XGL_WSI_X11_CONNECTION_INFO m_WsiConnection;')

1781

cd_body.append(' xcb_screen_t *m_pXcbScreen;')

1782

cd_body.append(' xcb_window_t m_XcbWindow;')

1783

cd_body.append('#endif')

1784

cd_body.append(' unsigned int m_windowWidth;')

1785

cd_body.append(' unsigned int m_windowHeight;')

Tony Barbour

2015-02-02 13:21:18 -0700

[diff] [blame]

1786

cd_body.append(' unsigned int m_frameNumber;')

Tony Barbour

2015-02-05 09:46:17 -0700

[diff] [blame]

1787

cd_body.append(' std::vector<uint32_t> imageWidth;')

1788

cd_body.append(' std::vector<uint32_t> imageHeight;')

1789

cd_body.append(' std::vector<XGL_IMAGE> imageHandles;')

1790

cd_body.append(' std::vector<XGL_GPU_MEMORY> imageMemory;')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

1791

cd_body.append('#if 0')

1792

cd_body.append(' XGL_DEVICE m_dev[XGL_MAX_PHYSICAL_GPUS];')

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

1793

cd_body.append(' uint32_t m_gpuCount;')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

1794

cd_body.append(' unsigned int m_gpuIdx;')

1795

cd_body.append(' XGL_PHYSICAL_GPU m_gpus[XGL_MAX_PHYSICAL_GPUS];')

1796

cd_body.append(' XGL_PHYSICAL_GPU_PROPERTIES m_gpuProps[XGL_MAX_PHYSICAL_GPUS];')

1797

cd_body.append('#endif')

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

1798

cd_body.append(' std::vector<char *>m_extensions;')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

1799

cd_body.append('};\n')

1800

cd_body.append('typedef struct _XGLAllocInfo {')

1801

cd_body.append(' XGL_GPU_SIZE size;')

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

1802

cd_body.append(' void *pData;')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

1803

cd_body.append('} XGLAllocInfo;')

1804

return "\n".join(cd_body)

1805

1806

def _generate_replay_func_ptrs(self):

1807

xf_body = []

1808

xf_body.append('struct xglFuncs {')

1809

xf_body.append(' void init_funcs(void * libHandle);')

1810

xf_body.append(' void *m_libHandle;\n')

1811

for proto in self.protos:

1812

xf_body.append(' typedef %s( XGLAPI * type_xgl%s)(' % (proto.ret, proto.name))

1813

for p in proto.params:

1814

if '[4]' in p.ty:

1815

xf_body.append(' %s %s[4],' % (p.ty.strip('[4]'), p.name))

1816

else:

1817

xf_body.append(' %s %s,' % (p.ty, p.name))

1818

xf_body[-1] = xf_body[-1].replace(',', ');')

1819

xf_body.append(' type_xgl%s real_xgl%s;' % (proto.name, proto.name))

1820

xf_body.append('};')

1821

return "\n".join(xf_body)

1822

1823

def _map_decl(self, type1, type2, name):

1824

return ' std::map<%s, %s> %s;' % (type1, type2, name)

1825

1826

def _add_to_map_decl(self, type1, type2, name):

1827

txt = ' void add_to_map(%s* pTraceVal, %s* pReplayVal)\n {\n' % (type1, type2)

1828

txt += ' assert(pTraceVal != NULL);\n'

1829

txt += ' assert(pReplayVal != NULL);\n'

1830

txt += ' %s[*pTraceVal] = *pReplayVal;\n }' % name

1831

return txt

1832

1833

def _rm_from_map_decl(self, ty, name):

1834

txt = ' void rm_from_map(const %s& key)\n {\n' % (ty)

1835

txt += ' %s.erase(key);\n }' % name

1836

return txt

1837

1838

def _remap_decl(self, ty, name):

1839

txt = ' %s remap(const %s& value)\n {\n' % (ty, ty)

1840

txt += ' std::map<%s, %s>::const_iterator q = %s.find(value);\n' % (ty, ty, name)

1841

txt += ' return (q == %s.end()) ? XGL_NULL_HANDLE : q->second;\n }' % name

1842

return txt

1843

1844

def _generate_replay_class(self):

Tobin Ehlis

2015-01-15 17:53:54 -0700

[diff] [blame]

1845

# Create dict mapping member var names to XGL type (i.e. 'm_imageViews' : 'XGL_IMAGE_VIEW')

1846

obj_map_dict = {}

1847

for ty in xgl.object_type_list:

1848

if ty in xgl.object_parent_list:

1849

continue

1850

mem_var = ty.replace('XGL_', '').lower()

1851

mem_var_list = mem_var.split('_')

Tobin Ehlis

2015-01-15 17:53:54 -0700

[diff] [blame]

1852

mem_var = 'm_%s%ss' % (mem_var_list[0], "".join([m.title() for m in mem_var_list[1:]]))

1853

obj_map_dict[mem_var] = ty

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

1854

rc_body = []

1855

rc_body.append('class xglReplay : public ApiReplay {')

1856

rc_body.append('public:')

1857

rc_body.append(' ~xglReplay();')

Peter Lohrmann

be24ff0

2015-01-08 19:47:03 -0800

[diff] [blame]

1858

rc_body.append(' xglReplay();\n')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

1859

rc_body.append(' int init(glv_replay::Display & disp);')

1860

rc_body.append(' xglDisplay * get_display() {return m_display;}')

1861

rc_body.append(' glv_replay::GLV_REPLAY_RESULT replay(glv_trace_packet_header *packet);')

1862

rc_body.append(' glv_replay::GLV_REPLAY_RESULT handle_replay_errors(const char* entrypointName, const XGL_RESULT resCall, const XGL_RESULT resTrace, const glv_replay::GLV_REPLAY_RESULT resIn);\n')

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

1863

rc_body.append(' void push_validation_msg(XGL_VALIDATION_LEVEL validationLevel, XGL_BASE_OBJECT srcObject, size_t location, int32_t msgCode, const char* pMsg);')

Jon Ashburn

2014-12-18 17:03:34 -0700

[diff] [blame]

1864

rc_body.append(' glv_replay::GLV_REPLAY_RESULT pop_validation_msgs();')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

1865

rc_body.append('private:')

1866

rc_body.append(' struct xglFuncs m_xglFuncs;')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

1867

rc_body.append(' xglDisplay *m_display;')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

1868

rc_body.append(' struct shaderPair {')

1869

rc_body.append(' XGL_SHADER *addr;')

1870

rc_body.append(' XGL_SHADER val;')

1871

rc_body.append(' };')

Tobin Ehlis

2015-02-05 11:29:45 -0700

[diff] [blame]

1872

rc_body.append(' struct eventPair {')

1873

rc_body.append(' XGL_EVENT *addr;')

1874

rc_body.append(' XGL_EVENT val;')

1875

rc_body.append(' };')

Jon Ashburn

2014-12-18 17:03:34 -0700

[diff] [blame]

1876

rc_body.append(' struct validationMsg {')

1877

rc_body.append(' XGL_VALIDATION_LEVEL validationLevel;')

1878

rc_body.append(' XGL_BASE_OBJECT srcObject;')

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

1879

rc_body.append(' size_t location;')

1880

rc_body.append(' int32_t msgCode;')

Jon Ashburn

2014-12-18 17:03:34 -0700

[diff] [blame]

1881

rc_body.append(' char msg[256];')

1882

rc_body.append(' };')

1883

rc_body.append(' std::vector<struct validationMsg> m_validationMsgs;')

Tony Barbour

2015-02-05 09:46:17 -0700

[diff] [blame]

1884

rc_body.append(' std::vector<int> m_screenshotFrames;')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

1885

rc_body.append(self._map_decl('XGL_GPU_MEMORY', 'XGLAllocInfo', 'm_mapData'))

1886

# Custom code for 1-off memory mapping functions

1887

rc_body.append(' void add_entry_to_mapData(XGL_GPU_MEMORY handle, XGL_GPU_SIZE size)')

1888

rc_body.append(' {')

1889

rc_body.append(' XGLAllocInfo info;')

1890

rc_body.append(' info.pData = NULL;')

1891

rc_body.append(' info.size = size;')

1892

rc_body.append(' m_mapData.insert(std::pair<XGL_GPU_MEMORY, XGLAllocInfo>(handle, info));')

1893

rc_body.append(' }')

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

1894

rc_body.append(' void add_mapping_to_mapData(XGL_GPU_MEMORY handle, void *pData)')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

1895

rc_body.append(' {')

1896

rc_body.append(' std::map<XGL_GPU_MEMORY,XGLAllocInfo>::iterator it = m_mapData.find(handle);')

1897

rc_body.append(' if (it == m_mapData.end())')

1898

rc_body.append(' {')

1899

rc_body.append(' glv_LogWarn("add_mapping_to_mapData() could not find entry\\n");')

1900

rc_body.append(' return;')

1901

rc_body.append(' }')

1902

rc_body.append(' XGLAllocInfo &info = it->second;')

1903

rc_body.append(' if (info.pData != NULL)')

1904

rc_body.append(' {')

1905

rc_body.append(' glv_LogWarn("add_mapping_to_mapData() data already mapped overwrite old mapping\\n");')

1906

rc_body.append(' }')

1907

rc_body.append(' info.pData = pData;')

1908

rc_body.append(' }')

1909

rc_body.append(' void rm_entry_from_mapData(XGL_GPU_MEMORY handle)')

1910

rc_body.append(' {')

1911

rc_body.append(' std::map<XGL_GPU_MEMORY,XGLAllocInfo>::iterator it = m_mapData.find(handle);')

1912

rc_body.append(' if (it == m_mapData.end())')

1913

rc_body.append(' return;')

1914

rc_body.append(' m_mapData.erase(it);')

1915

rc_body.append(' }')

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

1916

rc_body.append(' void rm_mapping_from_mapData(XGL_GPU_MEMORY handle, void* pData)')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

1917

rc_body.append(' {')

1918

rc_body.append(' std::map<XGL_GPU_MEMORY,XGLAllocInfo>::iterator it = m_mapData.find(handle);')

1919

rc_body.append(' if (it == m_mapData.end())')

1920

rc_body.append(' return;\n')

1921

rc_body.append(' XGLAllocInfo &info = it->second;')

1922

rc_body.append(' if (!pData || !info.pData)')

1923

rc_body.append(' {')

1924

rc_body.append(' glv_LogWarn("rm_mapping_from_mapData() null src or dest pointers\\n");')

1925

rc_body.append(' info.pData = NULL;')

1926

rc_body.append(' return;')

1927

rc_body.append(' }')

1928

rc_body.append(' memcpy(info.pData, pData, info.size);')

1929

rc_body.append(' info.pData = NULL;')

1930

rc_body.append(' }\n')

1931

rc_body.append(' /*std::map<XGL_PHYSICAL_GPU, XGL_PHYSICAL_GPU> m_gpus;')

1932

rc_body.append(' void add_to_map(XGL_PHYSICAL_GPU* pTraceGpu, XGL_PHYSICAL_GPU* pReplayGpu)')

1933

rc_body.append(' {')

1934

rc_body.append(' assert(pTraceGpu != NULL);')

1935

rc_body.append(' assert(pReplayGpu != NULL);')

1936

rc_body.append(' m_gpus[*pTraceGpu] = *pReplayGpu;')

1937

rc_body.append(' }\n')

1938

rc_body.append(' XGL_PHYSICAL_GPU remap(const XGL_PHYSICAL_GPU& gpu)')

1939

rc_body.append(' {')

1940

rc_body.append(' std::map<XGL_PHYSICAL_GPU, XGL_PHYSICAL_GPU>::const_iterator q = m_gpus.find(gpu);')

1941

rc_body.append(' return (q == m_gpus.end()) ? XGL_NULL_HANDLE : q->second;')

1942

rc_body.append(' }*/\n')

1943

rc_body.append(' void clear_all_map_handles()\n {')

1944

for var in sorted(obj_map_dict):

1945

rc_body.append(' %s.clear();' % var)

1946

rc_body.append(' }')

1947

for var in sorted(obj_map_dict):

1948

rc_body.append(self._map_decl(obj_map_dict[var], obj_map_dict[var], var))

1949

rc_body.append(self._add_to_map_decl(obj_map_dict[var], obj_map_dict[var], var))

1950

rc_body.append(self._rm_from_map_decl(obj_map_dict[var], var))

1951

rc_body.append(self._remap_decl(obj_map_dict[var], var))

Tobin Ehlis

2015-01-15 17:53:54 -0700

[diff] [blame]

1952

# XGL_DYNAMIC_STATE_OBJECT code

1953

state_obj_remap_types = xgl.object_dynamic_state_list

1954

rc_body.append(' XGL_DYNAMIC_STATE_OBJECT remap(const XGL_DYNAMIC_STATE_OBJECT& state)\n {')

1955

rc_body.append(' XGL_DYNAMIC_STATE_OBJECT obj;')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

1956

for t in state_obj_remap_types:

1957

rc_body.append(' if ((obj = remap(static_cast <%s> (state))) != XGL_NULL_HANDLE)' % t)

1958

rc_body.append(' return obj;')

1959

rc_body.append(' return XGL_NULL_HANDLE;\n }')

Tobin Ehlis

2015-01-15 17:53:54 -0700

[diff] [blame]

1960

rc_body.append(' void rm_from_map(const XGL_DYNAMIC_STATE_OBJECT& state)\n {')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

1961

for t in state_obj_remap_types:

1962

rc_body.append(' rm_from_map(static_cast <%s> (state));' % t)

1963

rc_body.append(' }')

1964

# OBJECT code

1965

rc_body.append(' XGL_OBJECT remap(const XGL_OBJECT& object)\n {')

1966

rc_body.append(' XGL_OBJECT obj;')

Tobin Ehlis

2015-01-15 17:53:54 -0700

[diff] [blame]

1967

obj_remap_types = xgl.object_list

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

1968

for var in obj_remap_types:

1969

rc_body.append(' if ((obj = remap(static_cast <%s> (object))) != XGL_NULL_HANDLE)' % (var))

1970

rc_body.append(' return obj;')

1971

rc_body.append(' return XGL_NULL_HANDLE;\n }')

1972

rc_body.append(' void rm_from_map(const XGL_OBJECT & objKey)\n {')

1973

for var in obj_remap_types:

1974

rc_body.append(' rm_from_map(static_cast <%s> (objKey));' % (var))

1975

rc_body.append(' }')

1976

rc_body.append(' XGL_BASE_OBJECT remap(const XGL_BASE_OBJECT& object)\n {')

1977

rc_body.append(' XGL_BASE_OBJECT obj;')

1978

base_obj_remap_types = ['XGL_DEVICE', 'XGL_QUEUE', 'XGL_GPU_MEMORY', 'XGL_OBJECT']

1979

for t in base_obj_remap_types:

1980

rc_body.append(' if ((obj = remap(static_cast <%s> (object))) != XGL_NULL_HANDLE)' % t)

1981

rc_body.append(' return obj;')

1982

rc_body.append(' return XGL_NULL_HANDLE;\n }')

Tony Barbour

2015-02-05 09:46:17 -0700

[diff] [blame]

1983

rc_body.append('void process_screenshot_list(const char *list)')

Tony Barbour

2015-02-02 13:21:18 -0700

[diff] [blame]

1984

rc_body.append('{')

1985

rc_body.append(' std::string spec(list), word;')

1986

rc_body.append(' size_t start = 0, comma = 0;\n')

1987

rc_body.append(' while (start < spec.size()) {')

1988

rc_body.append(' comma = spec.find(\',\', start);\n')

1989

rc_body.append(' if (comma == std::string::npos)')

1990

rc_body.append(' word = std::string(spec, start);')

1991

rc_body.append(' else')

1992

rc_body.append(' word = std::string(spec, start, comma - start);\n')

Tony Barbour

e3c27be

2015-02-05 13:55:03 -0700

[diff] [blame]

1993

rc_body.append(' m_screenshotFrames.push_back(atoi(word.c_str()));')

Tony Barbour

2015-02-02 13:21:18 -0700

[diff] [blame]

1994

rc_body.append(' if (comma == std::string::npos)')

1995

rc_body.append(' break;\n')

1996

rc_body.append(' start = comma + 1;\n')

Tony Barbour

2015-02-02 13:21:18 -0700

[diff] [blame]

1997

rc_body.append(' }')

1998

rc_body.append('}')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

1999

rc_body.append('};')

2000

return "\n".join(rc_body)

2001

2002

def _generate_replay_display_init_xgl(self):

2003

dix_body = []

2004

dix_body.append('XGL_RESULT xglDisplay::init_xgl(unsigned int gpu_idx)')

2005

dix_body.append('{')

2006

dix_body.append('#if 0')

2007

dix_body.append(' XGL_APPLICATION_INFO appInfo = {};')

2008

dix_body.append(' appInfo.pAppName = APP_NAME;')

2009

dix_body.append(' appInfo.pEngineName = "";')

2010

dix_body.append(' appInfo.apiVersion = XGL_API_VERSION;')

2011

dix_body.append(' XGL_RESULT res = xglInitAndEnumerateGpus(&appInfo, NULL, XGL_MAX_PHYSICAL_GPUS, &m_gpuCount, m_gpus);')

2012

dix_body.append(' if ( res == XGL_SUCCESS ) {')

2013

dix_body.append(' // retrieve the GPU information for all GPUs')

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

2014

dix_body.append(' for( uint32_t gpu = 0; gpu < m_gpuCount; gpu++)')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

2015

dix_body.append(' {')

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

2016

dix_body.append(' size_t gpuInfoSize = sizeof(m_gpuProps[0]);\n')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

2017

dix_body.append(' // get the GPU physical properties:')

2018

dix_body.append(' res = xglGetGpuInfo( m_gpus[gpu], XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES, &gpuInfoSize, &m_gpuProps[gpu]);')

2019

dix_body.append(' if (res != XGL_SUCCESS)')

2020

dix_body.append(' glv_LogWarn("Failed to retrieve properties for gpu[%d] result %d\\n", gpu, res);')

2021

dix_body.append(' }')

2022

dix_body.append(' res = XGL_SUCCESS;')

2023

dix_body.append(' } else if ((gpu_idx + 1) > m_gpuCount) {')

2024

dix_body.append(' glv_LogError("xglInitAndEnumerate number of gpus does not include requested index: num %d, requested %d\\n", m_gpuCount, gpu_idx);')

2025

dix_body.append(' return -1;')

2026

dix_body.append(' } else {')

2027

dix_body.append(' glv_LogError("xglInitAndEnumerate failed\\n");')

2028

dix_body.append(' return res;')

2029

dix_body.append(' }')

2030

dix_body.append(' // TODO add multi-gpu support always use gpu[gpu_idx] for now')

2031

dix_body.append(' // get all extensions supported by this device gpu[gpu_idx]')

2032

dix_body.append(' // first check if extensions are available and save a list of them')

2033

dix_body.append(' bool foundWSIExt = false;')

2034

dix_body.append(' for( int ext = 0; ext < sizeof( extensions ) / sizeof( extensions[0] ); ext++)')

2035

dix_body.append(' {')

2036

dix_body.append(' res = xglGetExtensionSupport( m_gpus[gpu_idx], extensions[ext] );')

2037

dix_body.append(' if (res == XGL_SUCCESS) {')

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

2038

dix_body.append(' m_extensions.push_back((char *) extensions[ext]);')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

2039

dix_body.append(' if (!strcmp(extensions[ext], "XGL_WSI_WINDOWS"))')

2040

dix_body.append(' foundWSIExt = true;')

2041

dix_body.append(' }')

2042

dix_body.append(' }')

2043

dix_body.append(' if (!foundWSIExt) {')

2044

dix_body.append(' glv_LogError("XGL_WSI_WINDOWS extension not supported by gpu[%d]\\n", gpu_idx);')

2045

dix_body.append(' return XGL_ERROR_INCOMPATIBLE_DEVICE;')

2046

dix_body.append(' }')

2047

dix_body.append(' // TODO generalize this: use one universal queue for now')

2048

dix_body.append(' XGL_DEVICE_QUEUE_CREATE_INFO dqci = {};')

2049

dix_body.append(' dqci.queueCount = 1;')

2050

dix_body.append(' dqci.queueType = XGL_QUEUE_UNIVERSAL;')

2051

dix_body.append(' // create the device enabling validation level 4')

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

2052

dix_body.append(' const char * const * extNames = &m_extensions[0];')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

2053

dix_body.append(' XGL_DEVICE_CREATE_INFO info = {};')

2054

dix_body.append(' info.queueRecordCount = 1;')

2055

dix_body.append(' info.pRequestedQueues = &dqci;')

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

2056

dix_body.append(' info.extensionCount = static_cast <uint32_t> (m_extensions.size());')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

2057

dix_body.append(' info.ppEnabledExtensionNames = extNames;')

2058

dix_body.append(' info.flags = XGL_DEVICE_CREATE_VALIDATION;')

2059

dix_body.append(' info.maxValidationLevel = XGL_VALIDATION_LEVEL_4;')

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

2060

dix_body.append(' bool32_t xglTrue = XGL_TRUE;')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

2061

dix_body.append(' res = xglDbgSetGlobalOption( XGL_DBG_OPTION_BREAK_ON_ERROR, sizeof( xglTrue ), &xglTrue );')

2062

dix_body.append(' if (res != XGL_SUCCESS)')

2063

dix_body.append(' glv_LogWarn("Could not set debug option break on error\\n");')

2064

dix_body.append(' res = xglCreateDevice( m_gpus[0], &info, &m_dev[gpu_idx]);')

2065

dix_body.append(' return res;')

2066

dix_body.append('#else')

2067

dix_body.append(' return XGL_ERROR_INITIALIZATION_FAILED;')

2068

dix_body.append('#endif')

2069

dix_body.append('}')

2070

return "\n".join(dix_body)

2071

2072

def _generate_replay_display_init(self):

2073

di_body = []

2074

di_body.append('int xglDisplay::init(const unsigned int gpu_idx)')

2075

di_body.append('{')

2076

di_body.append(' //m_gpuIdx = gpu_idx;')

2077

di_body.append('#if 0')

2078

di_body.append(' XGL_RESULT result = init_xgl(gpu_idx);')

2079

di_body.append(' if (result != XGL_SUCCESS) {')

2080

di_body.append(' glv_LogError("could not init xgl library");')

2081

di_body.append(' return -1;')

2082

di_body.append(' } else {')

2083

di_body.append(' m_initedXGL = true;')

2084

di_body.append(' }')

2085

di_body.append('#endif')

2086

di_body.append('#if defined(PLATFORM_LINUX)')

2087

di_body.append(' const xcb_setup_t *setup;')

2088

di_body.append(' xcb_screen_iterator_t iter;')

2089

di_body.append(' int scr;')

2090

di_body.append(' xcb_connection_t *pConnection;')

2091

di_body.append(' pConnection = xcb_connect(NULL, &scr);')

2092

di_body.append(' setup = xcb_get_setup(pConnection);')

2093

di_body.append(' iter = xcb_setup_roots_iterator(setup);')

2094

di_body.append(' while (scr-- > 0)')

2095

di_body.append(' xcb_screen_next(&iter);')

2096

di_body.append(' m_pXcbScreen = iter.data;')

2097

di_body.append(' m_WsiConnection.pConnection = pConnection;')

2098

di_body.append(' m_WsiConnection.root = m_pXcbScreen->root;')

2099

di_body.append('#endif')

2100

di_body.append(' return 0;')

2101

di_body.append('}')

2102

return "\n".join(di_body)

2103

2104

def _generate_replay_display_structors(self):

2105

ds_body = []

2106

ds_body.append('xglDisplay::xglDisplay()')

2107

ds_body.append(' : m_initedXGL(false),')

2108

ds_body.append(' m_windowWidth(0),')

2109

ds_body.append(' m_windowHeight(0)')

2110

ds_body.append('{')

2111

ds_body.append('#if defined(WIN32)')

2112

ds_body.append(' m_windowHandle = NULL;')

2113

ds_body.append('#elif defined(PLATFORM_LINUX)')

2114

ds_body.append(' m_WsiConnection.pConnection = NULL;')

2115

ds_body.append(' m_WsiConnection.root = 0;')

2116

ds_body.append(' m_WsiConnection.provider = 0;')

2117

ds_body.append(' m_pXcbScreen = NULL;')

2118

ds_body.append(' m_XcbWindow = 0;')

2119

ds_body.append('#endif')

2120

ds_body.append('}')

2121

ds_body.append('xglDisplay::~xglDisplay()')

2122

ds_body.append('{')

2123

ds_body.append('#ifdef PLATFORM_LINUX')

2124

ds_body.append(' if (m_XcbWindow != 0)')

2125

ds_body.append(' {')

2126

ds_body.append(' xcb_destroy_window(m_WsiConnection.pConnection, m_XcbWindow);')

2127

ds_body.append(' }')

2128

ds_body.append(' if (m_WsiConnection.pConnection != NULL)')

2129

ds_body.append(' {')

2130

ds_body.append(' xcb_disconnect(m_WsiConnection.pConnection);')

2131

ds_body.append(' }')

2132

ds_body.append('#endif')

2133

ds_body.append('}')

2134

return "\n".join(ds_body)

2135

2136

def _generate_replay_display_window(self):

2137

dw_body = []

2138

dw_body.append('#if defined(WIN32)')

2139

dw_body.append('LRESULT WINAPI WindowProcXgl( HWND window, unsigned int msg, WPARAM wp, LPARAM lp)')

2140

dw_body.append('{')

2141

dw_body.append(' switch(msg)')

2142

dw_body.append(' {')

2143

dw_body.append(' case WM_CLOSE:')

2144

dw_body.append(' DestroyWindow( window);')

2145

dw_body.append(' // fall-thru')

2146

dw_body.append(' case WM_DESTROY:')

2147

dw_body.append(' PostQuitMessage(0) ;')

2148

dw_body.append(' return 0L ;')

2149

dw_body.append(' default:')

2150

dw_body.append(' return DefWindowProc( window, msg, wp, lp ) ;')

2151

dw_body.append(' }')

2152

dw_body.append('}')

2153

dw_body.append('#endif')

2154

dw_body.append('int xglDisplay::set_window(glv_window_handle hWindow, unsigned int width, unsigned int height)')

2155

dw_body.append('{')

2156

dw_body.append('#if defined(WIN32)')

2157

dw_body.append(' m_windowHandle = hWindow;')

2158

dw_body.append('#elif defined(PLATFORM_LINUX)')

2159

dw_body.append(' m_XcbWindow = hWindow;')

2160

dw_body.append('#endif')

2161

dw_body.append(' m_windowWidth = width;')

2162

dw_body.append(' m_windowHeight = height;')

2163

dw_body.append(' return 0;')

2164

dw_body.append('}\n')

2165

dw_body.append('int xglDisplay::create_window(const unsigned int width, const unsigned int height)')

2166

dw_body.append('{')

2167

dw_body.append('#if defined(WIN32)')

2168

dw_body.append(' // Register Window class')

2169

dw_body.append(' WNDCLASSEX wcex = {};')

2170

dw_body.append(' wcex.cbSize = sizeof( WNDCLASSEX);')

2171

dw_body.append(' wcex.style = CS_HREDRAW | CS_VREDRAW;')

2172

dw_body.append(' wcex.lpfnWndProc = WindowProcXgl;')

2173

dw_body.append(' wcex.cbClsExtra = 0;')

2174

dw_body.append(' wcex.cbWndExtra = 0;')

2175

dw_body.append(' wcex.hInstance = GetModuleHandle(0);')

2176

dw_body.append(' wcex.hIcon = LoadIcon(wcex.hInstance, MAKEINTRESOURCE( IDI_ICON));')

2177

dw_body.append(' wcex.hCursor = LoadCursor( NULL, IDC_ARROW);')

2178

dw_body.append(' wcex.hbrBackground = ( HBRUSH )( COLOR_WINDOW + 1);')

2179

dw_body.append(' wcex.lpszMenuName = NULL;')

2180

dw_body.append(' wcex.lpszClassName = APP_NAME;')

2181

dw_body.append(' wcex.hIconSm = LoadIcon( wcex.hInstance, MAKEINTRESOURCE( IDI_ICON));')

2182

dw_body.append(' if( !RegisterClassEx( &wcex))')

2183

dw_body.append(' {')

2184

dw_body.append(' glv_LogError("Failed to register windows class\\n");')

2185

dw_body.append(' return -1;')

2186

dw_body.append(' }\n')

2187

dw_body.append(' // create the window')

2188

dw_body.append(' m_windowHandle = CreateWindow(APP_NAME, APP_NAME, WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU, 0, 0,')

2189

dw_body.append(' width, height, NULL, NULL, wcex.hInstance, NULL);\n')

2190

dw_body.append(' if (m_windowHandle)')

2191

dw_body.append(' {')

2192

dw_body.append(' ShowWindow( m_windowHandle, SW_SHOWDEFAULT);')

2193

dw_body.append(' m_windowWidth = width;')

2194

dw_body.append(' m_windowHeight = height;')

2195

dw_body.append(' } else {')

2196

dw_body.append(' glv_LogError("Failed to create window\\n");')

2197

dw_body.append(' return -1;')

2198

dw_body.append(' }')

2199

dw_body.append(' return 0;')

2200

dw_body.append('#elif defined(PLATFORM_LINUX)\n')

2201

dw_body.append(' uint32_t value_mask, value_list[32];')

2202

dw_body.append(' m_XcbWindow = xcb_generate_id(m_WsiConnection.pConnection);\n')

2203

dw_body.append(' value_mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;')

2204

dw_body.append(' value_list[0] = m_pXcbScreen->black_pixel;')

2205

dw_body.append(' value_list[1] = XCB_EVENT_MASK_KEY_RELEASE |')

2206

dw_body.append(' XCB_EVENT_MASK_EXPOSURE;\n')

2207

dw_body.append(' xcb_create_window(m_WsiConnection.pConnection,')

2208

dw_body.append(' XCB_COPY_FROM_PARENT,')

2209

dw_body.append(' m_XcbWindow, m_WsiConnection.root,')

2210

dw_body.append(' 0, 0, width, height, 0,')

2211

dw_body.append(' XCB_WINDOW_CLASS_INPUT_OUTPUT,')

2212

dw_body.append(' m_pXcbScreen->root_visual,')

2213

dw_body.append(' value_mask, value_list);\n')

2214

dw_body.append(' xcb_map_window(m_WsiConnection.pConnection, m_XcbWindow);')

2215

dw_body.append(' xcb_flush(m_WsiConnection.pConnection);')

2216

dw_body.append(' return 0;')

2217

dw_body.append('#endif')

2218

dw_body.append('}\n')

2219

dw_body.append('void xglDisplay::resize_window(const unsigned int width, const unsigned int height)')

2220

dw_body.append('{')

2221

dw_body.append('#if defined(WIN32)')

2222

dw_body.append(' if (width != m_windowWidth || height != m_windowHeight)')

2223

dw_body.append(' {')

2224

dw_body.append(' SetWindowPos(get_window_handle(), HWND_TOP, 0, 0, width, height, SWP_NOMOVE);')

2225

dw_body.append(' m_windowWidth = width;')

2226

dw_body.append(' m_windowHeight = height;')

2227

dw_body.append(' }')

2228

dw_body.append('#elif defined(PLATFORM_LINUX)')

2229

dw_body.append(' if (width != m_windowWidth || height != m_windowHeight)')

2230

dw_body.append(' {')

2231

dw_body.append(' uint32_t values[2];')

2232

dw_body.append(' values[0] = width;')

2233

dw_body.append(' values[1] = height;')

2234

dw_body.append(' xcb_configure_window(m_WsiConnection.pConnection, m_XcbWindow, XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT, values);')

2235

dw_body.append(' m_windowWidth = width;')

2236

dw_body.append(' m_windowHeight = height;')

2237

dw_body.append(' }')

2238

dw_body.append('#endif')

2239

dw_body.append('}\n')

2240

dw_body.append('void xglDisplay::process_event()')

2241

dw_body.append('{')

2242

dw_body.append('}')

2243

return "\n".join(dw_body)

2244

2245

def _generate_replay_structors(self):

2246

rs_body = []

Peter Lohrmann

be24ff0

2015-01-08 19:47:03 -0800

[diff] [blame]

2247

rs_body.append('xglReplay::xglReplay()')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

2248

rs_body.append('{')

2249

rs_body.append(' m_display = new xglDisplay();')

Jon Ashburn

215a966

2015-02-05 13:42:38 -0700

[diff] [blame]

2250

rs_body.append(' if (g_pReplaySettings && g_pReplaySettings->screenshotList) {')

2251

rs_body.append(' process_screenshot_list(g_pReplaySettings->screenshotList);')

Tony Barbour

2015-02-05 09:46:17 -0700

[diff] [blame]

2252

rs_body.append(' }')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

2253

rs_body.append('}\n')

2254

rs_body.append('xglReplay::~xglReplay()')

2255

rs_body.append('{')

2256

rs_body.append(' delete m_display;')

2257

rs_body.append(' glv_platform_close_library(m_xglFuncs.m_libHandle);')

2258

rs_body.append('}')

2259

return "\n".join(rs_body)

2260

2261

def _generate_replay_init(self):

2262

ri_body = []

2263

ri_body.append('int xglReplay::init(glv_replay::Display & disp)')

2264

ri_body.append('{')

2265

ri_body.append(' int err;')

2266

ri_body.append('#if defined _WIN64')

2267

ri_body.append(' HMODULE handle = LoadLibrary("xgl64.dll" );')

2268

ri_body.append('#elif defined _WIN32')

2269

ri_body.append(' HMODULE handle = LoadLibrary("xgl32.dll" );')

2270

ri_body.append('#elif defined PLATFORM_LINUX')

2271

ri_body.append(' void * handle = dlopen("libXGL.so", RTLD_LAZY);')

2272

ri_body.append('#endif\n')

2273

ri_body.append(' if (handle == NULL) {')

2274

ri_body.append(' glv_LogError("Failed to open xgl library.\\n");')

2275

ri_body.append(' return -1;')

2276

ri_body.append(' }')

2277

ri_body.append(' m_xglFuncs.init_funcs(handle);')

2278

ri_body.append(' disp.set_implementation(m_display);')

2279

ri_body.append(' if ((err = m_display->init(disp.get_gpu())) != 0) {')

2280

ri_body.append(' glv_LogError("Failed to init XGL display.\\n");')

2281

ri_body.append(' return err;')

2282

ri_body.append(' }')

2283

ri_body.append(' if (disp.get_window_handle() == 0)')

2284

ri_body.append(' {')

2285

ri_body.append(' if ((err = m_display->create_window(disp.get_width(), disp.get_height())) != 0) {')

2286

ri_body.append(' glv_LogError("Failed to create Window\\n");')

2287

ri_body.append(' return err;')

2288

ri_body.append(' }')

2289

ri_body.append(' }')

2290

ri_body.append(' else')

2291

ri_body.append(' {')

2292

ri_body.append(' if ((err = m_display->set_window(disp.get_window_handle(), disp.get_width(), disp.get_height())) != 0)')

2293

ri_body.append(' {')

2294

ri_body.append(' glv_LogError("Failed to set Window\\n");')

2295

ri_body.append(' return err;')

2296

ri_body.append(' }')

2297

ri_body.append(' }')

2298

ri_body.append(' return 0;')

2299

ri_body.append('}')

2300

return "\n".join(ri_body)

2301

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

2302

def _generate_replay_errors(self):

2303

re_body = []

2304

re_body.append('glv_replay::GLV_REPLAY_RESULT xglReplay::handle_replay_errors(const char* entrypointName, const XGL_RESULT resCall, const XGL_RESULT resTrace, const glv_replay::GLV_REPLAY_RESULT resIn)')

2305

re_body.append('{')

2306

re_body.append(' glv_replay::GLV_REPLAY_RESULT res = resIn;')

2307

re_body.append(' if (resCall != resTrace) {')

2308

re_body.append(' glv_LogWarn("Mismatched return from API call (%s) traced result %s, replay result %s\\n", entrypointName,')

Tobin Ehlis

2015-01-15 17:53:54 -0700

[diff] [blame]

2309

re_body.append(' string_XGL_RESULT((XGL_RESULT)resTrace), string_XGL_RESULT((XGL_RESULT)resCall));')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

2310

re_body.append(' res = glv_replay::GLV_REPLAY_BAD_RETURN;')

2311

re_body.append(' }')

2312

re_body.append('#if 0')

2313

re_body.append(' if (resCall != XGL_SUCCESS) {')

2314

re_body.append(' glv_LogWarn("API call (%s) returned failed result %s\\n", entrypointName, string_XGL_RESULT(resCall));')

2315

re_body.append(' }')

2316

re_body.append('#endif')

2317

re_body.append(' return res;')

2318

re_body.append('}')

2319

return "\n".join(re_body)

2320

Jon Ashburn

2014-12-18 17:03:34 -0700

[diff] [blame]

2321

def _generate_replay_validation_funcs(self):

2322

rvf_body = []

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

2323

rvf_body.append('void xglReplay::push_validation_msg(XGL_VALIDATION_LEVEL validationLevel, XGL_BASE_OBJECT srcObject, size_t location, int32_t msgCode, const char * pMsg)')

Jon Ashburn

2014-12-18 17:03:34 -0700

[diff] [blame]

2324

rvf_body.append('{')

2325

rvf_body.append(' struct validationMsg msgObj;')

2326

rvf_body.append(' msgObj.validationLevel = validationLevel;')

2327

rvf_body.append(' msgObj.srcObject = srcObject;')

2328

rvf_body.append(' msgObj.location = location;')

2329

rvf_body.append(' msgObj.msgCode = msgCode;')

2330

rvf_body.append(' strncpy(msgObj.msg, pMsg, 256);')

2331

rvf_body.append(" msgObj.msg[255] = '\\0';")

2332

rvf_body.append(' m_validationMsgs.push_back(msgObj);')

2333

rvf_body.append('}\n')

2334

rvf_body.append('glv_replay::GLV_REPLAY_RESULT xglReplay::pop_validation_msgs()')

2335

rvf_body.append('{')

2336

rvf_body.append(' if (m_validationMsgs.size() == 0)')

2337

rvf_body.append(' return glv_replay::GLV_REPLAY_SUCCESS;')

2338

rvf_body.append(' m_validationMsgs.clear();')

2339

rvf_body.append(' return glv_replay::GLV_REPLAY_VALIDATION_ERROR;')

2340

rvf_body.append('}')

2341

return "\n".join(rvf_body)

2342

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

2343

def _generate_replay_init_funcs(self):

2344

rif_body = []

2345

rif_body.append('void xglFuncs::init_funcs(void * handle)\n{\n m_libHandle = handle;')

2346

for proto in self.protos:

2347

rif_body.append(' real_xgl%s = (type_xgl%s)(glv_platform_get_library_entrypoint(handle, "xgl%s"));' % (proto.name, proto.name, proto.name))

2348

rif_body.append('}')

2349

return "\n".join(rif_body)

2350

2351

def _get_packet_param(self, t, n):

2352

# list of types that require remapping

Tobin Ehlis

2015-01-15 17:53:54 -0700

[diff] [blame]

2353

remap_list = xgl.object_type_list

Tobin Ehlis

2015-01-15 17:53:54 -0700

[diff] [blame]

2354

param_exclude_list = ['p1', 'p2', 'pGpus', 'pDescriptorSets']

2355

if t.strip('*').replace('const ', '') in remap_list and n not in param_exclude_list:

2356

if '*' in t:

2357

if 'const ' not in t:

2358

return 'remap(*pPacket->%s)' % (n)

2359

else: # TODO : Don't remap array ptrs?

2360

return 'pPacket->%s' % (n)

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

2361

return 'remap(pPacket->%s)' % (n)

2362

return 'pPacket->%s' % (n)

2363

Tobin Ehlis

2015-01-16 15:13:34 -0700

[diff] [blame]

2364

def _gen_replay_enum_gpus(self):

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

2365

ieg_body = []

2366

ieg_body.append(' if (!m_display->m_initedXGL)')

2367

ieg_body.append(' {')

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

2368

ieg_body.append(' uint32_t gpuCount;')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

2369

ieg_body.append(' XGL_PHYSICAL_GPU gpus[XGL_MAX_PHYSICAL_GPUS];')

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

2370

ieg_body.append(' uint32_t maxGpus = (pPacket->maxGpus < XGL_MAX_PHYSICAL_GPUS) ? pPacket->maxGpus : XGL_MAX_PHYSICAL_GPUS;')

Tobin Ehlis

2015-01-16 15:13:34 -0700

[diff] [blame]

2371

ieg_body.append(' replayResult = m_xglFuncs.real_xglEnumerateGpus(remap(pPacket->instance), maxGpus, &gpuCount, &gpus[0]);')

2372

ieg_body.append(' CHECK_RETURN_VALUE(xglEnumerateGpus);')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

2373

ieg_body.append(' //TODO handle different number of gpus in trace versus replay')

2374

ieg_body.append(' if (gpuCount != *(pPacket->pGpuCount))')

2375

ieg_body.append(' {')

2376

ieg_body.append(' glv_LogWarn("number of gpus mismatched in replay %u versus trace %u\\n", gpuCount, *(pPacket->pGpuCount));')

2377

ieg_body.append(' }')

2378

ieg_body.append(' else if (gpuCount == 0)')

2379

ieg_body.append(' {')

Tobin Ehlis

2015-01-16 15:13:34 -0700

[diff] [blame]

2380

ieg_body.append(' glv_LogError("xglEnumerateGpus number of gpus is zero\\n");')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

2381

ieg_body.append(' }')

2382

ieg_body.append(' else')

2383

ieg_body.append(' {')

2384

ieg_body.append(' glv_LogInfo("Enumerated %d GPUs in the system\\n", gpuCount);')

2385

ieg_body.append(' }')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

2386

ieg_body.append(' // TODO handle enumeration results in a different order from trace to replay')

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

2387

ieg_body.append(' for (uint32_t i = 0; i < gpuCount; i++)')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

2388

ieg_body.append(' {')

2389

ieg_body.append(' if (pPacket->pGpus)')

2390

ieg_body.append(' add_to_map(&(pPacket->pGpus[i]), &(gpus[i]));')

2391

ieg_body.append(' }')

2392

ieg_body.append(' }')

2393

return "\n".join(ieg_body)

2394

2395

def _gen_replay_get_gpu_info(self):

2396

ggi_body = []

2397

ggi_body.append(' if (!m_display->m_initedXGL)')

2398

ggi_body.append(' {')

2399

ggi_body.append(' switch (pPacket->infoType) {')

2400

ggi_body.append(' case XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES:')

2401

ggi_body.append(' {')

2402

ggi_body.append(' XGL_PHYSICAL_GPU_PROPERTIES gpuProps;')

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

2403

ggi_body.append(' size_t dataSize = sizeof(XGL_PHYSICAL_GPU_PROPERTIES);')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

2404

ggi_body.append(' replayResult = m_xglFuncs.real_xglGetGpuInfo(remap(pPacket->gpu), pPacket->infoType, &dataSize,')

2405

ggi_body.append(' (pPacket->pData == NULL) ? NULL : &gpuProps);')

2406

ggi_body.append(' if (pPacket->pData != NULL)')

2407

ggi_body.append(' {')

2408

ggi_body.append(' glv_LogInfo("Replay Gpu Properties\\n");')

2409

ggi_body.append(' glv_LogInfo("Vendor ID %x, Device ID %x, name %s\\n",gpuProps.vendorId, gpuProps.deviceId, gpuProps.gpuName);')

2410

ggi_body.append(' glv_LogInfo("API version %u, Driver version %u, gpu Type %u\\n",gpuProps.apiVersion, gpuProps.driverVersion, gpuProps.gpuType);')

2411

ggi_body.append(' }')

2412

ggi_body.append(' break;')

2413

ggi_body.append(' }')

2414

ggi_body.append(' case XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE:')

2415

ggi_body.append(' {')

2416

ggi_body.append(' XGL_PHYSICAL_GPU_PERFORMANCE gpuPerfs;')

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

2417

ggi_body.append(' size_t dataSize = sizeof(XGL_PHYSICAL_GPU_PERFORMANCE);')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

2418

ggi_body.append(' replayResult = m_xglFuncs.real_xglGetGpuInfo(remap(pPacket->gpu), pPacket->infoType, &dataSize,')

2419

ggi_body.append(' (pPacket->pData == NULL) ? NULL : &gpuPerfs);')

2420

ggi_body.append(' if (pPacket->pData != NULL)')

2421

ggi_body.append(' {')

2422

ggi_body.append(' glv_LogInfo("Replay Gpu Performance\\n");')

2423

ggi_body.append(' glv_LogInfo("Max GPU clock %f, max shader ALUs/clock %f, max texel fetches/clock %f\\n",gpuPerfs.maxGpuClock, gpuPerfs.aluPerClock, gpuPerfs.texPerClock);')

2424

ggi_body.append(' glv_LogInfo("Max primitives/clock %f, Max pixels/clock %f\\n",gpuPerfs.primsPerClock, gpuPerfs.pixelsPerClock);')

2425

ggi_body.append(' }')

2426

ggi_body.append(' break;')

2427

ggi_body.append(' }')

2428

ggi_body.append(' case XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES:')

2429

ggi_body.append(' {')

2430

ggi_body.append(' XGL_PHYSICAL_GPU_QUEUE_PROPERTIES *pGpuQueue, *pQ;')

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

2431

ggi_body.append(' size_t dataSize = sizeof(XGL_PHYSICAL_GPU_QUEUE_PROPERTIES);')

2432

ggi_body.append(' size_t numQueues = 1;')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

2433

ggi_body.append(' assert(pPacket->pDataSize);')

2434

ggi_body.append(' if ((*(pPacket->pDataSize) % dataSize) != 0)')

2435

ggi_body.append(' glv_LogWarn("xglGetGpuInfo() for GPU_QUEUE_PROPERTIES not an integral data size assuming 1\\n");')

2436

ggi_body.append(' else')

2437

ggi_body.append(' numQueues = *(pPacket->pDataSize) / dataSize;')

2438

ggi_body.append(' dataSize = numQueues * dataSize;')

2439

ggi_body.append(' pQ = static_cast < XGL_PHYSICAL_GPU_QUEUE_PROPERTIES *> (glv_malloc(dataSize));')

2440

ggi_body.append(' pGpuQueue = pQ;')

2441

ggi_body.append(' replayResult = m_xglFuncs.real_xglGetGpuInfo(remap(pPacket->gpu), pPacket->infoType, &dataSize,')

2442

ggi_body.append(' (pPacket->pData == NULL) ? NULL : pGpuQueue);')

2443

ggi_body.append(' if (pPacket->pData != NULL)')

2444

ggi_body.append(' {')

2445

ggi_body.append(' for (unsigned int i = 0; i < numQueues; i++)')

2446

ggi_body.append(' {')

2447

ggi_body.append(' glv_LogInfo("Replay Gpu Queue Property for index %d, flags %u\\n", i, pGpuQueue->queueFlags);')

2448

ggi_body.append(' glv_LogInfo("Max available count %u, max atomic counters %u, supports timestamps %u\\n",pGpuQueue->queueCount, pGpuQueue->maxAtomicCounters, pGpuQueue->supportsTimestamps);')

2449

ggi_body.append(' pGpuQueue++;')

2450

ggi_body.append(' }')

2451

ggi_body.append(' }')

2452

ggi_body.append(' glv_free(pQ);')

2453

ggi_body.append(' break;')

2454

ggi_body.append(' }')

2455

ggi_body.append(' default:')

2456

ggi_body.append(' {')

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

2457

ggi_body.append(' size_t size = 0;')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

2458

ggi_body.append(' void* pData = NULL;')

2459

ggi_body.append(' if (pPacket->pData != NULL && pPacket->pDataSize != NULL)')

2460

ggi_body.append(' {')

2461

ggi_body.append(' size = *pPacket->pDataSize;')

2462

ggi_body.append(' pData = glv_malloc(*pPacket->pDataSize);')

2463

ggi_body.append(' }')

2464

ggi_body.append(' replayResult = m_xglFuncs.real_xglGetGpuInfo(remap(pPacket->gpu), pPacket->infoType, &size, pData);')

2465

ggi_body.append(' if (replayResult == XGL_SUCCESS)')

2466

ggi_body.append(' {')

2467

ggi_body.append(' if (size != *pPacket->pDataSize && pData == NULL)')

2468

ggi_body.append(' {')

2469

ggi_body.append(' glv_LogWarn("xglGetGpuInfo returned a differing data size: replay (%d bytes) vs trace (%d bytes)\\n", size, *pPacket->pDataSize);')

2470

ggi_body.append(' }')

2471

ggi_body.append(' else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0)')

2472

ggi_body.append(' {')

2473

ggi_body.append(' glv_LogWarn("xglGetGpuInfo returned differing data contents than the trace file contained.\\n");')

2474

ggi_body.append(' }')

2475

ggi_body.append(' }')

2476

ggi_body.append(' glv_free(pData);')

2477

ggi_body.append(' break;')

2478

ggi_body.append(' }')

2479

ggi_body.append(' };')

2480

ggi_body.append(' CHECK_RETURN_VALUE(xglGetGpuInfo);')

2481

ggi_body.append(' }')

2482

return "\n".join(ggi_body)

2483

2484

def _gen_replay_create_device(self):

2485

cd_body = []

2486

cd_body.append(' if (!m_display->m_initedXGL)')

2487

cd_body.append(' {')

2488

cd_body.append(' XGL_DEVICE device;')

Peter Lohrmann

be24ff0

2015-01-08 19:47:03 -0800

[diff] [blame]

2489

cd_body.append(' if (g_xglReplaySettings.debugLevel > 0)')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

2490

cd_body.append(' {')

Jon Ashburn

6cad43c

2014-12-19 12:31:19 -0700

[diff] [blame]

2491

cd_body.append(' XGL_DEVICE_CREATE_INFO cInfo, *ci, *pCreateInfoSaved;')

Jon Ashburn

2014-12-18 17:03:34 -0700

[diff] [blame]

2492

cd_body.append(' // TODO what is the real list of layers to be running with??')

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

2493

# cd_body.append(' const char * layersStr[2] = {(char *) "DrawState", (char *) "ObjectTracker"};')

Peter Lohrmann

d445105

2015-01-09 12:34:50 -0800

[diff] [blame]

2494

2495

cd_body.append(' unsigned int numLayers = 0;')

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

2496

cd_body.append(' char ** layersStr = get_enableLayers_list(&numLayers);')

Jon Ashburn

2014-12-18 17:03:34 -0700

[diff] [blame]

2497

cd_body.append(' XGL_LAYER_CREATE_INFO layerInfo;')

Jon Ashburn

6cad43c

2014-12-19 12:31:19 -0700

[diff] [blame]

2498

cd_body.append(' pCreateInfoSaved = (XGL_DEVICE_CREATE_INFO *) pPacket->pCreateInfo;')

Jon Ashburn

2014-12-18 17:03:34 -0700

[diff] [blame]

2499

cd_body.append(' ci = (XGL_DEVICE_CREATE_INFO *) pPacket->pCreateInfo;')

Peter Lohrmann

d445105

2015-01-09 12:34:50 -0800

[diff] [blame]

2500

2501

cd_body.append(' if (layersStr != NULL && numLayers > 0)')

2502

cd_body.append(' {')

2503

cd_body.append(' while (ci->pNext != NULL)')

2504

cd_body.append(' ci = (XGL_DEVICE_CREATE_INFO *) ci->pNext;')

2505

cd_body.append(' ci->pNext = &layerInfo;')

2506

cd_body.append(' layerInfo.sType = XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO;')

2507

cd_body.append(' layerInfo.pNext = 0;')

2508

cd_body.append(' layerInfo.layerCount = numLayers;')

2509

cd_body.append(' layerInfo.ppActiveLayerNames = layersStr;')

2510

cd_body.append(' }')

2511

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

2512

cd_body.append(' memcpy(&cInfo, pPacket->pCreateInfo, sizeof(XGL_DEVICE_CREATE_INFO));')

2513

cd_body.append(' cInfo.flags = pPacket->pCreateInfo->flags | XGL_DEVICE_CREATE_VALIDATION_BIT;')

Tobin Ehlis

2015-01-15 17:53:54 -0700

[diff] [blame]

2514

cd_body.append(' cInfo.maxValidationLevel = (XGL_VALIDATION_LEVEL)((g_xglReplaySettings.debugLevel <= 4) ? (unsigned int) XGL_VALIDATION_LEVEL_0 + g_xglReplaySettings.debugLevel : (unsigned int) XGL_VALIDATION_LEVEL_0);')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

2515

cd_body.append(' pPacket->pCreateInfo = &cInfo;')

Jon Ashburn

2014-12-18 17:03:34 -0700

[diff] [blame]

2516

cd_body.append(' replayResult = m_xglFuncs.real_xglCreateDevice(remap(pPacket->gpu), pPacket->pCreateInfo, &device);')

Jon Ashburn

6cad43c

2014-12-19 12:31:19 -0700

[diff] [blame]

2517

cd_body.append(' // restore the packet for next replay')

2518

cd_body.append(' ci->pNext = NULL;')

2519

cd_body.append(' pPacket->pCreateInfo = pCreateInfoSaved;')

Peter Lohrmann

d445105

2015-01-09 12:34:50 -0800

[diff] [blame]

2520

cd_body.append(' release_enableLayer_list(layersStr);')

Jon Ashburn

2014-12-18 17:03:34 -0700

[diff] [blame]

2521

cd_body.append(' if (xglDbgRegisterMsgCallback(g_fpDbgMsgCallback, NULL) != XGL_SUCCESS)')

2522

cd_body.append(' glv_LogError("Failed to register xgl callback for replayer error handling\\n");')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

2523

cd_body.append(' }')

Jon Ashburn

2014-12-18 17:03:34 -0700

[diff] [blame]

2524

cd_body.append(' else ')

2525

cd_body.append(' replayResult = m_xglFuncs.real_xglCreateDevice(remap(pPacket->gpu), pPacket->pCreateInfo, &device);')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

2526

cd_body.append(' CHECK_RETURN_VALUE(xglCreateDevice);')

2527

cd_body.append(' if (replayResult == XGL_SUCCESS)')

2528

cd_body.append(' {')

2529

cd_body.append(' add_to_map(pPacket->pDevice, &device);')

2530

cd_body.append(' }')

2531

cd_body.append(' }')

2532

return "\n".join(cd_body)

2533

2534

def _gen_replay_get_extension_support(self):

2535

ges_body = []

2536

ges_body.append(' if (!m_display->m_initedXGL) {')

2537

ges_body.append(' replayResult = m_xglFuncs.real_xglGetExtensionSupport(remap(pPacket->gpu), pPacket->pExtName);')

2538

ges_body.append(' CHECK_RETURN_VALUE(xglGetExtensionSupport);')

2539

ges_body.append(' if (replayResult == XGL_SUCCESS) {')

2540

ges_body.append(' for (unsigned int ext = 0; ext < sizeof(g_extensions) / sizeof(g_extensions[0]); ext++)')

2541

ges_body.append(' {')

Chia-I Wu

2014-12-27 15:16:07 +0800

[diff] [blame]

2542

ges_body.append(' if (!strncmp(g_extensions[ext], pPacket->pExtName, strlen(g_extensions[ext]))) {')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

2543

ges_body.append(' bool extInList = false;')

2544

ges_body.append(' for (unsigned int j = 0; j < m_display->m_extensions.size(); ++j) {')

Chia-I Wu

2014-12-27 15:16:07 +0800

[diff] [blame]

2545

ges_body.append(' if (!strncmp(m_display->m_extensions[j], g_extensions[ext], strlen(g_extensions[ext])))')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

2546

ges_body.append(' extInList = true;')

2547

ges_body.append(' break;')

2548

ges_body.append(' }')

2549

ges_body.append(' if (!extInList)')

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

2550

ges_body.append(' m_display->m_extensions.push_back((char *) g_extensions[ext]);')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

2551

ges_body.append(' break;')

2552

ges_body.append(' }')

2553

ges_body.append(' }')

2554

ges_body.append(' }')

2555

ges_body.append(' }')

2556

return "\n".join(ges_body)

2557

2558

def _gen_replay_queue_submit(self):

2559

qs_body = []

2560

qs_body.append(' XGL_CMD_BUFFER *remappedBuffers = NULL;')

2561

qs_body.append(' if (pPacket->pCmdBuffers != NULL)')

2562

qs_body.append(' {')

2563

qs_body.append(' remappedBuffers = GLV_NEW_ARRAY( XGL_CMD_BUFFER, pPacket->cmdBufferCount);')

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

2564

qs_body.append(' for (uint32_t i = 0; i < pPacket->cmdBufferCount; i++)')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

2565

qs_body.append(' {')

2566

qs_body.append(' *(remappedBuffers + i) = remap(*(pPacket->pCmdBuffers + i));')

2567

qs_body.append(' }')

2568

qs_body.append(' }')

2569

qs_body.append(' XGL_MEMORY_REF* memRefs = NULL;')

2570

qs_body.append(' if (pPacket->pMemRefs != NULL)')

2571

qs_body.append(' {')

2572

qs_body.append(' memRefs = GLV_NEW_ARRAY(XGL_MEMORY_REF, pPacket->memRefCount);')

2573

qs_body.append(' memcpy(memRefs, pPacket->pMemRefs, sizeof(XGL_MEMORY_REF) * pPacket->memRefCount);')

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

2574

qs_body.append(' for (uint32_t i = 0; i < pPacket->memRefCount; i++)')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

2575

qs_body.append(' {')

2576

qs_body.append(' memRefs[i].mem = remap(pPacket->pMemRefs[i].mem);')

2577

qs_body.append(' }')

2578

qs_body.append(' }')

2579

qs_body.append(' replayResult = m_xglFuncs.real_xglQueueSubmit(remap(pPacket->queue), pPacket->cmdBufferCount, remappedBuffers, pPacket->memRefCount,')

2580

qs_body.append(' memRefs, remap(pPacket->fence));')

2581

qs_body.append(' GLV_DELETE(remappedBuffers);')

2582

qs_body.append(' GLV_DELETE(memRefs);')

2583

return "\n".join(qs_body)

2584

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

2585

def _gen_replay_get_object_info(self):

2586

goi_body = []

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

2587

goi_body.append(' size_t size = 0;')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

2588

goi_body.append(' void* pData = NULL;')

2589

goi_body.append(' if (pPacket->pData != NULL && pPacket->pDataSize != NULL)')

2590

goi_body.append(' {')

2591

goi_body.append(' size = *pPacket->pDataSize;')

2592

goi_body.append(' pData = glv_malloc(*pPacket->pDataSize);')

2593

goi_body.append(' memcpy(pData, pPacket->pData, *pPacket->pDataSize);')

2594

goi_body.append(' }')

2595

goi_body.append(' replayResult = m_xglFuncs.real_xglGetObjectInfo(remap(pPacket->object), pPacket->infoType, &size, pData);')

2596

goi_body.append(' if (replayResult == XGL_SUCCESS)')

2597

goi_body.append(' {')

2598

goi_body.append(' if (size != *pPacket->pDataSize && pData == NULL)')

2599

goi_body.append(' {')

2600

goi_body.append(' glv_LogWarn("xglGetObjectInfo returned a differing data size: replay (%d bytes) vs trace (%d bytes)\\n", size, *pPacket->pDataSize);')

2601

goi_body.append(' }')

2602

goi_body.append(' else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0)')

2603

goi_body.append(' {')

2604

goi_body.append(' glv_LogWarn("xglGetObjectInfo returned differing data contents than the trace file contained.\\n");')

2605

goi_body.append(' }')

2606

goi_body.append(' }')

2607

goi_body.append(' glv_free(pData);')

2608

return "\n".join(goi_body)

2609

2610

def _gen_replay_get_format_info(self):

2611

gfi_body = []

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

2612

gfi_body.append(' size_t size = 0;')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

2613

gfi_body.append(' void* pData = NULL;')

2614

gfi_body.append(' if (pPacket->pData != NULL && pPacket->pDataSize != NULL)')

2615

gfi_body.append(' {')

2616

gfi_body.append(' size = *pPacket->pDataSize;')

2617

gfi_body.append(' pData = glv_malloc(*pPacket->pDataSize);')

2618

gfi_body.append(' }')

2619

gfi_body.append(' replayResult = m_xglFuncs.real_xglGetFormatInfo(remap(pPacket->device), pPacket->format, pPacket->infoType, &size, pData);')

2620

gfi_body.append(' if (replayResult == XGL_SUCCESS)')

2621

gfi_body.append(' {')

2622

gfi_body.append(' if (size != *pPacket->pDataSize && pData == NULL)')

2623

gfi_body.append(' {')

2624

gfi_body.append(' glv_LogWarn("xglGetFormatInfo returned a differing data size: replay (%d bytes) vs trace (%d bytes)\\n", size, *pPacket->pDataSize);')

2625

gfi_body.append(' }')

2626

gfi_body.append(' else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0)')

2627

gfi_body.append(' {')

2628

gfi_body.append(' glv_LogWarn("xglGetFormatInfo returned differing data contents than the trace file contained.\\n");')

2629

gfi_body.append(' }')

2630

gfi_body.append(' }')

2631

gfi_body.append(' glv_free(pData);')

2632

return "\n".join(gfi_body)

2633

2634

def _gen_replay_get_image_subresource_info(self):

2635

isi_body = []

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

2636

isi_body.append(' size_t size = 0;')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

2637

isi_body.append(' void* pData = NULL;')

2638

isi_body.append(' if (pPacket->pData != NULL && pPacket->pDataSize != NULL)')

2639

isi_body.append(' {')

2640

isi_body.append(' size = *pPacket->pDataSize;')

2641

isi_body.append(' pData = glv_malloc(*pPacket->pDataSize);')

2642

isi_body.append(' }')

2643

isi_body.append(' replayResult = m_xglFuncs.real_xglGetImageSubresourceInfo(remap(pPacket->image), pPacket->pSubresource, pPacket->infoType, &size, pData);')

2644

isi_body.append(' if (replayResult == XGL_SUCCESS)')

2645

isi_body.append(' {')

2646

isi_body.append(' if (size != *pPacket->pDataSize && pData == NULL)')

2647

isi_body.append(' {')

2648

isi_body.append(' glv_LogWarn("xglGetImageSubresourceInfo returned a differing data size: replay (%d bytes) vs trace (%d bytes)\\n", size, *pPacket->pDataSize);')

2649

isi_body.append(' }')

2650

isi_body.append(' else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0)')

2651

isi_body.append(' {')

2652

isi_body.append(' glv_LogWarn("xglGetImageSubresourceInfo returned differing data contents than the trace file contained.\\n");')

2653

isi_body.append(' }')

2654

isi_body.append(' }')

2655

isi_body.append(' glv_free(pData);')

2656

return "\n".join(isi_body)

2657

Tobin Ehlis

2015-01-22 12:29:31 -0700

[diff] [blame]

2658

def _gen_replay_update_descriptors(self):

2659

ud_body = []

2660

# TODO : Add code here to read chain of update structs

Tobin Ehlis

2015-02-03 14:41:26 -0700

[diff] [blame]

2661

# We have to remap handles internal to the structures so make complete local copy of update chain

2662

# and remap all of the handles inside of the update structs

2663

ud_body.append(' XGL_UPDATE_SAMPLERS* pUpdateChain = (XGL_UPDATE_SAMPLERS*)pPacket->pUpdateChain;')

2664

ud_body.append(' void* pLocalUpdateChain = NULL;')

Tobin Ehlis

2015-02-04 14:57:24 -0700

[diff] [blame]

2665

ud_body.append(' XGL_UPDATE_SAMPLERS* pPrev = NULL;')

Tobin Ehlis

2015-02-03 14:41:26 -0700

[diff] [blame]

2666

ud_body.append(' void* pLocalUpdateChainHEAD = NULL;')

2667

ud_body.append(' size_t blockSize = 0;')

2668

ud_body.append(' while (pUpdateChain) {')

2669

ud_body.append(' switch(pUpdateChain->sType)')

2670

ud_body.append(' {')

2671

ud_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:')

2672

ud_body.append(' blockSize = sizeof(XGL_UPDATE_SAMPLERS) + ((XGL_UPDATE_SAMPLERS*)pUpdateChain)->count * sizeof(XGL_SAMPLER);')

2673

ud_body.append(' pLocalUpdateChain = (void*)malloc(blockSize);')

2674

ud_body.append(' memcpy(pLocalUpdateChain, pUpdateChain, blockSize);')

2675

ud_body.append(' for (uint32_t i = 0; i < ((XGL_UPDATE_SAMPLERS*)pLocalUpdateChain)->count; i++) {')

Tobin Ehlis

2015-02-04 14:57:24 -0700

[diff] [blame]

2676

ud_body.append(' XGL_SAMPLER* pLocalSampler = (XGL_SAMPLER*) &((XGL_UPDATE_SAMPLERS*)pLocalUpdateChain)->pSamplers[i];')

2677

ud_body.append(' *pLocalSampler = remap(((XGL_UPDATE_SAMPLERS*)pUpdateChain)->pSamplers[i]);')

Tobin Ehlis

2015-02-03 14:41:26 -0700

[diff] [blame]

2678

ud_body.append(' }')

2679

ud_body.append(' break;')

2680

ud_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:')

2681

ud_body.append(' blockSize = sizeof(XGL_UPDATE_SAMPLER_TEXTURES) + ((XGL_UPDATE_SAMPLER_TEXTURES*)pUpdateChain)->count * (sizeof(XGL_SAMPLER_IMAGE_VIEW_INFO) + sizeof(XGL_IMAGE_VIEW_ATTACH_INFO));')

Jon Ashburn

2015-02-04 12:57:25 -0700

[diff] [blame]

2682

ud_body.append(' XGL_UPDATE_SAMPLER_TEXTURES *pLocalUST;')

2683

ud_body.append(' pLocalUST = (XGL_UPDATE_SAMPLER_TEXTURES *)malloc(blockSize);')

2684

ud_body.append(' memcpy(pLocalUST, pUpdateChain, blockSize);')

2685

ud_body.append(' for (uint32_t i = 0; i < pLocalUST->count; i++) {')

2686

ud_body.append(' XGL_SAMPLER *plocalSampler = (XGL_SAMPLER *) &pLocalUST->pSamplerImageViews[i].pSampler; ')

2687

ud_body.append(' *plocalSampler = remap(((XGL_UPDATE_SAMPLER_TEXTURES*)pUpdateChain)->pSamplerImageViews[i].pSampler);')

2688

ud_body.append(' XGL_IMAGE_VIEW *pLocalView = (XGL_IMAGE_VIEW *)&pLocalUST->pSamplerImageViews[i].pImageView->view; ')

2689

ud_body.append(' *pLocalView = remap(((XGL_UPDATE_SAMPLER_TEXTURES*)pUpdateChain)->pSamplerImageViews[i].pImageView->view);')

Tobin Ehlis

2015-02-03 14:41:26 -0700

[diff] [blame]

2690

ud_body.append(' }')

Jon Ashburn

2015-02-04 12:57:25 -0700

[diff] [blame]

2691

ud_body.append(' pLocalUpdateChain = (void *) pLocalUST;')

Tobin Ehlis

2015-02-03 14:41:26 -0700

[diff] [blame]

2692

ud_body.append(' break;')

2693

ud_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:')

Jon Ashburn

2015-02-04 16:26:30 -0700

[diff] [blame]

2694

ud_body.append(' blockSize = sizeof(XGL_UPDATE_IMAGES) + (((XGL_UPDATE_IMAGES*)pUpdateChain)->count * (sizeof(XGL_IMAGE_VIEW_ATTACH_INFO*) + sizeof(XGL_IMAGE_VIEW_ATTACH_INFO)));')

Tobin Ehlis

2015-02-03 14:41:26 -0700

[diff] [blame]

2695

ud_body.append(' pLocalUpdateChain = malloc(blockSize);')

2696

ud_body.append(' memcpy(pLocalUpdateChain, pUpdateChain, blockSize);')

2697

ud_body.append(' for (uint32_t i = 0; i < ((XGL_UPDATE_IMAGES*)pLocalUpdateChain)->count; i++) {')

Tobin Ehlis

2015-02-04 14:57:24 -0700

[diff] [blame]

2698

ud_body.append(' XGL_IMAGE_VIEW* pLocalView = (XGL_IMAGE_VIEW*) &((XGL_UPDATE_IMAGES*)pUpdateChain)->pImageViews[i]->view;')

2699

ud_body.append(' *pLocalView = remap(((XGL_UPDATE_IMAGES*)pUpdateChain)->pImageViews[i]->view);')

Tobin Ehlis

2015-02-03 14:41:26 -0700

[diff] [blame]

2700

ud_body.append(' }')

2701

ud_body.append(' break;')

2702

ud_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:')

Jon Ashburn

2015-02-04 16:26:30 -0700

[diff] [blame]

2703

ud_body.append(' blockSize = sizeof(XGL_UPDATE_BUFFERS) + (((XGL_UPDATE_BUFFERS*)pUpdateChain)->count * (sizeof(XGL_BUFFER_VIEW_ATTACH_INFO*) + sizeof(XGL_BUFFER_VIEW_ATTACH_INFO)));')

Tobin Ehlis

2015-02-03 14:41:26 -0700

[diff] [blame]

2704

ud_body.append(' pLocalUpdateChain = malloc(blockSize);')

2705

ud_body.append(' memcpy(pLocalUpdateChain, pUpdateChain, blockSize);')

2706

ud_body.append(' for (uint32_t i = 0; i < ((XGL_UPDATE_BUFFERS*)pLocalUpdateChain)->count; i++) {')

Tobin Ehlis

2015-02-04 14:57:24 -0700

[diff] [blame]

2707

ud_body.append(' XGL_BUFFER_VIEW* pLocalView = (XGL_BUFFER_VIEW*) &((XGL_UPDATE_BUFFERS*)pUpdateChain)->pBufferViews[i]->view;')

2708

ud_body.append(' *pLocalView = remap(((XGL_UPDATE_BUFFERS*)pUpdateChain)->pBufferViews[i]->view);')

Tobin Ehlis

2015-02-03 14:41:26 -0700

[diff] [blame]

2709

ud_body.append(' }')

2710

ud_body.append(' break;')

2711

ud_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:')

2712

ud_body.append(' blockSize += sizeof(XGL_UPDATE_AS_COPY);')

2713

ud_body.append(' pLocalUpdateChain = malloc(blockSize);')

2714

ud_body.append(' memcpy(pLocalUpdateChain, pUpdateChain, blockSize);')

2715

ud_body.append(' ((XGL_UPDATE_AS_COPY*)pLocalUpdateChain)->descriptorSet = remap(((XGL_UPDATE_AS_COPY*)pUpdateChain)->descriptorSet);')

2716

ud_body.append(' break;')

2717

ud_body.append(' default:')

2718

ud_body.append(' // TODO : Flag error here')

2719

ud_body.append(' break;')

2720

ud_body.append(' }')

2721

ud_body.append(' if (NULL == pLocalUpdateChainHEAD) {')

2722

ud_body.append(' pLocalUpdateChainHEAD = pLocalUpdateChain;')

2723

ud_body.append(' }')

Tobin Ehlis

2015-02-04 14:57:24 -0700

[diff] [blame]

2724

ud_body.append(' if (pPrev) {')

2725

ud_body.append(' pPrev->pNext = pLocalUpdateChain;')

2726

ud_body.append(' }')

2727

ud_body.append(' pPrev = (XGL_UPDATE_SAMPLERS*)pLocalUpdateChain;')

Tobin Ehlis

2015-02-03 14:41:26 -0700

[diff] [blame]

2728

ud_body.append(' pUpdateChain = (XGL_UPDATE_SAMPLERS*)pUpdateChain->pNext;')

Tobin Ehlis

2015-02-03 14:41:26 -0700

[diff] [blame]

2729

ud_body.append(' }')

2730

ud_body.append(' m_xglFuncs.real_xglUpdateDescriptors(remap(pPacket->descriptorSet), pLocalUpdateChainHEAD);')

2731

ud_body.append(' pLocalUpdateChain = (XGL_UPDATE_SAMPLERS*)pLocalUpdateChainHEAD;')

2732

ud_body.append(' XGL_UPDATE_SAMPLERS* pFreeMe = NULL;')

2733

ud_body.append(' while (pLocalUpdateChain) {')

2734

ud_body.append(' switch(((XGL_UPDATE_SAMPLERS*)pLocalUpdateChain)->sType)')

2735

ud_body.append(' {')

2736

ud_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_SAMPLERS:')

2737

ud_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_IMAGES:')

2738

ud_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_BUFFERS:')

2739

ud_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_AS_COPY:')

Tobin Ehlis

2015-02-03 14:41:26 -0700

[diff] [blame]

2740

ud_body.append(' case XGL_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:')

2741

ud_body.append(' pFreeMe = (XGL_UPDATE_SAMPLERS*)pLocalUpdateChain;')

2742

ud_body.append(' pLocalUpdateChain = (void*)((XGL_UPDATE_SAMPLERS*)pLocalUpdateChain)->pNext;')

Tobin Ehlis

2015-02-03 14:41:26 -0700

[diff] [blame]

2743

ud_body.append(' free(pFreeMe);')

2744

ud_body.append(' break;')

2745

ud_body.append(' default:')

2746

ud_body.append(' // TODO : Flag error here')

Jon Ashburn

2015-02-04 12:57:25 -0700

[diff] [blame]

2747

ud_body.append(' pLocalUpdateChain = (void*)((XGL_UPDATE_SAMPLERS*)pLocalUpdateChain)->pNext;')

Tobin Ehlis

2015-02-03 14:41:26 -0700

[diff] [blame]

2748

ud_body.append(' break;')

2749

ud_body.append(' }')

Tobin Ehlis

2015-02-03 14:41:26 -0700

[diff] [blame]

2750

ud_body.append(' }')

2751

return "\n".join(ud_body)

Tobin Ehlis

2015-01-22 12:29:31 -0700

[diff] [blame]

2752

2753

def _gen_replay_create_descriptor_set_layout(self):

2754

cdsl_body = []

Tobin Ehlis

2015-02-03 14:41:26 -0700

[diff] [blame]

2755

cdsl_body.append(' XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO createInfo;')

2756

cdsl_body.append(' memcpy(&createInfo, pPacket->pSetLayoutInfoList, sizeof(XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO));')

2757

cdsl_body.append(' XGL_DESCRIPTOR_SET_LAYOUT setLayout;')

2758

cdsl_body.append(' replayResult = m_xglFuncs.real_xglCreateDescriptorSetLayout(remap(pPacket->device), pPacket->stageFlags, pPacket->pSetBindPoints, remap(pPacket->priorSetLayout), &createInfo, &setLayout);')

2759

cdsl_body.append(' if (replayResult == XGL_SUCCESS)')

2760

cdsl_body.append(' {')

2761

cdsl_body.append(' add_to_map(pPacket->pSetLayout, &setLayout);')

2762

cdsl_body.append(' }')

2763

return "\n".join(cdsl_body)

Tobin Ehlis

2015-01-22 12:29:31 -0700

[diff] [blame]

2764

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

2765

def _gen_replay_create_graphics_pipeline(self):

2766

cgp_body = []

2767

cgp_body.append(' XGL_GRAPHICS_PIPELINE_CREATE_INFO createInfo;')

2768

cgp_body.append(' struct shaderPair saveShader[10];')

2769

cgp_body.append(' unsigned int idx = 0;')

2770

cgp_body.append(' memcpy(&createInfo, pPacket->pCreateInfo, sizeof(XGL_GRAPHICS_PIPELINE_CREATE_INFO));')

Jon Ashburn

2015-02-03 17:47:58 -0700

[diff] [blame]

2771

cgp_body.append(' createInfo.lastSetLayout = remap(createInfo.lastSetLayout);')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

2772

cgp_body.append(' // Cast to shader type, as those are of primariy interest and all structs in LL have same header w/ sType & pNext')

2773

cgp_body.append(' XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pPacketNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pPacket->pCreateInfo->pNext;')

2774

cgp_body.append(' XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)createInfo.pNext;')

2775

cgp_body.append(' while (XGL_NULL_HANDLE != pPacketNext)')

2776

cgp_body.append(' {')

2777

cgp_body.append(' if (XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO == pNext->sType)')

2778

cgp_body.append(' {')

2779

cgp_body.append(' saveShader[idx].val = pNext->shader.shader;')

2780

cgp_body.append(' saveShader[idx++].addr = &(pNext->shader.shader);')

2781

cgp_body.append(' pNext->shader.shader = remap(pPacketNext->shader.shader);')

2782

cgp_body.append(' }')

2783

cgp_body.append(' pPacketNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pPacketNext->pNext;')

2784

cgp_body.append(' pNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pNext->pNext;')

2785

cgp_body.append(' }')

2786

cgp_body.append(' XGL_PIPELINE pipeline;')

2787

cgp_body.append(' replayResult = m_xglFuncs.real_xglCreateGraphicsPipeline(remap(pPacket->device), &createInfo, &pipeline);')

2788

cgp_body.append(' if (replayResult == XGL_SUCCESS)')

2789

cgp_body.append(' {')

2790

cgp_body.append(' add_to_map(pPacket->pPipeline, &pipeline);')

2791

cgp_body.append(' }')

2792

cgp_body.append(' for (unsigned int i = 0; i < idx; i++)')

2793

cgp_body.append(' *(saveShader[i].addr) = saveShader[i].val;')

2794

return "\n".join(cgp_body)

2795

Tobin Ehlis

2015-02-05 11:29:45 -0700

[diff] [blame]

2796

def _gen_replay_cmd_wait_events(self):

2797

cwe_body = []

2798

cwe_body.append(' struct eventPair saveEvent[100];')

2799

cwe_body.append(' uint32_t idx = 0;')

2800

cwe_body.append(' assert(pPacket->pWaitInfo && pPacket->pWaitInfo->eventCount <= 100);')

2801

cwe_body.append(' for (idx = 0; idx < pPacket->pWaitInfo->eventCount; idx++)')

2802

cwe_body.append(' {')

2803

cwe_body.append(' saveEvent[idx].val = pPacket->pWaitInfo->pEvents[idx];')

2804

cwe_body.append(' saveEvent[idx].addr = (XGL_EVENT*)&pPacket->pWaitInfo->pEvents[idx];')

2805

cwe_body.append(' *(saveEvent[idx].addr) = remap(pPacket->pWaitInfo->pEvents[idx]);')

2806

cwe_body.append(' }')

2807

cwe_body.append(' m_xglFuncs.real_xglCmdWaitEvents(remap(pPacket->cmdBuffer), pPacket->pWaitInfo);')

2808

cwe_body.append(' for (uint32_t i = 0; i < idx; i++)')

2809

cwe_body.append(' *(saveEvent[i].addr) = saveEvent[i].val;')

2810

return "\n".join(cwe_body)

2811

Jon Ashburn

2015-01-02 18:28:26 -0700

[diff] [blame]

2812

def _gen_replay_create_framebuffer(self):

2813

cf_body = []

2814

cf_body.append(' XGL_FRAMEBUFFER_CREATE_INFO *pInfo = (XGL_FRAMEBUFFER_CREATE_INFO *) pPacket->pCreateInfo;')

2815

cf_body.append(' XGL_COLOR_ATTACHMENT_BIND_INFO *pColorAttachments, *pSavedColor = (XGL_COLOR_ATTACHMENT_BIND_INFO*)pInfo->pColorAttachments;')

2816

cf_body.append(' bool allocatedColorAttachments = false;')

2817

cf_body.append(' if (pSavedColor != NULL)')

2818

cf_body.append(' {')

2819

cf_body.append(' allocatedColorAttachments = true;')

2820

cf_body.append(' pColorAttachments = GLV_NEW_ARRAY(XGL_COLOR_ATTACHMENT_BIND_INFO, pInfo->colorAttachmentCount);')

2821

cf_body.append(' memcpy(pColorAttachments, pSavedColor, sizeof(XGL_COLOR_ATTACHMENT_BIND_INFO) * pInfo->colorAttachmentCount);')

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

2822

cf_body.append(' for (uint32_t i = 0; i < pInfo->colorAttachmentCount; i++)')

Jon Ashburn

2015-01-02 18:28:26 -0700

[diff] [blame]

2823

cf_body.append(' {')

2824

cf_body.append(' pColorAttachments[i].view = remap(pInfo->pColorAttachments[i].view);')

2825

cf_body.append(' }')

2826

cf_body.append(' pInfo->pColorAttachments = pColorAttachments;')

2827

cf_body.append(' }')

2828

cf_body.append(' // remap depth stencil target')

Tobin Ehlis

2015-01-15 17:53:54 -0700

[diff] [blame]

2829

cf_body.append(' const XGL_DEPTH_STENCIL_BIND_INFO *pSavedDS = pInfo->pDepthStencilAttachment;')

Jon Ashburn

2015-01-02 18:28:26 -0700

[diff] [blame]

2830

cf_body.append(' XGL_DEPTH_STENCIL_BIND_INFO depthTarget;')

2831

cf_body.append(' if (pSavedDS != NULL)')

2832

cf_body.append(' {')

2833

cf_body.append(' memcpy(&depthTarget, pSavedDS, sizeof(XGL_DEPTH_STENCIL_BIND_INFO));')

2834

cf_body.append(' depthTarget.view = remap(pSavedDS->view);')

2835

cf_body.append(' pInfo->pDepthStencilAttachment = &depthTarget;')

2836

cf_body.append(' }')

2837

cf_body.append(' XGL_FRAMEBUFFER local_framebuffer;')

2838

cf_body.append(' replayResult = m_xglFuncs.real_xglCreateFramebuffer(remap(pPacket->device), pPacket->pCreateInfo, &local_framebuffer);')

2839

cf_body.append(' pInfo->pColorAttachments = pSavedColor;')

2840

cf_body.append(' pInfo->pDepthStencilAttachment = pSavedDS;')

2841

cf_body.append(' if (replayResult == XGL_SUCCESS)')

2842

cf_body.append(' {')

2843

cf_body.append(' add_to_map(pPacket->pFramebuffer, &local_framebuffer);')

2844

cf_body.append(' }')

2845

cf_body.append(' if (allocatedColorAttachments)')

2846

cf_body.append(' {')

2847

cf_body.append(' GLV_DELETE((void*)pColorAttachments);')

2848

cf_body.append(' }')

2849

return "\n".join(cf_body)

2850

2851

def _gen_replay_create_renderpass(self):

2852

cr_body = []

2853

cr_body.append(' XGL_RENDER_PASS_CREATE_INFO *pInfo = (XGL_RENDER_PASS_CREATE_INFO *) pPacket->pCreateInfo;')

2854

cr_body.append(' // remap framebuffer')

2855

cr_body.append(' XGL_FRAMEBUFFER savedFB, *pFB = &(pInfo->framebuffer);')

2856

cr_body.append(' if (*pFB != NULL)')

2857

cr_body.append(' {')

2858

cr_body.append(' savedFB = pInfo->framebuffer;')

2859

cr_body.append(' *pFB = remap(pInfo->framebuffer);')

2860

cr_body.append(' }')

2861

cr_body.append(' XGL_RENDER_PASS local_renderpass;')

2862

cr_body.append(' replayResult = m_xglFuncs.real_xglCreateRenderPass(remap(pPacket->device), pPacket->pCreateInfo, &local_renderpass);')

2863

cr_body.append(' pInfo->framebuffer = savedFB;')

2864

cr_body.append(' if (replayResult == XGL_SUCCESS)')

2865

cr_body.append(' {')

2866

cr_body.append(' add_to_map(pPacket->pRenderPass, &local_renderpass);')

2867

cr_body.append(' }')

2868

return "\n".join(cr_body)

2869

2870

def _gen_replay_begin_command_buffer(self):

2871

bcb_body = []

2872

bcb_body.append(' XGL_CMD_BUFFER_BEGIN_INFO* pInfo = (XGL_CMD_BUFFER_BEGIN_INFO*)pPacket->pBeginInfo;')

2873

bcb_body.append(' // assume only zero or one graphics_begin_info in the chain')

2874

bcb_body.append(' XGL_RENDER_PASS savedRP, *pRP;')

2875

bcb_body.append(' XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO *pGInfo = NULL;')

2876

bcb_body.append(' while (pInfo != NULL)')

2877

bcb_body.append(' {')

2878

bcb_body.append('')

2879

bcb_body.append(' if (pInfo->sType == XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO)')

2880

bcb_body.append(' {')

2881

bcb_body.append(' pGInfo = (XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO *) pInfo;')

2882

bcb_body.append(' savedRP = pGInfo->renderPass;')

2883

bcb_body.append(' pRP = &(pGInfo->renderPass);')

2884

bcb_body.append(' *pRP = remap(pGInfo->renderPass);')

2885

bcb_body.append(' break;')

2886

bcb_body.append(' }')

2887

bcb_body.append(' pInfo = (XGL_CMD_BUFFER_BEGIN_INFO*) pInfo->pNext;')

2888

bcb_body.append(' }')

2889

bcb_body.append(' replayResult = m_xglFuncs.real_xglBeginCommandBuffer(remap(pPacket->cmdBuffer), pPacket->pBeginInfo);')

2890

bcb_body.append(' if (pGInfo != NULL)')

2891

bcb_body.append(' pGInfo->renderPass = savedRP;')

2892

return "\n".join(bcb_body)

2893

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

2894

def _gen_replay_store_pipeline(self):

2895

sp_body = []

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

2896

sp_body.append(' size_t size = 0;')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

2897

sp_body.append(' void* pData = NULL;')

2898

sp_body.append(' if (pPacket->pData != NULL && pPacket->pDataSize != NULL)')

2899

sp_body.append(' {')

2900

sp_body.append(' size = *pPacket->pDataSize;')

2901

sp_body.append(' pData = glv_malloc(*pPacket->pDataSize);')

2902

sp_body.append(' }')

2903

sp_body.append(' replayResult = m_xglFuncs.real_xglStorePipeline(remap(pPacket->pipeline), &size, pData);')

2904

sp_body.append(' if (replayResult == XGL_SUCCESS)')

2905

sp_body.append(' {')

2906

sp_body.append(' if (size != *pPacket->pDataSize && pData == NULL)')

2907

sp_body.append(' {')

2908

sp_body.append(' glv_LogWarn("xglStorePipeline returned a differing data size: replay (%d bytes) vs trace (%d bytes)\\n", size, *pPacket->pDataSize);')

2909

sp_body.append(' }')

2910

sp_body.append(' else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0)')

2911

sp_body.append(' {')

2912

sp_body.append(' glv_LogWarn("xglStorePipeline returned differing data contents than the trace file contained.\\n");')

2913

sp_body.append(' }')

2914

sp_body.append(' }')

2915

sp_body.append(' glv_free(pData);')

2916

return "\n".join(sp_body)

2917

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

2918

def _gen_replay_get_multi_gpu_compatibility(self):

2919

gmgc_body = []

2920

gmgc_body.append(' XGL_GPU_COMPATIBILITY_INFO cInfo;')

2921

gmgc_body.append(' XGL_PHYSICAL_GPU handle0, handle1;')

2922

gmgc_body.append(' handle0 = remap(pPacket->gpu0);')

2923

gmgc_body.append(' handle1 = remap(pPacket->gpu1);')

2924

gmgc_body.append(' replayResult = m_xglFuncs.real_xglGetMultiGpuCompatibility(handle0, handle1, &cInfo);')

2925

return "\n".join(gmgc_body)

2926

2927

def _gen_replay_destroy_object(self):

2928

do_body = []

2929

do_body.append(' XGL_OBJECT object = remap(pPacket->object);')

2930

do_body.append(' if (object != XGL_NULL_HANDLE)')

2931

do_body.append(' replayResult = m_xglFuncs.real_xglDestroyObject(object);')

2932

do_body.append(' if (replayResult == XGL_SUCCESS)')

2933

do_body.append(' rm_from_map(pPacket->object);')

2934

return "\n".join(do_body)

2935

2936

def _gen_replay_wait_for_fences(self):

2937

wf_body = []

2938

wf_body.append(' XGL_FENCE *pFence = GLV_NEW_ARRAY(XGL_FENCE, pPacket->fenceCount);')

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

2939

wf_body.append(' for (uint32_t i = 0; i < pPacket->fenceCount; i++)')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

2940

wf_body.append(' {')

2941

wf_body.append(' *(pFence + i) = remap(*(pPacket->pFences + i));')

2942

wf_body.append(' }')

2943

wf_body.append(' replayResult = m_xglFuncs.real_xglWaitForFences(remap(pPacket->device), pPacket->fenceCount, pFence, pPacket->waitAll, pPacket->timeout);')

2944

wf_body.append(' GLV_DELETE(pFence);')

2945

return "\n".join(wf_body)

2946

2947

def _gen_replay_wsi_associate_connection(self):

2948

wac_body = []

2949

wac_body.append(' //associate with the replayers Wsi connection rather than tracers')

2950

wac_body.append(' replayResult = m_xglFuncs.real_xglWsiX11AssociateConnection(remap(pPacket->gpu), &(m_display->m_WsiConnection));')

2951

return "\n".join(wac_body)

2952

2953

def _gen_replay_wsi_get_msc(self):

2954

wgm_body = []

2955

wgm_body.append(' xcb_window_t window = m_display->m_XcbWindow;')

2956

wgm_body.append(' replayResult = m_xglFuncs.real_xglWsiX11GetMSC(remap(pPacket->device), window, pPacket->crtc, pPacket->pMsc);')

2957

return "\n".join(wgm_body)

2958

2959

def _gen_replay_wsi_create_presentable_image(self):

2960

cpi_body = []

2961

cpi_body.append(' XGL_IMAGE img;')

2962

cpi_body.append(' XGL_GPU_MEMORY mem;')

Tony Barbour

2015-02-05 09:46:17 -0700

[diff] [blame]

2963

cpi_body.append(' m_display->imageHeight.push_back(pPacket->pCreateInfo->extent.height);')

2964

cpi_body.append(' m_display->imageWidth.push_back(pPacket->pCreateInfo->extent.width);')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

2965

cpi_body.append(' replayResult = m_xglFuncs.real_xglWsiX11CreatePresentableImage(remap(pPacket->device), pPacket->pCreateInfo, &img, &mem);')

2966

cpi_body.append(' if (replayResult == XGL_SUCCESS)')

2967

cpi_body.append(' {')

2968

cpi_body.append(' if (pPacket->pImage != NULL)')

2969

cpi_body.append(' add_to_map(pPacket->pImage, &img);')

2970

cpi_body.append(' if(pPacket->pMem != NULL)')

2971

cpi_body.append(' add_to_map(pPacket->pMem, &mem);')

Tony Barbour

2015-02-05 09:46:17 -0700

[diff] [blame]

2972

cpi_body.append(' m_display->imageHandles.push_back(img);')

2973

cpi_body.append(' m_display->imageMemory.push_back(mem);')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

2974

cpi_body.append(' }')

2975

return "\n".join(cpi_body)

2976

2977

def _gen_replay_wsi_queue_present(self):

2978

wqp_body = []

2979

wqp_body.append(' XGL_WSI_X11_PRESENT_INFO pInfo;')

Tony Barbour

2015-02-02 13:21:18 -0700

[diff] [blame]

2980

wqp_body.append(' std::vector<int>::iterator it;')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

2981

wqp_body.append(' memcpy(&pInfo, pPacket->pPresentInfo, sizeof(XGL_WSI_X11_PRESENT_INFO));')

2982

wqp_body.append(' pInfo.srcImage = remap(pPacket->pPresentInfo->srcImage);')

2983

wqp_body.append(' // use replayers Xcb window')

2984

wqp_body.append(' pInfo.destWindow = m_display->m_XcbWindow;')

2985

wqp_body.append(' replayResult = m_xglFuncs.real_xglWsiX11QueuePresent(remap(pPacket->queue), &pInfo, remap(pPacket->fence));')

Tony Barbour

2015-02-05 09:46:17 -0700

[diff] [blame]

2986

wqp_body.append(' it = std::find(m_screenshotFrames.begin(), m_screenshotFrames.end(), m_display->m_frameNumber);')

2987

wqp_body.append(' if (it != m_screenshotFrames.end())')

Tony Barbour

2015-02-02 13:21:18 -0700

[diff] [blame]

2988

wqp_body.append(' {')

Tony Barbour

2015-02-05 09:46:17 -0700

[diff] [blame]

2989

wqp_body.append(' for(unsigned int i=0; i<m_display->imageHandles.size(); i++)')

Tony Barbour

2015-02-02 13:21:18 -0700

[diff] [blame]

2990

wqp_body.append(' {')

Tony Barbour

2015-02-05 09:46:17 -0700

[diff] [blame]

2991

wqp_body.append(' if (m_display->imageHandles[i] == pInfo.srcImage)')

Tony Barbour

2015-02-02 13:21:18 -0700

[diff] [blame]

2992

wqp_body.append(' {')

2993

wqp_body.append(' char frameName[32];')

2994

wqp_body.append(' sprintf(frameName, "%d",m_display->m_frameNumber);')

Tony Barbour

2015-02-05 09:46:17 -0700

[diff] [blame]

2995

wqp_body.append(' glvWritePPM(frameName, m_display->imageWidth[i], m_display->imageHeight[i],')

2996

wqp_body.append(' m_display->imageHandles[i], m_display->imageMemory[i], &m_xglFuncs);')

Tony Barbour

2015-02-02 13:21:18 -0700

[diff] [blame]

2997

wqp_body.append(' break;')

2998

wqp_body.append(' }')

2999

wqp_body.append(' }')

3000

wqp_body.append(' }')

3001

wqp_body.append(' m_display->m_frameNumber++;')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

3002

return "\n".join(wqp_body)

3003

3004

# I don't like making these 3 mem functions 'fully' custom, but just doing it for now to avoid being too cute

3005

def _gen_replay_free_memory(self):

3006

fm_body = []

3007

fm_body.append(' XGL_GPU_MEMORY handle = remap(pPacket->mem);')

3008

fm_body.append(' replayResult = m_xglFuncs.real_xglFreeMemory(handle);')

3009

fm_body.append(' if (replayResult == XGL_SUCCESS) ')

3010

fm_body.append(' {')

3011

fm_body.append(' rm_entry_from_mapData(handle);')

3012

fm_body.append(' rm_from_map(pPacket->mem);')

3013

fm_body.append(' }')

3014

return "\n".join(fm_body)

3015

3016

def _gen_replay_map_memory(self):

3017

mm_body = []

3018

mm_body.append(' XGL_GPU_MEMORY handle = remap(pPacket->mem);')

Mark Lobodzinski

2015-01-29 08:55:56 -0600

[diff] [blame]

3019

mm_body.append(' void* pData;')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

3020

mm_body.append(' replayResult = m_xglFuncs.real_xglMapMemory(handle, pPacket->flags, &pData);')

3021

mm_body.append(' if (replayResult == XGL_SUCCESS)')

3022

mm_body.append(' add_mapping_to_mapData(handle, pData);')

3023

return "\n".join(mm_body)

3024

3025

def _gen_replay_unmap_memory(self):

3026

um_body = []

3027

um_body.append(' XGL_GPU_MEMORY handle = remap(pPacket->mem);')

3028

um_body.append(' rm_mapping_from_mapData(handle, pPacket->pData); // copies data from packet into memory buffer')

3029

um_body.append(' replayResult = m_xglFuncs.real_xglUnmapMemory(handle);')

3030

return "\n".join(um_body)

3031

3032

def _gen_replay_bind_dynamic_memory_view(self):

3033

bdmv_body = []

3034

bdmv_body.append(' XGL_MEMORY_VIEW_ATTACH_INFO memView;')

3035

bdmv_body.append(' memcpy(&memView, pPacket->pMemView, sizeof(XGL_MEMORY_VIEW_ATTACH_INFO));')

3036

bdmv_body.append(' memView.mem = remap(pPacket->pMemView->mem);')

3037

bdmv_body.append(' m_xglFuncs.real_xglCmdBindDynamicMemoryView(remap(pPacket->cmdBuffer), pPacket->pipelineBindPoint, &memView);')

3038

return "\n".join(bdmv_body)

3039

Tobin Ehlis

2015-02-05 11:29:45 -0700

[diff] [blame]

3040

# Generate main replay case statements where actual replay API call is dispatched based on input packet data

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

3041

def _generate_replay(self):

3042

# map protos to custom functions if body is fully custom

Tobin Ehlis

2015-01-16 15:13:34 -0700

[diff] [blame]

3043

custom_body_dict = {'EnumerateGpus': self._gen_replay_enum_gpus,

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

3044

'GetGpuInfo': self._gen_replay_get_gpu_info,

3045

'CreateDevice': self._gen_replay_create_device,

3046

'GetExtensionSupport': self._gen_replay_get_extension_support,

3047

'QueueSubmit': self._gen_replay_queue_submit,

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

3048

'GetObjectInfo': self._gen_replay_get_object_info,

3049

'GetFormatInfo': self._gen_replay_get_format_info,

3050

'GetImageSubresourceInfo': self._gen_replay_get_image_subresource_info,

3051

'CreateGraphicsPipeline': self._gen_replay_create_graphics_pipeline,

Jon Ashburn

2015-01-02 18:28:26 -0700

[diff] [blame]

3052

'CreateFramebuffer': self._gen_replay_create_framebuffer,

3053

'CreateRenderPass': self._gen_replay_create_renderpass,

3054

'BeginCommandBuffer': self._gen_replay_begin_command_buffer,

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

3055

'StorePipeline': self._gen_replay_store_pipeline,

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

3056

'GetMultiGpuCompatibility': self._gen_replay_get_multi_gpu_compatibility,

3057

'DestroyObject': self._gen_replay_destroy_object,

3058

'WaitForFences': self._gen_replay_wait_for_fences,

3059

'WsiX11AssociateConnection': self._gen_replay_wsi_associate_connection,

3060

'WsiX11GetMSC': self._gen_replay_wsi_get_msc,

3061

'WsiX11CreatePresentableImage': self._gen_replay_wsi_create_presentable_image,

3062

'WsiX11QueuePresent': self._gen_replay_wsi_queue_present,

3063

'FreeMemory': self._gen_replay_free_memory,

3064

'MapMemory': self._gen_replay_map_memory,

3065

'UnmapMemory': self._gen_replay_unmap_memory,

Tobin Ehlis

2015-02-03 14:41:26 -0700

[diff] [blame]

3066

'CmdBindDynamicMemoryView': self._gen_replay_bind_dynamic_memory_view,

3067

'UpdateDescriptors': self._gen_replay_update_descriptors,

Tobin Ehlis

2015-02-05 11:29:45 -0700

[diff] [blame]

3068

'CreateDescriptorSetLayout': self._gen_replay_create_descriptor_set_layout,

3069

'CmdWaitEvents': self._gen_replay_cmd_wait_events}

Tobin Ehlis

2015-01-22 12:29:31 -0700

[diff] [blame]

3070

# TODO : Need to guard CreateInstance with "if (!m_display->m_initedXGL)" check

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

3071

# Despite returning a value, don't check these funcs b/c custom code includes check already

Jon Ashburn

b1b63ed

2015-02-03 11:24:08 -0700

[diff] [blame]

3072

custom_check_ret_val = ['EnumerateGpus', 'GetGpuInfo', 'CreateDevice', 'GetExtensionSupport']

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

3073

# multi-gpu Open funcs w/ list of local params to create

3074

custom_open_params = {'OpenSharedMemory': (-1,),

3075

'OpenSharedQueueSemaphore': (-1,),

3076

'OpenPeerMemory': (-1,),

3077

'OpenPeerImage': (-1, -2,)}

3078

# Functions that create views are unique from other create functions

Jon Ashburn

b1b63ed

2015-02-03 11:24:08 -0700

[diff] [blame]

3079

create_view_list = ['CreateBufferView', 'CreateImageView', 'CreateColorAttachmentView', 'CreateDepthStencilView', 'CreateComputePipeline']

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

3080

# Functions to treat as "Create' that don't have 'Create' in the name

Tobin Ehlis

2015-01-20 13:50:59 -0700

[diff] [blame]

3081

special_create_list = ['LoadPipeline', 'AllocMemory', 'GetDeviceQueue', 'PinSystemMemory', 'AllocDescriptorSets']

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

3082

# A couple funcs use do while loops

3083

do_while_dict = {'GetFenceStatus': 'replayResult != pPacket->result && pPacket->result == XGL_SUCCESS', 'GetEventStatus': '(pPacket->result == XGL_EVENT_SET || pPacket->result == XGL_EVENT_RESET) && replayResult != pPacket->result'}

3084

rbody = []

3085

rbody.append('#define CHECK_RETURN_VALUE(entrypoint) returnValue = handle_replay_errors(#entrypoint, replayResult, pPacket->result, returnValue);\n')

3086

rbody.append('glv_replay::GLV_REPLAY_RESULT xglReplay::replay(glv_trace_packet_header *packet)')

3087

rbody.append('{')

3088

rbody.append(' glv_replay::GLV_REPLAY_RESULT returnValue = glv_replay::GLV_REPLAY_SUCCESS;')

3089

rbody.append(' XGL_RESULT replayResult = XGL_ERROR_UNKNOWN;')

3090

rbody.append(' switch (packet->packet_id)')

3091

rbody.append(' {')

Jon Ashburn

2015-02-03 08:57:28 -0700

[diff] [blame]

3092

rbody.append(' case GLV_TPI_XGL_xglApiVersion:')

3093

rbody.append(' break; // nothing to replay on the version packet')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

3094

for proto in self.protos:

3095

ret_value = False

3096

create_view = False

3097

create_func = False

Tobin Ehlis

2015-01-15 17:53:54 -0700

[diff] [blame]

3098

# TODO : How to handle void* return of GetProcAddr?

3099

if ('void' not in proto.ret) and (proto.name not in custom_check_ret_val):

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

3100

ret_value = True

3101

if proto.name in create_view_list:

3102

create_view = True

3103

elif 'Create' in proto.name or proto.name in special_create_list:

3104

create_func = True

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

3105

rbody.append(' case GLV_TPI_XGL_xgl%s:' % proto.name)

3106

rbody.append(' {')

3107

rbody.append(' struct_xgl%s* pPacket = (struct_xgl%s*)(packet->pBody);' % (proto.name, proto.name))

3108

if proto.name in custom_body_dict:

3109

rbody.append(custom_body_dict[proto.name]())

3110

else:

3111

if proto.name in custom_open_params:

3112

rbody.append(' XGL_DEVICE handle;')

3113

for pidx in custom_open_params[proto.name]:

Tobin Ehlis

2015-01-15 17:53:54 -0700

[diff] [blame]

3114

rbody.append(' %s local_%s;' % (proto.params[pidx].ty.replace('const ', '').strip('*'), proto.params[pidx].name))

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

3115

rbody.append(' handle = remap(pPacket->device);')

3116

elif create_view:

Tobin Ehlis

2015-01-15 17:53:54 -0700

[diff] [blame]

3117

rbody.append(' %s createInfo;' % (proto.params[1].ty.strip('*').replace('const ', '')))

3118

rbody.append(' memcpy(&createInfo, pPacket->pCreateInfo, sizeof(%s));' % (proto.params[1].ty.strip('*').replace('const ', '')))

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

3119

if 'CreateComputePipeline' == proto.name:

3120

rbody.append(' createInfo.cs.shader = remap(pPacket->pCreateInfo->cs.shader);')

Jon Ashburn

b1b63ed

2015-02-03 11:24:08 -0700

[diff] [blame]

3121

elif 'CreateBufferView' == proto.name:

3122

rbody.append(' createInfo.buffer = remap(pPacket->pCreateInfo->buffer);')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

3123

else:

3124

rbody.append(' createInfo.image = remap(pPacket->pCreateInfo->image);')

Tobin Ehlis

2015-01-15 17:53:54 -0700

[diff] [blame]

3125

rbody.append(' %s local_%s;' % (proto.params[-1].ty.strip('*').replace('const ', ''), proto.params[-1].name))

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

3126

elif create_func: # Declare local var to store created handle into

Tobin Ehlis

2015-01-15 17:53:54 -0700

[diff] [blame]

3127

rbody.append(' %s local_%s;' % (proto.params[-1].ty.strip('*').replace('const ', ''), proto.params[-1].name))

Tobin Ehlis

2015-01-20 13:50:59 -0700

[diff] [blame]

3128

if 'AllocDescriptorSets' == proto.name:

Jon Ashburn

2015-02-04 12:57:25 -0700

[diff] [blame]

3129

rbody.append(' %s local_%s[100];' % (proto.params[-2].ty.strip('*').replace('const ', ''), proto.params[-2].name))

3130

rbody.append(' XGL_DESCRIPTOR_SET_LAYOUT localDescSets[100];')

3131

rbody.append(' assert(pPacket->count <= 100);')

3132

rbody.append(' for (uint32_t i = 0; i < pPacket->count; i++)')

3133

rbody.append(' {')

3134

rbody.append(' localDescSets[i] = remap(pPacket->%s[i]);' % (proto.params[-3].name))

3135

rbody.append(' }')

3136

elif proto.name == 'ClearDescriptorSets':

3137

rbody.append(' XGL_DESCRIPTOR_SET localDescSets[100];')

3138

rbody.append(' assert(pPacket->count <= 100);')

3139

rbody.append(' for (uint32_t i = 0; i < pPacket->count; i++)')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

3140

rbody.append(' {')

Jon Ashburn

2015-02-04 12:57:25 -0700

[diff] [blame]

3141

rbody.append(' localDescSets[i] = remap(pPacket->%s[i]);' % (proto.params[-1].name))

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

3142

rbody.append(' }')

3143

elif proto.name in do_while_dict:

3144

rbody.append(' do {')

Jon Ashburn

ffd5f14

2015-02-03 13:39:05 -0700

[diff] [blame]

3145

elif proto.name == 'EnumerateLayers':

3146

rbody.append(' char **bufptr = GLV_NEW_ARRAY(char *, pPacket->maxLayerCount);')

3147

rbody.append(' char **ptrLayers = (pPacket->pOutLayers == NULL) ? bufptr : (char **) pPacket->pOutLayers;')

3148

rbody.append(' for (unsigned int i = 0; i < pPacket->maxLayerCount; i++)')

3149

rbody.append(' bufptr[i] = GLV_NEW_ARRAY(char, pPacket->maxStringSize);')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

3150

rr_string = ' '

3151

if ret_value:

3152

rr_string = ' replayResult = '

3153

rr_string += 'm_xglFuncs.real_xgl%s(' % proto.name

3154

for p in proto.params:

3155

# For last param of Create funcs, pass address of param

Tobin Ehlis

2015-01-20 13:50:59 -0700

[diff] [blame]

3156

if create_func:

3157

if p.name == proto.params[-1].name:

3158

rr_string += '&local_%s, ' % p.name

3159

elif proto.name == 'AllocDescriptorSets' and p.name == proto.params[-2].name:

3160

rr_string += 'local_%s, ' % p.name

3161

else:

3162

rr_string += '%s, ' % self._get_packet_param(p.ty, p.name)

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

3163

else:

3164

rr_string += '%s, ' % self._get_packet_param(p.ty, p.name)

3165

rr_string = '%s);' % rr_string[:-2]

Jon Ashburn

2015-02-04 12:57:25 -0700

[diff] [blame]

3166

if proto.name in custom_open_params:

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

3167

rr_list = rr_string.split(', ')

3168

rr_list[0] = rr_list[0].replace('remap(pPacket->device)', 'handle')

3169

for pidx in custom_open_params[proto.name]:

3170

rr_list[pidx] = '&local_%s' % proto.params[pidx].name

3171

rr_string = ', '.join(rr_list)

3172

rr_string += ');'

3173

elif create_view:

3174

rr_list = rr_string.split(', ')

3175

rr_list[-2] = '&createInfo'

3176

rr_list[-1] = '&local_%s);' % proto.params[-1].name

3177

rr_string = ', '.join(rr_list)

3178

# this is a sneaky shortcut to use generic create code below to add_to_map

3179

create_func = True

Jon Ashburn

ffd5f14

2015-02-03 13:39:05 -0700

[diff] [blame]

3180

elif proto.name == 'EnumerateLayers':

3181

rr_string = rr_string.replace('pPacket->pOutLayers', 'ptrLayers')

Jon Ashburn

2015-02-04 12:57:25 -0700

[diff] [blame]

3182

elif proto.name == 'ClearDescriptorSets':

3183

rr_string = rr_string.replace('pPacket->pDescriptorSets', 'localDescSets')

3184

elif proto.name == 'AllocDescriptorSets':

3185

rr_string = rr_string.replace('pPacket->pSetLayouts', 'localDescSets')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

3186

rbody.append(rr_string)

3187

if 'DestroyDevice' in proto.name:

3188

rbody.append(' if (replayResult == XGL_SUCCESS)')

3189

rbody.append(' {')

3190

rbody.append(' rm_from_map(pPacket->device);')

3191

rbody.append(' m_display->m_initedXGL = false;')

3192

rbody.append(' }')

Jon Ashburn

2015-02-03 08:57:28 -0700

[diff] [blame]

3193

if 'DestroyInstance' in proto.name:

3194

rbody.append(' if (replayResult == XGL_SUCCESS)')

3195

rbody.append(' {')

Jon Ashburn

6f58a16

2015-02-03 09:17:12 -0700

[diff] [blame]

3196

rbody.append(' // TODO need to handle multiple instances and only clearing maps within an instance.')

3197

rbody.append(' // TODO this only works with a single instance used at any given time.')

3198

rbody.append(' clear_all_map_handles();')

Jon Ashburn

2015-02-03 08:57:28 -0700

[diff] [blame]

3199

rbody.append(' }')

Tobin Ehlis

2015-01-20 13:50:59 -0700

[diff] [blame]

3200

elif 'AllocDescriptorSets' in proto.name:

3201

rbody.append(' if (replayResult == XGL_SUCCESS)')

3202

rbody.append(' {')

3203

rbody.append(' for (uint32_t i = 0; i < local_pCount; i++) {')

Tobin Ehlis

2015-01-22 12:29:31 -0700

[diff] [blame]

3204

rbody.append(' add_to_map(&pPacket->%s[i], &local_%s[i]);' % (proto.params[-2].name, proto.params[-2].name))

Tobin Ehlis

2015-01-20 13:50:59 -0700

[diff] [blame]

3205

rbody.append(' }')

3206

rbody.append(' }')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

3207

elif create_func: # save handle mapping if create successful

3208

rbody.append(' if (replayResult == XGL_SUCCESS)')

3209

rbody.append(' {')

3210

rbody.append(' add_to_map(pPacket->%s, &local_%s);' % (proto.params[-1].name, proto.params[-1].name))

3211

if 'AllocMemory' == proto.name:

3212

rbody.append(' add_entry_to_mapData(local_%s, pPacket->pAllocInfo->allocationSize);' % (proto.params[-1].name))

3213

rbody.append(' }')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

3214

elif proto.name in do_while_dict:

3215

rbody[-1] = ' %s' % rbody[-1]

3216

rbody.append(' } while (%s);' % do_while_dict[proto.name])

Jon Ashburn

ffd5f14

2015-02-03 13:39:05 -0700

[diff] [blame]

3217

elif proto.name == 'EnumerateLayers':

3218

rbody.append(' for (unsigned int i = 0; i < pPacket->maxLayerCount; i++)')

3219

rbody.append(' GLV_DELETE(bufptr[i]);')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

3220

if ret_value:

3221

rbody.append(' CHECK_RETURN_VALUE(xgl%s);' % proto.name)

3222

if 'MsgCallback' in proto.name:

rbody.pop()

rbody.pop()

rbody.pop()

rbody.append(' // Just eating these calls as no way to restore dbg func ptr.')

3227

rbody.append(' break;')

3228

rbody.append(' }')

3229

rbody.append(' default:')

3230

rbody.append(' glv_LogWarn("Unrecognized packet_id %u, skipping\\n", packet->packet_id);')

3231

rbody.append(' returnValue = glv_replay::GLV_REPLAY_INVALID_ID;')

3232

rbody.append(' break;')

3233

rbody.append(' }')

3234

rbody.append(' return returnValue;')

3235

rbody.append('}')

3236

return "\n".join(rbody)

3237

3238

class GlaveTraceHeader(Subcommand):

3239

def generate_header(self):

3240

header_txt = []

3241

header_txt.append('#include "glvtrace_xgl_xgl_structs.h"')

3242

header_txt.append('#include "glvtrace_xgl_packet_id.h"\n')

3243

header_txt.append('void AttachHooks();')

3244

header_txt.append('void DetachHooks();')

3245

header_txt.append('void InitTracer();\n')

3246

return "\n".join(header_txt)

3247

3248

def generate_body(self):

3249

body = [self._generate_trace_func_ptrs(),

3250

self._generate_trace_func_protos()]

3251

3252

return "\n".join(body)

3253

3254

class GlaveTraceC(Subcommand):

3255

def generate_header(self):

3256

header_txt = []

3257

header_txt.append('#include "glv_platform.h"')

3258

header_txt.append('#include "glv_common.h"')

3259

header_txt.append('#include "glvtrace_xgl_xgl.h"')

3260

header_txt.append('#include "glvtrace_xgl_xgldbg.h"')

3261

header_txt.append('#include "glvtrace_xgl_xglwsix11ext.h"')

3262

header_txt.append('#include "glv_interconnect.h"')

3263

header_txt.append('#include "glv_filelike.h"')

3264

header_txt.append('#ifdef WIN32')

3265

header_txt.append('#include "mhook/mhook-lib/mhook.h"')

3266

header_txt.append('#endif')

3267

header_txt.append('#include "glv_trace_packet_utils.h"')

3268

header_txt.append('#include <stdio.h>\n')

3269

return "\n".join(header_txt)

3270

3271

def generate_body(self):

3272

body = [self._generate_func_ptr_assignments(),

3273

self._generate_attach_hooks(),

3274

self._generate_detach_hooks(),

Jon Ashburn

2014-12-16 18:37:04 -0700

[diff] [blame]

3275

self._generate_init_funcs(),

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

3276

self._generate_helper_funcs(),

3277

self._generate_trace_funcs()]

3278

3279

return "\n".join(body)

3280

3281

class GlavePacketID(Subcommand):

3282

def generate_header(self):

3283

header_txt = []

3284

header_txt.append('#pragma once\n')

3285

header_txt.append('#include "glv_trace_packet_utils.h"')

3286

header_txt.append('#include "glv_trace_packet_identifiers.h"')

3287

header_txt.append('#include "glv_interconnect.h"')

3288

header_txt.append('#include "glvtrace_xgl_xgl_structs.h"')

3289

header_txt.append('#include "glvtrace_xgl_xgldbg_structs.h"')

3290

header_txt.append('#include "glvtrace_xgl_xglwsix11ext_structs.h"')

3291

header_txt.append('#include "xgl_enum_string_helper.h"')

3292

header_txt.append('#define SEND_ENTRYPOINT_ID(entrypoint) ;')

3293

header_txt.append('//#define SEND_ENTRYPOINT_ID(entrypoint) glv_TraceInfo(#entrypoint "\\n");\n')

3294

header_txt.append('#define SEND_ENTRYPOINT_PARAMS(entrypoint, ...) ;')

3295

header_txt.append('//#define SEND_ENTRYPOINT_PARAMS(entrypoint, ...) glv_TraceInfo(entrypoint, __VA_ARGS__);\n')

3296

header_txt.append('#define CREATE_TRACE_PACKET(entrypoint, buffer_bytes_needed) \\')

3297

header_txt.append(' pHeader = glv_create_trace_packet(GLV_TID_XGL, GLV_TPI_XGL_##entrypoint, sizeof(struct_##entrypoint), buffer_bytes_needed);\n')

3298

header_txt.append('#define FINISH_TRACE_PACKET() \\')

3299

header_txt.append(' glv_finalize_trace_packet(pHeader); \\')

3300

header_txt.append(' glv_write_trace_packet(pHeader, glv_trace_get_trace_file()); \\')

3301

header_txt.append(' glv_delete_trace_packet(&pHeader);')

3302

return "\n".join(header_txt)

3303

3304

def generate_body(self):

3305

body = [self._generate_packet_id_enum(),

3306

self._generate_stringify_func(),

3307

self._generate_interp_func()]

3308

3309

return "\n".join(body)

3310

3311

class GlaveCoreStructs(Subcommand):

3312

def generate_header(self):

3313

header_txt = []

3314

header_txt.append('#pragma once\n')

3315

header_txt.append('#include "xgl.h"')

3316

header_txt.append('#include "glv_trace_packet_utils.h"\n')

3317

return "\n".join(header_txt)

3318

3319

def generate_body(self):

3320

body = [self._generate_struct_util_funcs(),

3321

self._generate_interp_funcs()]

3322

3323

return "\n".join(body)

3324

3325

class GlaveWsiHeader(Subcommand):

3326

def generate_header(self):

3327

header_txt = []

3328

header_txt.append('#pragma once\n')

3329

header_txt.append('#include "xgl.h"')

3330

header_txt.append('#include "xglWsiX11Ext.h"\n')

3331

header_txt.append('void AttachHooks_xglwsix11ext();')

3332

header_txt.append('void DetachHooks_xglwsix11ext();')

3333

return "\n".join(header_txt)

3334

3335

def generate_body(self):

3336

body = [self._generate_trace_func_ptrs_ext(),

3337

self._generate_trace_func_protos_ext()]

3338

3339

return "\n".join(body)

3340

3341

class GlaveWsiC(Subcommand):

3342

def generate_header(self):

3343

header_txt = []

3344

header_txt.append('#include "glv_platform.h"')

3345

header_txt.append('#include "glv_common.h"')

3346

header_txt.append('#include "glvtrace_xgl_xglwsix11ext.h"')

3347

header_txt.append('#include "glvtrace_xgl_xglwsix11ext_structs.h"')

3348

header_txt.append('#include "glvtrace_xgl_packet_id.h"')

3349

header_txt.append('#ifdef WIN32')

3350

header_txt.append('#include "mhook/mhook-lib/mhook.h"')

3351

header_txt.append('#endif')

3352

return "\n".join(header_txt)

3353

3354

def generate_body(self):

3355

body = [self._generate_func_ptr_assignments_ext(),

3356

self._generate_attach_hooks_ext(),

3357

self._generate_detach_hooks_ext(),

3358

self._generate_trace_funcs_ext()]

3359

3360

return "\n".join(body)

3361

3362

class GlaveWsiStructs(Subcommand):

3363

def generate_header(self):

3364

header_txt = []

3365

header_txt.append('#pragma once\n')

3366

header_txt.append('#include "xglWsiX11Ext.h"')

3367

header_txt.append('#include "glv_trace_packet_utils.h"\n')

3368

return "\n".join(header_txt)

3369

3370

def generate_body(self):

3371

body = [self._generate_interp_funcs_ext()]

3372

3373

return "\n".join(body)

3374

3375

class GlaveDbgHeader(Subcommand):

3376

def generate_header(self):

3377

header_txt = []

3378

header_txt.append('#pragma once\n')

3379

header_txt.append('#include "xgl.h"')

3380

header_txt.append('#include "xglDbg.h"\n')

3381

header_txt.append('void AttachHooks_xgldbg();')

3382

header_txt.append('void DetachHooks_xgldbg();')

3383

return "\n".join(header_txt)

3384

3385

def generate_body(self):

3386

body = [self._generate_trace_func_ptrs_ext('Dbg'),

3387

self._generate_trace_func_protos_ext('Dbg')]

3388

3389

return "\n".join(body)

3390

3391

class GlaveDbgC(Subcommand):

3392

def generate_header(self):

3393

header_txt = []

3394

header_txt.append('#include "glv_platform.h"')

3395

header_txt.append('#include "glv_common.h"')

3396

header_txt.append('#include "glvtrace_xgl_xgl.h"')

3397

header_txt.append('#include "glvtrace_xgl_xgldbg.h"')

3398

header_txt.append('#include "glvtrace_xgl_xgldbg_structs.h"')

3399

header_txt.append('#include "glvtrace_xgl_packet_id.h"')

3400

header_txt.append('#ifdef WIN32')

3401

header_txt.append('#include "mhook/mhook-lib/mhook.h"')

3402

header_txt.append('#endif')

3403

return "\n".join(header_txt)

3404

3405

def generate_body(self):

3406

body = [self._generate_func_ptr_assignments_ext('Dbg'),

3407

self._generate_attach_hooks_ext('Dbg'),

3408

self._generate_detach_hooks_ext('Dbg'),

3409

self._generate_trace_funcs_ext('Dbg')]

3410

3411

return "\n".join(body)

3412

3413

class GlaveDbgStructs(Subcommand):

3414

def generate_header(self):

3415

header_txt = []

3416

header_txt.append('#pragma once\n')

3417

header_txt.append('#include "xglDbg.h"')

3418

header_txt.append('#include "glv_trace_packet_utils.h"\n')

3419

return "\n".join(header_txt)

3420

3421

def generate_body(self):

3422

body = [self._generate_interp_funcs_ext('Dbg')]

3423

3424

return "\n".join(body)

3425

3426

class GlaveReplayHeader(Subcommand):

3427

def generate_header(self):

3428

header_txt = []

3429

header_txt.append('#pragma once\n')

3430

header_txt.append('#include <set>')

3431

header_txt.append('#include <map>')

3432

header_txt.append('#include <vector>')

Tony Barbour

2015-02-02 13:21:18 -0700

[diff] [blame]

3433

header_txt.append('#include <string>')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

3434

header_txt.append('#include <xcb/xcb.h>\n')

3435

header_txt.append('#include "glvreplay_window.h"')

3436

header_txt.append('#include "glvreplay_factory.h"')

3437

header_txt.append('#include "glv_trace_packet_identifiers.h"\n')

3438

header_txt.append('#include "xgl.h"')

3439

header_txt.append('#include "xglDbg.h"')

3440

header_txt.append('#include "xglWsiX11Ext.h"')

3441

return "\n".join(header_txt)

3442

3443

def generate_body(self):

3444

body = [self._generate_replay_class_decls(),

3445

self._generate_replay_func_ptrs(),

3446

self._generate_replay_class()]

3447

3448

return "\n".join(body)

3449

3450

class GlaveReplayC(Subcommand):

3451

def generate_header(self):

3452

header_txt = []

3453

header_txt.append('#include "glvreplay_xgl_replay.h"\n')

Jon Ashburn

2014-12-18 17:03:34 -0700

[diff] [blame]

3454

header_txt.append('#include "glvreplay_xgl.h"\n')

Tony Barbour

2015-02-02 13:21:18 -0700

[diff] [blame]

3455

header_txt.append('#include "glvreplay_xgl_write_ppm.h"\n')

3456

header_txt.append('#include "glvreplay_main.h"\n')

3457

header_txt.append('#include <algorithm>')

Jon Ashburn

215a966

2015-02-05 13:42:38 -0700

[diff] [blame]

3458

header_txt.append('extern glvreplay_settings *g_pReplaySettings;')

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

3459

header_txt.append('extern "C" {')

3460

header_txt.append('#include "glvtrace_xgl_xgl_structs.h"')

3461

header_txt.append('#include "glvtrace_xgl_xgldbg_structs.h"')

3462

header_txt.append('#include "glvtrace_xgl_xglwsix11ext_structs.h"')

3463

header_txt.append('#include "glvtrace_xgl_packet_id.h"')

3464

header_txt.append('#include "xgl_enum_string_helper.h"\n}\n')

3465

header_txt.append('#define APP_NAME "glvreplay_xgl"')

3466

header_txt.append('#define IDI_ICON 101\n')

3467

header_txt.append('static const char* g_extensions[] =')

3468

header_txt.append('{')

3469

header_txt.append(' "XGL_WSI_WINDOWS",')

3470

header_txt.append(' "XGL_TIMER_QUEUE",')

3471

header_txt.append(' "XGL_GPU_TIMESTAMP_CALIBRATION",')

3472

header_txt.append(' "XGL_DMA_QUEUE",')

3473

header_txt.append(' "XGL_COMMAND_BUFFER_CONTROL_FLOW",')

3474

header_txt.append(' "XGL_COPY_OCCLUSION_QUERY_DATA",')

3475

header_txt.append(' "XGL_ADVANCED_MULTISAMPLING",')

3476

header_txt.append(' "XGL_BORDER_COLOR_PALETTE"')

3477

header_txt.append('};')

3478

return "\n".join(header_txt)

3479

3480

def generate_body(self):

3481

body = [self._generate_replay_display_init_xgl(),

3482

self._generate_replay_display_init(),

3483

self._generate_replay_display_structors(),

3484

self._generate_replay_display_window(),

3485

self._generate_replay_structors(),

3486

self._generate_replay_init(),

Tobin Ehlis

2014-12-15 18:14:12 -0700

[diff] [blame]

3487

self._generate_replay_errors(),

Jon Ashburn

2014-12-18 17:03:34 -0700

[diff] [blame]

3488

self._generate_replay_validation_funcs(),

Tobin Ehlis