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

341

#EL == EnumerateLayers

342

#I think this another case where you have to make the real call prior to CREATE_TRACE_PACKET(). SInce you

343

#don't know how many layers will be returned or how big the strings will be. Alternatively, could be

344

#on the safe side of CREATE_TRACE_PACKET with maxStringSize*maxLayerCount.

345

#EL also needs a loop where add a trace buffer for each layer, depending on how you CREATE_TRACE_PACKET.

346

347

def _generate_trace_funcs(self):

348

func_body = []

349

for proto in self.protos:

Tobin Ehlis

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

[diff] [blame]

350

if 'UnmapMemory' == proto.name:

Tobin Ehlis

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

[diff] [blame]

351

func_body.append(self._gen_unmap_memory())

352

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

353

packet_update_txt = ''

354

return_txt = ''

355

packet_size = ''

356

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

357

buff_ptr_indices = []

358

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

359

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

360

if 'color' == p.name:

361

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

362

else:

363

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

364

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

365

if 'pData' == p.name:

366

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

367

packet_size += 'dataSize + '

368

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

Tobin Ehlis

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

[diff] [blame]

369

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

Tobin Ehlis

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

[diff] [blame]

370

else:

371

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

Tobin Ehlis

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

[diff] [blame]

372

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

Mark Lobodzinski

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

[diff] [blame]

373

packet_size += 'sizeof(void*) + '

Tobin Ehlis

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

[diff] [blame]

374

elif 'void' in p.ty:

Tobin Ehlis

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

[diff] [blame]

375

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

Tobin Ehlis

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

[diff] [blame]

376

elif 'char' in p.ty:

Chia-I Wu

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

[diff] [blame]

377

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

Tobin Ehlis

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

[diff] [blame]

378

elif 'DEVICE_CREATE_INFO' in p.ty:

379

packet_size += 'calc_size_XGL_DEVICE_CREATE_INFO(pCreateInfo) + '

380

elif 'pDataSize' in p.name:

Mark Lobodzinski

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

[diff] [blame]

381

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

Tobin Ehlis

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

[diff] [blame]

382

in_data_size = True;

383

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

384

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

385

else:

Tobin Ehlis

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

[diff] [blame]

386

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

Tobin Ehlis

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

[diff] [blame]

387

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

388

else:

389

if 'color' == p.name:

Mark Lobodzinski

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

[diff] [blame]

390

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

Tobin Ehlis

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

[diff] [blame]

391

else:

392

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

393

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]

394

if '*' in p.ty:

395

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

396

else:

397

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

Tobin Ehlis

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

[diff] [blame]

398

if '' == packet_size:

399

packet_size = '0'

400

else:

401

packet_size = packet_size.strip(' + ')

402

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

403

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

Tobin Ehlis

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

[diff] [blame]

404

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

Tobin Ehlis

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

[diff] [blame]

405

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

406

return_txt = 'result = '

407

if in_data_size:

Mark Lobodzinski

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

[diff] [blame]

408

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

Tobin Ehlis

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

[diff] [blame]

409

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

410

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

411

if 'EnumerateLayers' == proto.name:

412

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

Mark Lobodzinski

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

[diff] [blame]

413

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

Tobin Ehlis

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

[diff] [blame]

414

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

415

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

Chia-I Wu

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

[diff] [blame]

416

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

Mark Lobodzinski

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

[diff] [blame]

417

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

Tobin Ehlis

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

[diff] [blame^]

418

elif 'AllocDescriptorSets' == proto.name:

419

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

420

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

421

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

422

elif proto.name in ['CreateShader', 'CreateFramebuffer', 'CreateRenderPass', 'BeginCommandBuffer', 'CreateGraphicsPipeline', 'CreateComputePipeline']:

Tobin Ehlis

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

[diff] [blame]

423

func_body.append(' size_t customSize;')

424

if 'CreateShader' == proto.name:

425

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

426

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

427

elif 'CreateGraphicsPipeline' == proto.name:

428

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

429

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

Jon Ashburn

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

[diff] [blame]

430

elif 'CreateFramebuffer' == proto.name:

431

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

432

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

433

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

434

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

435

elif 'CreateRenderPass' == proto.name:

436

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

437

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

438

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

439

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

440

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

441

elif 'BeginCommandBuffer' == proto.name:

442

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

443

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

Tobin Ehlis

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

[diff] [blame]

444

else: #'CreateComputePipeline'

445

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

446

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

447

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

448

else:

449

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

450

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

451

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

452

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

453

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

454

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

455

func_body.append(' {')

Mark Lobodzinski

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

[diff] [blame]

456

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]

457

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

458

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

459

func_body.append(' }')

460

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

461

func_body.append(' FINISH_TRACE_PACKET();')

462

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

463

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

464

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

465

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

Mark Lobodzinski

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

[diff] [blame]

466

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]

467

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

Tobin Ehlis

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

[diff] [blame]

468

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

Chia-I Wu

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

[diff] [blame]

469

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]

470

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

471

func_body.append(' }')

Tobin Ehlis

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

[diff] [blame]

472

473

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

474

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

475

func_body.append(' FINISH_TRACE_PACKET();')

476

else:

477

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

478

for idx in buff_ptr_indices:

479

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

480

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

Tobin Ehlis

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

[diff] [blame]

481

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

Chia-I Wu

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

[diff] [blame]

482

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]

483

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]

484

deref = ''

485

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

486

deref = '*'

487

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]

488

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

489

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

490

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

Mark Lobodzinski

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

[diff] [blame]

491

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^]

492

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

493

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]

494

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

495

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

496

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

497

elif in_data_size:

498

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

499

else:

500

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))

501

else:

Tobin Ehlis

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

[diff] [blame]

502

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]

503

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

Jon Ashburn

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

[diff] [blame]

504

if proto.name in ['CreateShader', 'CreateFramebuffer', 'CreateRenderPass', 'BeginCommandBuffer', 'CreateGraphicsPipeline', 'CreateComputePipeline']:

Tobin Ehlis

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

[diff] [blame]

505

if 'CreateShader' == proto.name:

506

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

507

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

Jon Ashburn

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

[diff] [blame]

508

elif 'CreateFramebuffer' == proto.name:

509

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

510

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

511

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

512

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

513

elif 'CreateRenderPass' == proto.name:

514

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

515

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

516

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

517

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

518

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

519

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

520

elif 'BeginCommandBuffer' == proto.name:

Mark Lobodzinski

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

[diff] [blame]

521

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

Tobin Ehlis

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

[diff] [blame]

522

elif 'CreateGraphicsPipeline' == proto.name:

Mark Lobodzinski

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

[diff] [blame]

523

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]

524

else:

Mark Lobodzinski

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

[diff] [blame]

525

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]

526

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

527

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

Tobin Ehlis

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

[diff] [blame]

528

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

Tobin Ehlis

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

[diff] [blame]

529

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

530

for idx in buff_ptr_indices:

531

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

532

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

533

func_body.append(' FINISH_TRACE_PACKET();')

534

if 'AllocMemory' in proto.name:

535

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

536

elif 'FreeMemory' in proto.name:

537

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

Tobin Ehlis

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

[diff] [blame]

538

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

Tobin Ehlis

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

[diff] [blame]

539

func_body.append(' return result;')

540

func_body.append('}\n')

541

return "\n".join(func_body)

542

543

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

544

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

545

func_body = []

546

for proto in self.protos:

547

if func_class in proto.name:

548

packet_update_txt = ''

549

return_txt = ''

550

packet_size = ''

551

buff_ptr_indices = []

552

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

553

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

554

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

555

if 'Size' in p.name:

556

packet_size += p.name

557

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

Tobin Ehlis

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

[diff] [blame]

558

if 'char' in p.ty:

Chia-I Wu

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

[diff] [blame]

559

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

Tobin Ehlis

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

[diff] [blame]

560

elif 'Size' not in packet_size:

Tobin Ehlis

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

[diff] [blame]

561

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

Tobin Ehlis

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

[diff] [blame]

562

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

563

if 'pConnectionInfo' in p.name:

564

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

565

else:

566

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

567

if '' == packet_size:

568

packet_size = '0'

569

else:

570

packet_size = packet_size.strip(' + ')

571

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

572

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

Tobin Ehlis

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

[diff] [blame]

573

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

Tobin Ehlis

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

[diff] [blame]

574

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

575

return_txt = 'result = '

576

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

577

if proto.name in thread_once_funcs:

578

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

579

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

580

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

581

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

582

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

583

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

584

for idx in buff_ptr_indices:

Tobin Ehlis

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

[diff] [blame]

585

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

Chia-I Wu

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

[diff] [blame]

586

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]

587

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

588

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))

589

else:

Tobin Ehlis

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

[diff] [blame]

590

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]

591

if 'WsiX11AssociateConnection' in proto.name:

592

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

593

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

594

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

595

func_body.append(' }')

Tobin Ehlis

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

[diff] [blame]

596

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

Tobin Ehlis

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

[diff] [blame]

597

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

598

for idx in buff_ptr_indices:

599

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

600

func_body.append(' FINISH_TRACE_PACKET();')

Tobin Ehlis

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

[diff] [blame]

601

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

Tobin Ehlis

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

[diff] [blame]

602

func_body.append(' return result;')

603

func_body.append('}\n')

604

return "\n".join(func_body)

605

606

def _generate_helper_funcs(self):

607

hf_body = []

608

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

609

hf_body.append('typedef struct _XGLAllocInfo {')

610

hf_body.append(' XGL_GPU_SIZE size;')

611

hf_body.append(' XGL_GPU_MEMORY handle;')

Mark Lobodzinski

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

[diff] [blame]

612

hf_body.append(' void *pData;')

Tobin Ehlis

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

[diff] [blame]

613

hf_body.append(' BOOL valid;')

614

hf_body.append('} XGLAllocInfo;')

615

hf_body.append('typedef struct _XGLMemInfo {')

616

hf_body.append(' unsigned int numEntrys;')

617

hf_body.append(' XGLAllocInfo *pEntrys;')

618

hf_body.append(' XGLAllocInfo *pLastMapped;')

619

hf_body.append(' unsigned int capacity;')

620

hf_body.append('} XGLMemInfo;')

621

hf_body.append('')

622

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

623

hf_body.append('')

624

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

625

hf_body.append('{')

626

hf_body.append(' unsigned int i;')

627

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

628

hf_body.append(' {')

629

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

630

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

631

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

632

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

633

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

hf_body.append(' }')

hf_body.append('}')

hf_body.append('')

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

638

hf_body.append('{')

639

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

640

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

641

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

642

hf_body.append('')

643

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

644

hf_body.append('')

645

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

646

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

647

hf_body.append(' else')

648

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

649

hf_body.append('}')

650

hf_body.append('')

651

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

652

hf_body.append('{')

653

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

654

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

655

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

656

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

657

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

658

hf_body.append('}')

659

hf_body.append('')

660

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

661

hf_body.append('{')

662

hf_body.append(' unsigned int i;')

663

hf_body.append(' XGLAllocInfo *entry;')

664

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

665

hf_body.append(' {')

666

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

667

hf_body.append(' return NULL;')

668

hf_body.append(' }')

669

hf_body.append('')

670

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

671

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

672

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

673

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

674

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

675

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

676

hf_body.append(' }')

677

hf_body.append('')

678

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

679

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

680

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

681

hf_body.append(' {')

682

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

683

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

684

hf_body.append(' }')

685

hf_body.append('')

686

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

687

hf_body.append(' return NULL;')

688

hf_body.append('}')

689

hf_body.append('')

690

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

691

hf_body.append('{')

692

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

693

hf_body.append(' unsigned int i;')

694

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

695

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

696

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

697

hf_body.append(' {')

698

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

699

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

700

hf_body.append(' }')

701

hf_body.append('')

702

hf_body.append(' return NULL;')

703

hf_body.append('}')

704

hf_body.append('')

Mark Lobodzinski

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

[diff] [blame]

705

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]

706

hf_body.append('{')

707

hf_body.append(' XGLAllocInfo *entry;')

708

hf_body.append('')

709

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

710

hf_body.append(' init_mem_info();')

711

hf_body.append('')

712

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

713

hf_body.append(' if (entry)')

714

hf_body.append(' {')

715

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

716

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

717

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

718

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

719

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

720

hf_body.append(' }')

721

hf_body.append('}')

722

hf_body.append('')

Mark Lobodzinski

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

[diff] [blame]

723

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]

724

hf_body.append('{')

725

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

726

hf_body.append('')

727

hf_body.append(' if (entry)')

728

hf_body.append(' {')

729

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

730

hf_body.append(' }')

731

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

732

hf_body.append('}')

733

hf_body.append('')

734

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

735

hf_body.append('{')

736

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

737

hf_body.append('')

738

hf_body.append(' if (entry)')

739

hf_body.append(' {')

740

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

741

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

742

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

743

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

744

hf_body.append('')

745

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

746

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

747

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

748

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

749

hf_body.append(' delete_mem_info();')

750

hf_body.append(' }')

751

hf_body.append('}')

752

hf_body.append('')

Jon Ashburn

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

[diff] [blame]

753

754

Mark Lobodzinski

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

[diff] [blame]

755

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]

756

hf_body.append('{')

757

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

758

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

759

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

760

hf_body.append(' {')

761

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

762

hf_body.append(' ppOutNext = NULL;')

763

hf_body.append('')

764

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

765

hf_body.append(' {')

766

hf_body.append(' case XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO:')

767

hf_body.append(' {')

768

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

769

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

770

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

771

hf_body.append(' break;')

772

hf_body.append(' }')

773

hf_body.append(' default:')

774

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

775

hf_body.append(' }')

776

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

777

hf_body.append(' }')

778

hf_body.append(' return;')

779

hf_body.append('}')

780

781

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

782

hf_body.append('{')

783

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

784

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

785

hf_body.append(' {')

786

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

787

hf_body.append(' {')

788

hf_body.append(' case XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO:')

789

hf_body.append(' {')

790

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

791

hf_body.append(' break;')

792

hf_body.append(' }')

793

hf_body.append(' default:')

794

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

795

hf_body.append(' break;')

796

hf_body.append(' }')

797

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

798

hf_body.append(' }')

799

hf_body.append(' return siz;')

800

hf_body.append('}')

801

hf_body.append('')

Tobin Ehlis

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

[diff] [blame]

802

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

803

hf_body.append('{')

804

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

Tobin Ehlis

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

[diff] [blame]

805

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

Tobin Ehlis

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

[diff] [blame]

806

hf_body.append(' // constant buffers')

807

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

808

hf_body.append(' {')

Mark Lobodzinski

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

[diff] [blame]

809

hf_body.append(' uint32_t i;')

Tobin Ehlis

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

[diff] [blame]

810

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

811

hf_body.append(' {')

812

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

813

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

814

hf_body.append(' }')

Tobin Ehlis

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

[diff] [blame]

815

hf_body.append(' }')

Tobin Ehlis

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

[diff] [blame]

816

hf_body.append(' return size;')

817

hf_body.append('}')

818

hf_body.append('')

819

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)')

820

hf_body.append('{')

Tobin Ehlis

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

[diff] [blame]

821

hf_body.append(' uint32_t i;')

Tobin Ehlis

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

[diff] [blame]

822

hf_body.append(' // constant buffers')

823

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

824

hf_body.append(' {')

825

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

826

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

827

hf_body.append(' {')

828

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)')

834

hf_body.append('{')

Tobin Ehlis

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

[diff] [blame]

835

hf_body.append(' uint32_t i;')

Tobin Ehlis

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

[diff] [blame]

836

hf_body.append(' // constant buffers')

837

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

838

hf_body.append(' {')

839

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

840

hf_body.append(' {')

841

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

842

hf_body.append(' }')

843

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

844

hf_body.append(' }')

845

hf_body.append('}')

846

hf_body.append('')

Mark Lobodzinski

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

[diff] [blame]

847

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

Tobin Ehlis

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

[diff] [blame]

848

hf_body.append('{')

849

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

850

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

851

hf_body.append(' while (pNext)')

852

hf_body.append(' {')

853

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

854

hf_body.append(' {')

Tobin Ehlis

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

[diff] [blame]

855

pipe_state_list = ['IA_STATE_CREATE_INFO',

856

'TESS_STATE_CREATE_INFO',

857

'RS_STATE_CREATE_INFO',

858

'DS_STATE_CREATE_INFO',

859

'CB_STATE_CREATE_INFO',

860

'VP_STATE_CREATE_INFO',

861

'MS_STATE_CREATE_INFO'

862

]

863

for pipe_state in pipe_state_list:

864

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

865

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

866

hf_body.append(' break;')

Tobin Ehlis

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

[diff] [blame]

867

hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:')

868

hf_body.append(' {')

869

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

870

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

871

hf_body.append(' break;')

872

hf_body.append(' }')

873

hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:')

874

hf_body.append(' {')

875

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

876

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

877

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

878

hf_body.append(' break;')

879

hf_body.append(' }')

880

hf_body.append(' default:')

881

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

882

hf_body.append(' }')

883

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

884

hf_body.append(' }')

885

hf_body.append(' return totalStateSize;')

886

hf_body.append('}')

887

hf_body.append('')

Mark Lobodzinski

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

[diff] [blame]

888

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]

889

hf_body.append('{')

890

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

891

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

892

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

893

hf_body.append(' {')

894

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

895

hf_body.append(' ppOutNext = NULL;')

896

hf_body.append('')

897

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

898

hf_body.append(' {')

Tobin Ehlis

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

[diff] [blame]

899

# TODO : FINISH THIS LOOP AND DELETE CODE BELOW IT

900

for pipe_state in pipe_state_list:

901

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

902

hf_body.append(' {')

903

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

904

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

905

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

906

hf_body.append(' break;')

907

hf_body.append(' }')

Tobin Ehlis

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

[diff] [blame]

908

hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:')

909

hf_body.append(' {')

910

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

911

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

912

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

913

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

914

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

915

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

916

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

917

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

918

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

919

hf_body.append(' break;')

920

hf_body.append(' }')

921

hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:')

922

hf_body.append(' {')

923

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

924

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

925

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

926

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

927

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

928

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

929

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

930

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

931

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

932

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

933

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

934

hf_body.append(' break;')

935

hf_body.append(' }')

936

hf_body.append(' default:')

937

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

938

hf_body.append(' }')

939

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

940

hf_body.append(' }')

941

hf_body.append(' return;')

942

hf_body.append('}')

943

return "\n".join(hf_body)

944

945

def _generate_packet_id_enum(self):

946

pid_enum = []

947

pid_enum.append('enum GLV_TRACE_PACKET_ID_XGL')

948

pid_enum.append('{')

949

first_func = True

950

for proto in self.protos:

951

if first_func:

952

first_func = False

Jon Ashburn

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

[diff] [blame]

953

pid_enum.append(' GLV_TPI_XGL_xglApiVersion = GLV_TPI_BEGIN_API_HERE,')

954

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

Tobin Ehlis

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

[diff] [blame]

955

else:

956

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

957

pid_enum.append('};\n')

958

return "\n".join(pid_enum)

959

960

def _generate_stringify_func(self):

961

func_body = []

962

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

963

func_body.append('{')

964

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

965

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

Jon Ashburn

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

[diff] [blame]

966

func_body.append(' case GLV_TPI_XGL_xglApiVersion:')

967

func_body.append(' {')

968

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

969

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

970

func_body.append(' return str;')

971

func_body.append(' }')

Tobin Ehlis

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

[diff] [blame]

972

for proto in self.protos:

973

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

974

func_body.append(' {')

975

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

976

print_vals = ''

977

create_func = False

978

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

979

create_func = True

980

for p in proto.params:

981

last_param = False

982

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

983

last_param = True

984

if last_param and create_func: # last param of create func

985

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

986

else:

987

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

988

if last_param == True:

989

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

990

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

991

else:

992

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

993

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

994

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

995

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

996

func_body.append(' return str;')

997

func_body.append(' }')

998

func_body.append(' default:')

999

func_body.append(' return NULL;')

1000

func_body.append(' }')

1001

func_body.append('};\n')

1002

return "\n".join(func_body)

1003

1004

def _generate_interp_func(self):

1005

interp_func_body = []

1006

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

1007

interp_func_body.append('{')

1008

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

1009

interp_func_body.append(' {')

1010

interp_func_body.append(' return NULL;')

1011

interp_func_body.append(' }')

1012

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

1013

interp_func_body.append(' {')

Jon Ashburn

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

[diff] [blame]

1014

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

1015

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

Tobin Ehlis

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

[diff] [blame]

1016

for proto in self.protos:

1017

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

1018

header_prefix = 'h'

1019

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

1020

header_prefix = 'pH'

1021

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

1022

interp_func_body.append(' default:')

1023

interp_func_body.append(' return NULL;')

1024

interp_func_body.append(' }')

1025

interp_func_body.append(' return NULL;')

1026

interp_func_body.append('}')

1027

return "\n".join(interp_func_body)

1028

1029

def _generate_struct_util_funcs(self):

1030

pid_enum = []

1031

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

1032

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

1033

pid_enum.append('{')

Chia-I Wu

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

[diff] [blame]

1034

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]

1035

pid_enum.append('}\n')

1036

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)')

1037

pid_enum.append('{')

1038

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]

1039

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

1040

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]

1041

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

1042

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

1043

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

1044

pid_enum.append('};\n')

1045

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

1046

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

1047

pid_enum.append('{')

Mark Lobodzinski

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

[diff] [blame]

1048

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

Tobin Ehlis

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

[diff] [blame]

1049

pid_enum.append(' uint32_t i;')

1050

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

1051

pid_enum.append(' {')

Chia-I Wu

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

[diff] [blame]

1052

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

Tobin Ehlis

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

[diff] [blame]

1053

pid_enum.append(' }')

Jon Ashburn

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

[diff] [blame]

1054

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

1055

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

1056

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

1057

pid_enum.append(' {')

1058

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

1059

pid_enum.append(' {')

1060

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

1061

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

1062

pid_enum.append(' {')

1063

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

1064

pid_enum.append(' }')

1065

pid_enum.append(' }')

1066

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

1067

pid_enum.append(' }')

1068

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]

1069

pid_enum.append('}\n')

1070

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)')

1071

pid_enum.append('{')

1072

pid_enum.append(' uint32_t i;')

1073

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

1074

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

1075

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

1076

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

1077

pid_enum.append(' {')

Mark Lobodzinski

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

[diff] [blame]

1078

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]

1079

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

1080

pid_enum.append(' {')

Chia-I Wu

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

[diff] [blame]

1081

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]

1082

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

1083

pid_enum.append(' }')

1084

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

1085

pid_enum.append(' }')

Jon Ashburn

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

[diff] [blame]

1086

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

1087

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

1088

pid_enum.append(' {')

1089

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

1090

pid_enum.append(' {')

1091

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

1092

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

1093

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]

1094

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]

1095

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

1096

pid_enum.append(' {')

1097

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

1098

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

1099

pid_enum.append(' }')

1100

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

1101

pid_enum.append(' }')

1102

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

1103

pid_enum.append(' }')

Tobin Ehlis

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

[diff] [blame]

1104

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

1105

pid_enum.append('}\n')

1106

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

1107

pid_enum.append('{')

1108

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')

1109

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

1110

pid_enum.append(' {')

Jon Ashburn

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

[diff] [blame]

1111

pid_enum.append(' uint32_t i;')

Mark Lobodzinski

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

[diff] [blame]

1112

pid_enum.append(' const char** pNames;')

Tobin Ehlis

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

[diff] [blame]

1113

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')

1114

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

1115

pid_enum.append(' {')

Mark Lobodzinski

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

[diff] [blame]

1116

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);')

1117

pid_enum.append(' pNames = (const char**)pXGL_DEVICE_CREATE_INFO->ppEnabledExtensionNames;')

Tobin Ehlis

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

[diff] [blame]

1118

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

1119

pid_enum.append(' {')

Mark Lobodzinski

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

[diff] [blame]

1120

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]

1121

pid_enum.append(' }')

1122

pid_enum.append(' }')

Jon Ashburn

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

[diff] [blame]

1123

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);')

1124

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

1125

pid_enum.append(' {')

1126

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

1127

pid_enum.append(' {')

Mark Lobodzinski

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

[diff] [blame]

1128

pid_enum.append(' pNext->ppActiveLayerNames = (const char**) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)(pNext->ppActiveLayerNames));')

1129

pid_enum.append(' pNames = (const char**)pNext->ppActiveLayerNames;')

Jon Ashburn

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

[diff] [blame]

1130

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

1131

pid_enum.append(' {')

Mark Lobodzinski

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

[diff] [blame]

1132

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]

1133

pid_enum.append(' }')

1134

pid_enum.append(' }')

1135

pid_enum.append(' pNext = ( XGL_LAYER_CREATE_INFO *) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);')

1136

pid_enum.append(' }')

Tobin Ehlis

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

[diff] [blame]

1137

pid_enum.append(' }\n')

1138

pid_enum.append(' return pXGL_DEVICE_CREATE_INFO;')

1139

pid_enum.append('}\n')

1140

pid_enum.append('static void interpret_pipeline_shader(glv_trace_packet_header* pHeader, XGL_PIPELINE_SHADER* pShader)')

1141

pid_enum.append('{')

Tobin Ehlis

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

[diff] [blame]

1142

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

1143

pid_enum.append(' {')

Tobin Ehlis

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

[diff] [blame]

1144

pid_enum.append(' // constant buffers')

1145

pid_enum.append(' if (pShader->linkConstBufferCount > 0)')

1146

pid_enum.append(' {')

Mark Lobodzinski

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

[diff] [blame]

1147

pid_enum.append(' uint32_t i;')

Tobin Ehlis

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

[diff] [blame]

1148

pid_enum.append(' pShader->pLinkConstBufferInfo = (const XGL_LINK_CONST_BUFFER*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pShader->pLinkConstBufferInfo);')

1149

pid_enum.append(' for (i = 0; i < pShader->linkConstBufferCount; i++)')

1150

pid_enum.append(' {')

1151

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]

1152

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]

1153

pid_enum.append(' }')

1154

pid_enum.append(' }')

1155

pid_enum.append(' }')

1156

pid_enum.append('}\n')

1157

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

1158

return "\n".join(pid_enum)

1159

1160

def _generate_interp_funcs(self):

1161

# Custom txt for given function and parameter. First check if param is NULL, then insert txt if not

Tobin Ehlis

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

[diff] [blame]

1162

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]

1163

'pInfo->pAppName = (const char*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pAppInfo->pAppName);\n',

1164

'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]

1165

'CreateShader' : {'param': 'pCreateInfo', 'txt': ['XGL_SHADER_CREATE_INFO* pInfo = (XGL_SHADER_CREATE_INFO*)pPacket->pCreateInfo;\n',

1166

'pInfo->pCode = glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pCode);']},

1167

'CreateFramebuffer' : {'param': 'pCreateInfo', 'txt': ['XGL_FRAMEBUFFER_CREATE_INFO* pInfo = (XGL_FRAMEBUFFER_CREATE_INFO*)pPacket->pCreateInfo;\n',

1168

'pInfo->pColorAttachments = (XGL_COLOR_ATTACHMENT_BIND_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pColorAttachments);\n',

1169

'pInfo->pDepthStencilAttachment = (XGL_DEPTH_STENCIL_BIND_INFO*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pDepthStencilAttachment);\n']},

1170

'CreateRenderPass' : {'param': 'pCreateInfo', 'txt': ['XGL_RENDER_PASS_CREATE_INFO* pInfo = (XGL_RENDER_PASS_CREATE_INFO*)pPacket->pCreateInfo;\n',

1171

'pInfo->pColorLoadOps = (XGL_ATTACHMENT_LOAD_OP*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pColorLoadOps);\n',

1172

'pInfo->pColorStoreOps = (XGL_ATTACHMENT_STORE_OP*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pColorStoreOps);\n',

1173

'pInfo->pColorLoadClearValues = (XGL_CLEAR_COLOR*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pColorLoadClearValues);\n']},

1174

'BeginCommandBuffer' : {'param': 'pBeginInfo', 'txt': ['assert(pPacket->pBeginInfo->sType == XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO);\n',

1175

'// 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]

1176

'void** ppNextVoidPtr = (void**)&pPacket->pBeginInfo->pNext;\n',

1177

'*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]

1178

'XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO* pNext = (XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO*)pPacket->pBeginInfo->pNext;\n',

1179

'while ((NULL != pNext) && (XGL_NULL_HANDLE != pNext))\n', '{\n',

1180

' switch(pNext->sType)\n', ' {\n',

1181

' case XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO:\n',

1182

' {\n',

Mark Lobodzinski

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

[diff] [blame]

1183

' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',

1184

' *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',

1189

' }\n',

1190

' pNext = (XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO*)pNext->pNext;\n',

1191

'}']},

1192

'CreateGraphicsPipeline' : {'param': 'pCreateInfo', 'txt': ['assert(pPacket->pCreateInfo->sType == XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO);\n',

1193

'// 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]

1194

'void** ppNextVoidPtr = (void**)&pPacket->pCreateInfo->pNext;\n',

1195

'*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]

1196

'XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pPacket->pCreateInfo->pNext;\n',

1197

'while ((NULL != pNext) && (XGL_NULL_HANDLE != pNext))\n', '{\n',

Tobin Ehlis

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

[diff] [blame]

1198

' switch(pNext->sType)\n', ' {\n',

1199

' case XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO:\n',

1200

' case XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO:\n',

1201

' case XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO:\n',

Tobin Ehlis

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

[diff] [blame]

1202

' case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:\n',

Tobin Ehlis

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

[diff] [blame]

1203

' case XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO:\n',

1204

' case XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO:\n',

1205

' case XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO:\n',

Tobin Ehlis

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

[diff] [blame]

1206

' {\n',

Mark Lobodzinski

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

[diff] [blame]

1207

' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',

1208

' *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]

1209

' break;\n',

1210

' }\n',

1211

' case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:\n',

1212

' {\n',

Mark Lobodzinski

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

[diff] [blame]

1213

' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',

1214

' *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]

1215

' interpret_pipeline_shader(pHeader, &pNext->shader);\n',

Tobin Ehlis

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

[diff] [blame]

1216

' break;\n',

1217

' }\n',

1218

' case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:\n',

1219

' {\n',

Mark Lobodzinski

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

[diff] [blame]

1220

' void** ppNextVoidPtr = (void**)&pNext->pNext;\n',

Tobin Ehlis

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

[diff] [blame]

1221

' 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]

1222

' *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]

1223

' pVi->pVertexBindingDescriptions = (XGL_VERTEX_INPUT_BINDING_DESCRIPTION*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVi->pVertexBindingDescriptions);\n',

1224

' 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',

1229

' }\n',

1230

' pNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pNext->pNext;\n',

1231

'}']},

Tobin Ehlis

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

[diff] [blame]

1232

'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]

1233

if_body = []

Jon Ashburn

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

[diff] [blame]

1234

if_body.append('typedef struct struct_xglApiVersion {')

1235

if_body.append(' glv_trace_packet_header* header;')

1236

if_body.append(' uint32_t version;')

1237

if_body.append('} struct_xglApiVersion;\n')

1238

if_body.append('static struct_xglApiVersion* interpret_body_as_xglApiVersion(glv_trace_packet_header* pHeader, BOOL check_version)')

1239

if_body.append('{')

1240

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

1241

if_body.append(' pPacket->header = pHeader;')

1242

if_body.append(' if (check_version && pPacket->version != XGL_API_VERSION)')

1243

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);')

1244

if_body.append(' return pPacket;')

1245

if_body.append('}\n')

Tobin Ehlis

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

[diff] [blame]

1246

for proto in self.protos:

1247

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

1248

if 'UnmapMemory' == proto.name:

Mark Lobodzinski

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

[diff] [blame]

1249

proto.params.append(xgl.Param("void*", "pData"))

Tobin Ehlis

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

[diff] [blame]

1250

if_body.append('typedef struct struct_xgl%s {' % proto.name)

1251

if_body.append(' glv_trace_packet_header* header;')

1252

for p in proto.params:

1253

if '[4]' in p.ty:

1254

if_body.append(' %s %s[4];' % (p.ty.strip('[4]'), p.name))

1255

else:

1256

if_body.append(' %s %s;' % (p.ty, p.name))

Mark Lobodzinski

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

[diff] [blame]

1257

if 'void' != proto.ret:

Tobin Ehlis

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

[diff] [blame]

1258

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

1259

if_body.append('} struct_xgl%s;\n' % proto.name)

1260

if_body.append('static struct_xgl%s* interpret_body_as_xgl%s(glv_trace_packet_header* pHeader)' % (proto.name, proto.name))

1261

if_body.append('{')

1262

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

1263

if_body.append(' pPacket->header = pHeader;')

1264

for p in proto.params:

1265

if '*' in p.ty:

1266

if 'DEVICE_CREATE_INFO' in p.ty:

1267

if_body.append(' pPacket->%s = interpret_XGL_DEVICE_CREATE_INFO(pHeader, (intptr_t)pPacket->%s);' % (p.name, p.name))

1268

else:

1269

if_body.append(' pPacket->%s = (%s)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->%s);' % (p.name, p.ty, p.name))

1270

if proto.name in custom_case_dict and p.name == custom_case_dict[proto.name]['param']:

1271

if_body.append(' if (pPacket->%s != NULL)' % custom_case_dict[proto.name]['param'])

1272

if_body.append(' {')

1273

if_body.append(' %s' % " ".join(custom_case_dict[proto.name]['txt']))

1274

if_body.append(' }')

1275

if_body.append(' return pPacket;')

1276

if_body.append('}\n')

1277

return "\n".join(if_body)

1278

1279

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

1280

if_body = []

1281

for proto in self.protos:

1282

if func_class in proto.name:

1283

if_body.append('typedef struct struct_xgl%s {' % proto.name)

1284

if_body.append(' glv_trace_packet_header* pHeader;')

1285

for p in proto.params:

1286

if_body.append(' %s %s;' % (p.ty, p.name))

Mark Lobodzinski

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

[diff] [blame]

1287

if 'void' != proto.ret:

Tobin Ehlis

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

[diff] [blame]

1288

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

1289

if_body.append('} struct_xgl%s;\n' % proto.name)

1290

if_body.append('static struct_xgl%s* interpret_body_as_xgl%s(glv_trace_packet_header* pHeader)' % (proto.name, proto.name))

1291

if_body.append('{')

1292

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

1293

if_body.append(' pPacket->pHeader = pHeader;')

1294

for p in proto.params:

1295

if '*' in p.ty:

1296

if_body.append(' pPacket->%s = (%s)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->%s);' % (p.name, p.ty, p.name))

1297

if_body.append(' return pPacket;')

1298

if_body.append('}\n')

1299

return "\n".join(if_body)

1300

1301

def _generate_replay_class_decls(self):

1302

cd_body = []

1303

cd_body.append('class ApiReplay {')

1304

cd_body.append('public:')

1305

cd_body.append(' virtual ~ApiReplay() { }')

1306

cd_body.append(' virtual enum glv_replay::GLV_REPLAY_RESULT replay(glv_trace_packet_header * packet) = 0;')

1307

cd_body.append(' virtual int init(glv_replay::Display & disp) = 0;')

Mark Lobodzinski

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

[diff] [blame]

1308

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]

1309

cd_body.append(' virtual glv_replay::GLV_REPLAY_RESULT pop_validation_msgs() = 0;')

Tobin Ehlis

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

[diff] [blame]

1310

cd_body.append('};\n')

1311

cd_body.append('class xglDisplay: public glv_replay::DisplayImp {')

1312

cd_body.append('friend class xglReplay;')

1313

cd_body.append('public:')

1314

cd_body.append(' xglDisplay();')

1315

cd_body.append(' ~xglDisplay();')

1316

cd_body.append(' int init(const unsigned int gpu_idx);')

1317

cd_body.append(' int set_window(glv_window_handle hWindow, unsigned int width, unsigned int height);')

1318

cd_body.append(' int create_window(const unsigned int width, const unsigned int height);')

1319

cd_body.append(' void resize_window(const unsigned int width, const unsigned int height);')

1320

cd_body.append(' void process_event();')

1321

cd_body.append(' // XGL_DEVICE get_device() { return m_dev[m_gpuIdx];}')

1322

cd_body.append('#if defined(WIN32)')

1323

cd_body.append(' HWND get_window_handle() { return m_windowHandle; }')

1324

cd_body.append('#elif defined(PLATFORM_LINUX)')

1325

cd_body.append(' xcb_window_t get_window_handle() { return m_XcbWindow; }')

1326

cd_body.append('#endif')

1327

cd_body.append('private:')

1328

cd_body.append(' XGL_RESULT init_xgl(const unsigned int gpu_idx);')

1329

cd_body.append(' bool m_initedXGL;')

1330

cd_body.append('#if defined(WIN32)')

1331

cd_body.append(' HWND m_windowHandle;')

1332

cd_body.append('#elif defined(PLATFORM_LINUX)')

1333

cd_body.append(' XGL_WSI_X11_CONNECTION_INFO m_WsiConnection;')

1334

cd_body.append(' xcb_screen_t *m_pXcbScreen;')

1335

cd_body.append(' xcb_window_t m_XcbWindow;')

1336

cd_body.append('#endif')

1337

cd_body.append(' unsigned int m_windowWidth;')

1338

cd_body.append(' unsigned int m_windowHeight;')

1339

cd_body.append('#if 0')

1340

cd_body.append(' XGL_DEVICE m_dev[XGL_MAX_PHYSICAL_GPUS];')

Mark Lobodzinski

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

[diff] [blame]

1341

cd_body.append(' uint32_t m_gpuCount;')

Tobin Ehlis

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

[diff] [blame]

1342

cd_body.append(' unsigned int m_gpuIdx;')

1343

cd_body.append(' XGL_PHYSICAL_GPU m_gpus[XGL_MAX_PHYSICAL_GPUS];')

1344

cd_body.append(' XGL_PHYSICAL_GPU_PROPERTIES m_gpuProps[XGL_MAX_PHYSICAL_GPUS];')

1345

cd_body.append('#endif')

Mark Lobodzinski

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

[diff] [blame]

1346

cd_body.append(' std::vector<char *>m_extensions;')

Tobin Ehlis

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

[diff] [blame]

1347

cd_body.append('};\n')

1348

cd_body.append('typedef struct _XGLAllocInfo {')

1349

cd_body.append(' XGL_GPU_SIZE size;')

Mark Lobodzinski

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

[diff] [blame]

1350

cd_body.append(' void *pData;')

Tobin Ehlis

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

[diff] [blame]

1351

cd_body.append('} XGLAllocInfo;')

1352

return "\n".join(cd_body)

1353

1354

def _generate_replay_func_ptrs(self):

1355

xf_body = []

1356

xf_body.append('struct xglFuncs {')

1357

xf_body.append(' void init_funcs(void * libHandle);')

1358

xf_body.append(' void *m_libHandle;\n')

1359

for proto in self.protos:

1360

xf_body.append(' typedef %s( XGLAPI * type_xgl%s)(' % (proto.ret, proto.name))

1361

for p in proto.params:

1362

if '[4]' in p.ty:

1363

xf_body.append(' %s %s[4],' % (p.ty.strip('[4]'), p.name))

1364

else:

1365

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

1366

xf_body[-1] = xf_body[-1].replace(',', ');')

1367

xf_body.append(' type_xgl%s real_xgl%s;' % (proto.name, proto.name))

1368

xf_body.append('};')

1369

return "\n".join(xf_body)

1370

1371

def _map_decl(self, type1, type2, name):

1372

return ' std::map<%s, %s> %s;' % (type1, type2, name)

1373

1374

def _add_to_map_decl(self, type1, type2, name):

1375

txt = ' void add_to_map(%s* pTraceVal, %s* pReplayVal)\n {\n' % (type1, type2)

1376

txt += ' assert(pTraceVal != NULL);\n'

1377

txt += ' assert(pReplayVal != NULL);\n'

1378

txt += ' %s[*pTraceVal] = *pReplayVal;\n }' % name

1379

return txt

1380

1381

def _rm_from_map_decl(self, ty, name):

1382

txt = ' void rm_from_map(const %s& key)\n {\n' % (ty)

1383

txt += ' %s.erase(key);\n }' % name

1384

return txt

1385

1386

def _remap_decl(self, ty, name):

1387

txt = ' %s remap(const %s& value)\n {\n' % (ty, ty)

1388

txt += ' std::map<%s, %s>::const_iterator q = %s.find(value);\n' % (ty, ty, name)

1389

txt += ' return (q == %s.end()) ? XGL_NULL_HANDLE : q->second;\n }' % name

1390

return txt

1391

1392

def _generate_replay_class(self):

Tobin Ehlis

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

[diff] [blame]

1393

# obj_map_dict = {'m_gpus': 'XGL_PHYSICAL_GPU',

1394

# 'm_devices': 'XGL_DEVICE',

1395

# 'm_queues': 'XGL_QUEUE',

1396

# 'm_memories': 'XGL_GPU_MEMORY',

1397

# 'm_images': 'XGL_IMAGE',

1398

# 'm_imageViews': 'XGL_IMAGE_VIEW',

1399

# 'm_colorTargetViews': 'XGL_COLOR_ATTACHMENT_VIEW',

1400

# 'm_depthStencilViews': 'XGL_DEPTH_STENCIL_VIEW',

1401

# 'm_shader': 'XGL_SHADER',

1402

# 'm_pipeline': 'XGL_PIPELINE',

1403

# 'm_pipelineDelta': 'XGL_PIPELINE_DELTA',

1404

# 'm_sampler': 'XGL_SAMPLER',

1405

# 'm_descriptorSets': 'XGL_DESCRIPTOR_SET',

1406

# 'm_viewportStates': 'XGL_DYNAMIC_VP_STATE_OBJECT',

1407

# 'm_rasterStates': 'XGL_DYNAMIC_RS_STATE_OBJECT',

1408

# 'm_colorBlendStates': 'XGL_DYNAMIC_CB_STATE_OBJECT',

1409

# 'm_depthStencilStates': 'XGL_DYNAMIC_DS_STATE_OBJECT',

1410

# 'm_cmdBuffers': 'XGL_CMD_BUFFER',

1411

# 'm_fences': 'XGL_FENCE',

1412

# 'm_queue_semaphores': 'XGL_QUEUE_SEMAPHORE',

1413

# 'm_events': 'XGL_EVENT',

1414

# 'm_queryPools': 'XGL_QUERY_POOL',

1415

# }

1416

# Create dict mapping member var names to XGL type (i.e. 'm_imageViews' : 'XGL_IMAGE_VIEW')

1417

obj_map_dict = {}

1418

for ty in xgl.object_type_list:

1419

if ty in xgl.object_parent_list:

1420

continue

1421

mem_var = ty.replace('XGL_', '').lower()

1422

mem_var_list = mem_var.split('_')

1423

# mem_var = 'm_%s%ss' % (mem_var_list[0], "".join([x.title() for x in mem_var_list[1:]])

1424

mem_var = 'm_%s%ss' % (mem_var_list[0], "".join([m.title() for m in mem_var_list[1:]]))

1425

obj_map_dict[mem_var] = ty

Tobin Ehlis

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

[diff] [blame]

1426

rc_body = []

1427

rc_body.append('class xglReplay : public ApiReplay {')

1428

rc_body.append('public:')

1429

rc_body.append(' ~xglReplay();')

Peter Lohrmann

be24ff0

2015-01-08 19:47:03 -0800

[diff] [blame]

1430

rc_body.append(' xglReplay();\n')

Tobin Ehlis

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

[diff] [blame]

1431

rc_body.append(' int init(glv_replay::Display & disp);')

1432

rc_body.append(' xglDisplay * get_display() {return m_display;}')

1433

rc_body.append(' glv_replay::GLV_REPLAY_RESULT replay(glv_trace_packet_header *packet);')

1434

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]

1435

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]

1436

rc_body.append(' glv_replay::GLV_REPLAY_RESULT pop_validation_msgs();')

Tobin Ehlis

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

[diff] [blame]

1437

rc_body.append('private:')

1438

rc_body.append(' struct xglFuncs m_xglFuncs;')

Tobin Ehlis

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

[diff] [blame]

1439

rc_body.append(' xglDisplay *m_display;')

Tobin Ehlis

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

[diff] [blame]

1440

rc_body.append(' struct shaderPair {')

1441

rc_body.append(' XGL_SHADER *addr;')

1442

rc_body.append(' XGL_SHADER val;')

1443

rc_body.append(' };')

Jon Ashburn

2014-12-18 17:03:34 -0700

[diff] [blame]

1444

rc_body.append(' struct validationMsg {')

1445

rc_body.append(' XGL_VALIDATION_LEVEL validationLevel;')

1446

rc_body.append(' XGL_BASE_OBJECT srcObject;')

Mark Lobodzinski

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

[diff] [blame]

1447

rc_body.append(' size_t location;')

1448

rc_body.append(' int32_t msgCode;')

Jon Ashburn

2014-12-18 17:03:34 -0700

[diff] [blame]

1449

rc_body.append(' char msg[256];')

1450

rc_body.append(' };')

1451

rc_body.append(' std::vector<struct validationMsg> m_validationMsgs;')

Tobin Ehlis

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

[diff] [blame]

1452

rc_body.append(self._map_decl('XGL_GPU_MEMORY', 'XGLAllocInfo', 'm_mapData'))

1453

# Custom code for 1-off memory mapping functions

1454

rc_body.append(' void add_entry_to_mapData(XGL_GPU_MEMORY handle, XGL_GPU_SIZE size)')

1455

rc_body.append(' {')

1456

rc_body.append(' XGLAllocInfo info;')

1457

rc_body.append(' info.pData = NULL;')

1458

rc_body.append(' info.size = size;')

1459

rc_body.append(' m_mapData.insert(std::pair<XGL_GPU_MEMORY, XGLAllocInfo>(handle, info));')

1460

rc_body.append(' }')

Mark Lobodzinski

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

[diff] [blame]

1461

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]

1462

rc_body.append(' {')

1463

rc_body.append(' std::map<XGL_GPU_MEMORY,XGLAllocInfo>::iterator it = m_mapData.find(handle);')

1464

rc_body.append(' if (it == m_mapData.end())')

1465

rc_body.append(' {')

1466

rc_body.append(' glv_LogWarn("add_mapping_to_mapData() could not find entry\\n");')

1467

rc_body.append(' return;')

1468

rc_body.append(' }')

1469

rc_body.append(' XGLAllocInfo &info = it->second;')

1470

rc_body.append(' if (info.pData != NULL)')

1471

rc_body.append(' {')

1472

rc_body.append(' glv_LogWarn("add_mapping_to_mapData() data already mapped overwrite old mapping\\n");')

1473

rc_body.append(' }')

1474

rc_body.append(' info.pData = pData;')

1475

rc_body.append(' }')

1476

rc_body.append(' void rm_entry_from_mapData(XGL_GPU_MEMORY handle)')

1477

rc_body.append(' {')

1478

rc_body.append(' std::map<XGL_GPU_MEMORY,XGLAllocInfo>::iterator it = m_mapData.find(handle);')

1479

rc_body.append(' if (it == m_mapData.end())')

1480

rc_body.append(' return;')

1481

rc_body.append(' m_mapData.erase(it);')

1482

rc_body.append(' }')

Mark Lobodzinski

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

[diff] [blame]

1483

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]

1484

rc_body.append(' {')

1485

rc_body.append(' std::map<XGL_GPU_MEMORY,XGLAllocInfo>::iterator it = m_mapData.find(handle);')

1486

rc_body.append(' if (it == m_mapData.end())')

1487

rc_body.append(' return;\n')

1488

rc_body.append(' XGLAllocInfo &info = it->second;')

1489

rc_body.append(' if (!pData || !info.pData)')

1490

rc_body.append(' {')

1491

rc_body.append(' glv_LogWarn("rm_mapping_from_mapData() null src or dest pointers\\n");')

1492

rc_body.append(' info.pData = NULL;')

1493

rc_body.append(' return;')

1494

rc_body.append(' }')

1495

rc_body.append(' memcpy(info.pData, pData, info.size);')

1496

rc_body.append(' info.pData = NULL;')

1497

rc_body.append(' }\n')

1498

rc_body.append(' /*std::map<XGL_PHYSICAL_GPU, XGL_PHYSICAL_GPU> m_gpus;')

1499

rc_body.append(' void add_to_map(XGL_PHYSICAL_GPU* pTraceGpu, XGL_PHYSICAL_GPU* pReplayGpu)')

1500

rc_body.append(' {')

1501

rc_body.append(' assert(pTraceGpu != NULL);')

1502

rc_body.append(' assert(pReplayGpu != NULL);')

1503

rc_body.append(' m_gpus[*pTraceGpu] = *pReplayGpu;')

1504

rc_body.append(' }\n')

1505

rc_body.append(' XGL_PHYSICAL_GPU remap(const XGL_PHYSICAL_GPU& gpu)')

1506

rc_body.append(' {')

1507

rc_body.append(' std::map<XGL_PHYSICAL_GPU, XGL_PHYSICAL_GPU>::const_iterator q = m_gpus.find(gpu);')

1508

rc_body.append(' return (q == m_gpus.end()) ? XGL_NULL_HANDLE : q->second;')

1509

rc_body.append(' }*/\n')

1510

rc_body.append(' void clear_all_map_handles()\n {')

1511

for var in sorted(obj_map_dict):

1512

rc_body.append(' %s.clear();' % var)

1513

rc_body.append(' }')

1514

for var in sorted(obj_map_dict):

1515

rc_body.append(self._map_decl(obj_map_dict[var], obj_map_dict[var], var))

1516

rc_body.append(self._add_to_map_decl(obj_map_dict[var], obj_map_dict[var], var))

1517

rc_body.append(self._rm_from_map_decl(obj_map_dict[var], var))

1518

rc_body.append(self._remap_decl(obj_map_dict[var], var))

Tobin Ehlis

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

[diff] [blame]

1519

# XGL_DYNAMIC_STATE_OBJECT code

1520

state_obj_remap_types = xgl.object_dynamic_state_list

1521

rc_body.append(' XGL_DYNAMIC_STATE_OBJECT remap(const XGL_DYNAMIC_STATE_OBJECT& state)\n {')

1522

rc_body.append(' XGL_DYNAMIC_STATE_OBJECT obj;')

Tobin Ehlis

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

[diff] [blame]

1523

for t in state_obj_remap_types:

1524

rc_body.append(' if ((obj = remap(static_cast <%s> (state))) != XGL_NULL_HANDLE)' % t)

1525

rc_body.append(' return obj;')

1526

rc_body.append(' return XGL_NULL_HANDLE;\n }')

Tobin Ehlis

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

[diff] [blame]

1527

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]

1528

for t in state_obj_remap_types:

1529

rc_body.append(' rm_from_map(static_cast <%s> (state));' % t)

1530

rc_body.append(' }')

1531

# OBJECT code

1532

rc_body.append(' XGL_OBJECT remap(const XGL_OBJECT& object)\n {')

1533

rc_body.append(' XGL_OBJECT obj;')

Tobin Ehlis

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

[diff] [blame]

1534

obj_remap_types = xgl.object_list

Tobin Ehlis

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

[diff] [blame]

1535

for var in obj_remap_types:

1536

rc_body.append(' if ((obj = remap(static_cast <%s> (object))) != XGL_NULL_HANDLE)' % (var))

1537

rc_body.append(' return obj;')

1538

rc_body.append(' return XGL_NULL_HANDLE;\n }')

1539

rc_body.append(' void rm_from_map(const XGL_OBJECT & objKey)\n {')

1540

for var in obj_remap_types:

1541

rc_body.append(' rm_from_map(static_cast <%s> (objKey));' % (var))

1542

rc_body.append(' }')

1543

rc_body.append(' XGL_BASE_OBJECT remap(const XGL_BASE_OBJECT& object)\n {')

1544

rc_body.append(' XGL_BASE_OBJECT obj;')

1545

base_obj_remap_types = ['XGL_DEVICE', 'XGL_QUEUE', 'XGL_GPU_MEMORY', 'XGL_OBJECT']

1546

for t in base_obj_remap_types:

1547

rc_body.append(' if ((obj = remap(static_cast <%s> (object))) != XGL_NULL_HANDLE)' % t)

1548

rc_body.append(' return obj;')

1549

rc_body.append(' return XGL_NULL_HANDLE;\n }')

1550

rc_body.append('};')

1551

return "\n".join(rc_body)

1552

1553

def _generate_replay_display_init_xgl(self):

1554

dix_body = []

1555

dix_body.append('XGL_RESULT xglDisplay::init_xgl(unsigned int gpu_idx)')

1556

dix_body.append('{')

1557

dix_body.append('#if 0')

1558

dix_body.append(' XGL_APPLICATION_INFO appInfo = {};')

1559

dix_body.append(' appInfo.pAppName = APP_NAME;')

1560

dix_body.append(' appInfo.pEngineName = "";')

1561

dix_body.append(' appInfo.apiVersion = XGL_API_VERSION;')

1562

dix_body.append(' XGL_RESULT res = xglInitAndEnumerateGpus(&appInfo, NULL, XGL_MAX_PHYSICAL_GPUS, &m_gpuCount, m_gpus);')

1563

dix_body.append(' if ( res == XGL_SUCCESS ) {')

1564

dix_body.append(' // retrieve the GPU information for all GPUs')

Mark Lobodzinski

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

[diff] [blame]

1565

dix_body.append(' for( uint32_t gpu = 0; gpu < m_gpuCount; gpu++)')

Tobin Ehlis

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

[diff] [blame]

1566

dix_body.append(' {')

Mark Lobodzinski

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

[diff] [blame]

1567

dix_body.append(' size_t gpuInfoSize = sizeof(m_gpuProps[0]);\n')

Tobin Ehlis

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

[diff] [blame]

1568

dix_body.append(' // get the GPU physical properties:')

1569

dix_body.append(' res = xglGetGpuInfo( m_gpus[gpu], XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES, &gpuInfoSize, &m_gpuProps[gpu]);')

1570

dix_body.append(' if (res != XGL_SUCCESS)')

1571

dix_body.append(' glv_LogWarn("Failed to retrieve properties for gpu[%d] result %d\\n", gpu, res);')

1572

dix_body.append(' }')

1573

dix_body.append(' res = XGL_SUCCESS;')

1574

dix_body.append(' } else if ((gpu_idx + 1) > m_gpuCount) {')

1575

dix_body.append(' glv_LogError("xglInitAndEnumerate number of gpus does not include requested index: num %d, requested %d\\n", m_gpuCount, gpu_idx);')

1576

dix_body.append(' return -1;')

1577

dix_body.append(' } else {')

1578

dix_body.append(' glv_LogError("xglInitAndEnumerate failed\\n");')

1579

dix_body.append(' return res;')

1580

dix_body.append(' }')

1581

dix_body.append(' // TODO add multi-gpu support always use gpu[gpu_idx] for now')

1582

dix_body.append(' // get all extensions supported by this device gpu[gpu_idx]')

1583

dix_body.append(' // first check if extensions are available and save a list of them')

1584

dix_body.append(' bool foundWSIExt = false;')

1585

dix_body.append(' for( int ext = 0; ext < sizeof( extensions ) / sizeof( extensions[0] ); ext++)')

1586

dix_body.append(' {')

1587

dix_body.append(' res = xglGetExtensionSupport( m_gpus[gpu_idx], extensions[ext] );')

1588

dix_body.append(' if (res == XGL_SUCCESS) {')

Mark Lobodzinski

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

[diff] [blame]

1589

dix_body.append(' m_extensions.push_back((char *) extensions[ext]);')

Tobin Ehlis

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

[diff] [blame]

1590

dix_body.append(' if (!strcmp(extensions[ext], "XGL_WSI_WINDOWS"))')

1591

dix_body.append(' foundWSIExt = true;')

1592

dix_body.append(' }')

1593

dix_body.append(' }')

1594

dix_body.append(' if (!foundWSIExt) {')

1595

dix_body.append(' glv_LogError("XGL_WSI_WINDOWS extension not supported by gpu[%d]\\n", gpu_idx);')

1596

dix_body.append(' return XGL_ERROR_INCOMPATIBLE_DEVICE;')

1597

dix_body.append(' }')

1598

dix_body.append(' // TODO generalize this: use one universal queue for now')

1599

dix_body.append(' XGL_DEVICE_QUEUE_CREATE_INFO dqci = {};')

1600

dix_body.append(' dqci.queueCount = 1;')

1601

dix_body.append(' dqci.queueType = XGL_QUEUE_UNIVERSAL;')

1602

dix_body.append(' // create the device enabling validation level 4')

Mark Lobodzinski

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

[diff] [blame]

1603

dix_body.append(' const char * const * extNames = &m_extensions[0];')

Tobin Ehlis

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

[diff] [blame]

1604

dix_body.append(' XGL_DEVICE_CREATE_INFO info = {};')

1605

dix_body.append(' info.queueRecordCount = 1;')

1606

dix_body.append(' info.pRequestedQueues = &dqci;')

Mark Lobodzinski

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

[diff] [blame]

1607

dix_body.append(' info.extensionCount = static_cast <uint32_t> (m_extensions.size());')

Tobin Ehlis

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

[diff] [blame]

1608

dix_body.append(' info.ppEnabledExtensionNames = extNames;')

1609

dix_body.append(' info.flags = XGL_DEVICE_CREATE_VALIDATION;')

1610

dix_body.append(' info.maxValidationLevel = XGL_VALIDATION_LEVEL_4;')

Mark Lobodzinski

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

[diff] [blame]

1611

dix_body.append(' bool32_t xglTrue = XGL_TRUE;')

Tobin Ehlis

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

[diff] [blame]

1612

dix_body.append(' res = xglDbgSetGlobalOption( XGL_DBG_OPTION_BREAK_ON_ERROR, sizeof( xglTrue ), &xglTrue );')

1613

dix_body.append(' if (res != XGL_SUCCESS)')

1614

dix_body.append(' glv_LogWarn("Could not set debug option break on error\\n");')

1615

dix_body.append(' res = xglCreateDevice( m_gpus[0], &info, &m_dev[gpu_idx]);')

1616

dix_body.append(' return res;')

1617

dix_body.append('#else')

1618

dix_body.append(' return XGL_ERROR_INITIALIZATION_FAILED;')

1619

dix_body.append('#endif')

1620

dix_body.append('}')

1621

return "\n".join(dix_body)

1622

1623

def _generate_replay_display_init(self):

1624

di_body = []

1625

di_body.append('int xglDisplay::init(const unsigned int gpu_idx)')

1626

di_body.append('{')

1627

di_body.append(' //m_gpuIdx = gpu_idx;')

1628

di_body.append('#if 0')

1629

di_body.append(' XGL_RESULT result = init_xgl(gpu_idx);')

1630

di_body.append(' if (result != XGL_SUCCESS) {')

1631

di_body.append(' glv_LogError("could not init xgl library");')

1632

di_body.append(' return -1;')

1633

di_body.append(' } else {')

1634

di_body.append(' m_initedXGL = true;')

1635

di_body.append(' }')

1636

di_body.append('#endif')

1637

di_body.append('#if defined(PLATFORM_LINUX)')

1638

di_body.append(' const xcb_setup_t *setup;')

1639

di_body.append(' xcb_screen_iterator_t iter;')

1640

di_body.append(' int scr;')

1641

di_body.append(' xcb_connection_t *pConnection;')

1642

di_body.append(' pConnection = xcb_connect(NULL, &scr);')

1643

di_body.append(' setup = xcb_get_setup(pConnection);')

1644

di_body.append(' iter = xcb_setup_roots_iterator(setup);')

1645

di_body.append(' while (scr-- > 0)')

1646

di_body.append(' xcb_screen_next(&iter);')

1647

di_body.append(' m_pXcbScreen = iter.data;')

1648

di_body.append(' m_WsiConnection.pConnection = pConnection;')

1649

di_body.append(' m_WsiConnection.root = m_pXcbScreen->root;')

1650

di_body.append('#endif')

1651

di_body.append(' return 0;')

1652

di_body.append('}')

1653

return "\n".join(di_body)

1654

1655

def _generate_replay_display_structors(self):

1656

ds_body = []

1657

ds_body.append('xglDisplay::xglDisplay()')

1658

ds_body.append(' : m_initedXGL(false),')

1659

ds_body.append(' m_windowWidth(0),')

1660

ds_body.append(' m_windowHeight(0)')

1661

ds_body.append('{')

1662

ds_body.append('#if defined(WIN32)')

1663

ds_body.append(' m_windowHandle = NULL;')

1664

ds_body.append('#elif defined(PLATFORM_LINUX)')

1665

ds_body.append(' m_WsiConnection.pConnection = NULL;')

1666

ds_body.append(' m_WsiConnection.root = 0;')

1667

ds_body.append(' m_WsiConnection.provider = 0;')

1668

ds_body.append(' m_pXcbScreen = NULL;')

1669

ds_body.append(' m_XcbWindow = 0;')

1670

ds_body.append('#endif')

1671

ds_body.append('}')

1672

ds_body.append('xglDisplay::~xglDisplay()')

1673

ds_body.append('{')

1674

ds_body.append('#ifdef PLATFORM_LINUX')

1675

ds_body.append(' if (m_XcbWindow != 0)')

1676

ds_body.append(' {')

1677

ds_body.append(' xcb_destroy_window(m_WsiConnection.pConnection, m_XcbWindow);')

1678

ds_body.append(' }')

1679

ds_body.append(' if (m_WsiConnection.pConnection != NULL)')

1680

ds_body.append(' {')

1681

ds_body.append(' xcb_disconnect(m_WsiConnection.pConnection);')

1682

ds_body.append(' }')

1683

ds_body.append('#endif')

1684

ds_body.append('}')

1685

return "\n".join(ds_body)

1686

1687

def _generate_replay_display_window(self):

1688

dw_body = []

1689

dw_body.append('#if defined(WIN32)')

1690

dw_body.append('LRESULT WINAPI WindowProcXgl( HWND window, unsigned int msg, WPARAM wp, LPARAM lp)')

1691

dw_body.append('{')

1692

dw_body.append(' switch(msg)')

1693

dw_body.append(' {')

1694

dw_body.append(' case WM_CLOSE:')

1695

dw_body.append(' DestroyWindow( window);')

1696

dw_body.append(' // fall-thru')

1697

dw_body.append(' case WM_DESTROY:')

1698

dw_body.append(' PostQuitMessage(0) ;')

1699

dw_body.append(' return 0L ;')

1700

dw_body.append(' default:')

1701

dw_body.append(' return DefWindowProc( window, msg, wp, lp ) ;')

1702

dw_body.append(' }')

1703

dw_body.append('}')

1704

dw_body.append('#endif')

1705

dw_body.append('int xglDisplay::set_window(glv_window_handle hWindow, unsigned int width, unsigned int height)')

1706

dw_body.append('{')

1707

dw_body.append('#if defined(WIN32)')

1708

dw_body.append(' m_windowHandle = hWindow;')

1709

dw_body.append('#elif defined(PLATFORM_LINUX)')

1710

dw_body.append(' m_XcbWindow = hWindow;')

1711

dw_body.append('#endif')

1712

dw_body.append(' m_windowWidth = width;')

1713

dw_body.append(' m_windowHeight = height;')

1714

dw_body.append(' return 0;')

1715

dw_body.append('}\n')

1716

dw_body.append('int xglDisplay::create_window(const unsigned int width, const unsigned int height)')

1717

dw_body.append('{')

1718

dw_body.append('#if defined(WIN32)')

1719

dw_body.append(' // Register Window class')

1720

dw_body.append(' WNDCLASSEX wcex = {};')

1721

dw_body.append(' wcex.cbSize = sizeof( WNDCLASSEX);')

1722

dw_body.append(' wcex.style = CS_HREDRAW | CS_VREDRAW;')

1723

dw_body.append(' wcex.lpfnWndProc = WindowProcXgl;')

1724

dw_body.append(' wcex.cbClsExtra = 0;')

1725

dw_body.append(' wcex.cbWndExtra = 0;')

1726

dw_body.append(' wcex.hInstance = GetModuleHandle(0);')

1727

dw_body.append(' wcex.hIcon = LoadIcon(wcex.hInstance, MAKEINTRESOURCE( IDI_ICON));')

1728

dw_body.append(' wcex.hCursor = LoadCursor( NULL, IDC_ARROW);')

1729

dw_body.append(' wcex.hbrBackground = ( HBRUSH )( COLOR_WINDOW + 1);')

1730

dw_body.append(' wcex.lpszMenuName = NULL;')

1731

dw_body.append(' wcex.lpszClassName = APP_NAME;')

1732

dw_body.append(' wcex.hIconSm = LoadIcon( wcex.hInstance, MAKEINTRESOURCE( IDI_ICON));')

1733

dw_body.append(' if( !RegisterClassEx( &wcex))')

1734

dw_body.append(' {')

1735

dw_body.append(' glv_LogError("Failed to register windows class\\n");')

1736

dw_body.append(' return -1;')

1737

dw_body.append(' }\n')

1738

dw_body.append(' // create the window')

1739

dw_body.append(' m_windowHandle = CreateWindow(APP_NAME, APP_NAME, WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU, 0, 0,')

1740

dw_body.append(' width, height, NULL, NULL, wcex.hInstance, NULL);\n')

1741

dw_body.append(' if (m_windowHandle)')

1742

dw_body.append(' {')

1743

dw_body.append(' ShowWindow( m_windowHandle, SW_SHOWDEFAULT);')

1744

dw_body.append(' m_windowWidth = width;')

1745

dw_body.append(' m_windowHeight = height;')

1746

dw_body.append(' } else {')

1747

dw_body.append(' glv_LogError("Failed to create window\\n");')

1748

dw_body.append(' return -1;')

1749

dw_body.append(' }')

1750

dw_body.append(' return 0;')

1751

dw_body.append('#elif defined(PLATFORM_LINUX)\n')

1752

dw_body.append(' uint32_t value_mask, value_list[32];')

1753

dw_body.append(' m_XcbWindow = xcb_generate_id(m_WsiConnection.pConnection);\n')

1754

dw_body.append(' value_mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;')

1755

dw_body.append(' value_list[0] = m_pXcbScreen->black_pixel;')

1756

dw_body.append(' value_list[1] = XCB_EVENT_MASK_KEY_RELEASE |')

1757

dw_body.append(' XCB_EVENT_MASK_EXPOSURE;\n')

1758

dw_body.append(' xcb_create_window(m_WsiConnection.pConnection,')

1759

dw_body.append(' XCB_COPY_FROM_PARENT,')

1760

dw_body.append(' m_XcbWindow, m_WsiConnection.root,')

1761

dw_body.append(' 0, 0, width, height, 0,')

1762

dw_body.append(' XCB_WINDOW_CLASS_INPUT_OUTPUT,')

1763

dw_body.append(' m_pXcbScreen->root_visual,')

1764

dw_body.append(' value_mask, value_list);\n')

1765

dw_body.append(' xcb_map_window(m_WsiConnection.pConnection, m_XcbWindow);')

1766

dw_body.append(' xcb_flush(m_WsiConnection.pConnection);')

1767

dw_body.append(' return 0;')

1768

dw_body.append('#endif')

1769

dw_body.append('}\n')

1770

dw_body.append('void xglDisplay::resize_window(const unsigned int width, const unsigned int height)')

1771

dw_body.append('{')

1772

dw_body.append('#if defined(WIN32)')

1773

dw_body.append(' if (width != m_windowWidth || height != m_windowHeight)')

1774

dw_body.append(' {')

1775

dw_body.append(' SetWindowPos(get_window_handle(), HWND_TOP, 0, 0, width, height, SWP_NOMOVE);')

1776

dw_body.append(' m_windowWidth = width;')

1777

dw_body.append(' m_windowHeight = height;')

1778

dw_body.append(' }')

1779

dw_body.append('#elif defined(PLATFORM_LINUX)')

1780

dw_body.append(' if (width != m_windowWidth || height != m_windowHeight)')

1781

dw_body.append(' {')

1782

dw_body.append(' uint32_t values[2];')

1783

dw_body.append(' values[0] = width;')

1784

dw_body.append(' values[1] = height;')

1785

dw_body.append(' xcb_configure_window(m_WsiConnection.pConnection, m_XcbWindow, XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT, values);')

1786

dw_body.append(' m_windowWidth = width;')

1787

dw_body.append(' m_windowHeight = height;')

1788

dw_body.append(' }')

1789

dw_body.append('#endif')

1790

dw_body.append('}\n')

1791

dw_body.append('void xglDisplay::process_event()')

1792

dw_body.append('{')

1793

dw_body.append('}')

1794

return "\n".join(dw_body)

1795

1796

def _generate_replay_structors(self):

1797

rs_body = []

Peter Lohrmann

be24ff0

2015-01-08 19:47:03 -0800

[diff] [blame]

1798

rs_body.append('xglReplay::xglReplay()')

Tobin Ehlis

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

[diff] [blame]

1799

rs_body.append('{')

1800

rs_body.append(' m_display = new xglDisplay();')

Tobin Ehlis

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

[diff] [blame]

1801

rs_body.append('}\n')

1802

rs_body.append('xglReplay::~xglReplay()')

1803

rs_body.append('{')

1804

rs_body.append(' delete m_display;')

1805

rs_body.append(' glv_platform_close_library(m_xglFuncs.m_libHandle);')

1806

rs_body.append('}')

1807

return "\n".join(rs_body)

1808

1809

def _generate_replay_init(self):

1810

ri_body = []

1811

ri_body.append('int xglReplay::init(glv_replay::Display & disp)')

1812

ri_body.append('{')

1813

ri_body.append(' int err;')

1814

ri_body.append('#if defined _WIN64')

1815

ri_body.append(' HMODULE handle = LoadLibrary("xgl64.dll" );')

1816

ri_body.append('#elif defined _WIN32')

1817

ri_body.append(' HMODULE handle = LoadLibrary("xgl32.dll" );')

1818

ri_body.append('#elif defined PLATFORM_LINUX')

1819

ri_body.append(' void * handle = dlopen("libXGL.so", RTLD_LAZY);')

1820

ri_body.append('#endif\n')

1821

ri_body.append(' if (handle == NULL) {')

1822

ri_body.append(' glv_LogError("Failed to open xgl library.\\n");')

1823

ri_body.append(' return -1;')

1824

ri_body.append(' }')

1825

ri_body.append(' m_xglFuncs.init_funcs(handle);')

1826

ri_body.append(' disp.set_implementation(m_display);')

1827

ri_body.append(' if ((err = m_display->init(disp.get_gpu())) != 0) {')

1828

ri_body.append(' glv_LogError("Failed to init XGL display.\\n");')

1829

ri_body.append(' return err;')

1830

ri_body.append(' }')

1831

ri_body.append(' if (disp.get_window_handle() == 0)')

1832

ri_body.append(' {')

1833

ri_body.append(' if ((err = m_display->create_window(disp.get_width(), disp.get_height())) != 0) {')

1834

ri_body.append(' glv_LogError("Failed to create Window\\n");')

1835

ri_body.append(' return err;')

1836

ri_body.append(' }')

1837

ri_body.append(' }')

1838

ri_body.append(' else')

1839

ri_body.append(' {')

1840

ri_body.append(' if ((err = m_display->set_window(disp.get_window_handle(), disp.get_width(), disp.get_height())) != 0)')

1841

ri_body.append(' {')

1842

ri_body.append(' glv_LogError("Failed to set Window\\n");')

1843

ri_body.append(' return err;')

1844

ri_body.append(' }')

1845

ri_body.append(' }')

1846

ri_body.append(' return 0;')

1847

ri_body.append('}')

1848

return "\n".join(ri_body)

1849

Tobin Ehlis

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

[diff] [blame]

1850

def _generate_replay_errors(self):

1851

re_body = []

1852

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)')

1853

re_body.append('{')

1854

re_body.append(' glv_replay::GLV_REPLAY_RESULT res = resIn;')

1855

re_body.append(' if (resCall != resTrace) {')

1856

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]

1857

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]

1858

re_body.append(' res = glv_replay::GLV_REPLAY_BAD_RETURN;')

1859

re_body.append(' }')

1860

re_body.append('#if 0')

1861

re_body.append(' if (resCall != XGL_SUCCESS) {')

1862

re_body.append(' glv_LogWarn("API call (%s) returned failed result %s\\n", entrypointName, string_XGL_RESULT(resCall));')

1863

re_body.append(' }')

1864

re_body.append('#endif')

1865

re_body.append(' return res;')

1866

re_body.append('}')

1867

return "\n".join(re_body)

1868

Jon Ashburn

2014-12-18 17:03:34 -0700

[diff] [blame]

1869

def _generate_replay_validation_funcs(self):

1870

rvf_body = []

Mark Lobodzinski

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

[diff] [blame]

1871

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]

1872

rvf_body.append('{')

1873

rvf_body.append(' struct validationMsg msgObj;')

1874

rvf_body.append(' msgObj.validationLevel = validationLevel;')

1875

rvf_body.append(' msgObj.srcObject = srcObject;')

1876

rvf_body.append(' msgObj.location = location;')

1877

rvf_body.append(' msgObj.msgCode = msgCode;')

1878

rvf_body.append(' strncpy(msgObj.msg, pMsg, 256);')

1879

rvf_body.append(" msgObj.msg[255] = '\\0';")

1880

rvf_body.append(' m_validationMsgs.push_back(msgObj);')

1881

rvf_body.append('}\n')

1882

rvf_body.append('glv_replay::GLV_REPLAY_RESULT xglReplay::pop_validation_msgs()')

1883

rvf_body.append('{')

1884

rvf_body.append(' if (m_validationMsgs.size() == 0)')

1885

rvf_body.append(' return glv_replay::GLV_REPLAY_SUCCESS;')

1886

rvf_body.append(' m_validationMsgs.clear();')

1887

rvf_body.append(' return glv_replay::GLV_REPLAY_VALIDATION_ERROR;')

1888

rvf_body.append('}')

1889

return "\n".join(rvf_body)

1890

Tobin Ehlis

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

[diff] [blame]

1891

def _generate_replay_init_funcs(self):

1892

rif_body = []

1893

rif_body.append('void xglFuncs::init_funcs(void * handle)\n{\n m_libHandle = handle;')

1894

for proto in self.protos:

1895

rif_body.append(' real_xgl%s = (type_xgl%s)(glv_platform_get_library_entrypoint(handle, "xgl%s"));' % (proto.name, proto.name, proto.name))

1896

rif_body.append('}')

1897

return "\n".join(rif_body)

1898

1899

def _get_packet_param(self, t, n):

1900

# list of types that require remapping

Tobin Ehlis

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

[diff] [blame]

1901

remap_list = xgl.object_type_list

1902

#[

1903

# 'XGL_PHYSICAL_GPU',

# 'XGL_DEVICE',

# 'XGL_QUEUE',

# 'XGL_GPU_MEMORY',

# 'XGL_IMAGE',

# 'XGL_IMAGE_VIEW',

# 'XGL_COLOR_ATTACHMENT_VIEW',

1910

# 'XGL_DEPTH_STENCIL_VIEW',

1911

# 'XGL_SHADER',

1912

# 'XGL_PIPELINE',

1913

# 'XGL_PIPELINE_DELTA',

1914

# 'XGL_SAMPLER',

1915

# 'XGL_DESCRIPTOR_SET',

1916

# 'XGL_VIEWPORT_STATE_OBJECT',

1917

# 'XGL_RASTER_STATE_OBJECT',

1918

# 'XGL_MSAA_STATE_OBJECT',

1919

# 'XGL_COLOR_BLEND_STATE_OBJECT',

1920

# 'XGL_DEPTH_STENCIL_STATE_OBJECT',

1921

# 'XGL_CMD_BUFFER',

1922

# 'XGL_FENCE',

1923

# 'XGL_QUEUE_SEMAPHORE',

1924

# 'XGL_EVENT',

1925

# 'XGL_QUERY_POOL',

1926

# 'XGL_STATE_OBJECT',

# 'XGL_BASE_OBJECT',

# 'XGL_OBJECT',

# ]

param_exclude_list = ['p1', 'p2', 'pGpus', 'pDescriptorSets']

1931

if t.strip('*').replace('const ', '') in remap_list and n not in param_exclude_list:

1932

if '*' in t:

1933

if 'const ' not in t:

1934

return 'remap(*pPacket->%s)' % (n)

1935

else: # TODO : Don't remap array ptrs?

1936

return 'pPacket->%s' % (n)

Tobin Ehlis

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

[diff] [blame]

1937

return 'remap(pPacket->%s)' % (n)

1938

return 'pPacket->%s' % (n)

1939

Tobin Ehlis

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

[diff] [blame]

1940

def _gen_replay_enum_gpus(self):

Tobin Ehlis

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

[diff] [blame]

1941

ieg_body = []

1942

ieg_body.append(' if (!m_display->m_initedXGL)')

1943

ieg_body.append(' {')

Mark Lobodzinski

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

[diff] [blame]

1944

ieg_body.append(' uint32_t gpuCount;')

Tobin Ehlis

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

[diff] [blame]

1945

ieg_body.append(' XGL_PHYSICAL_GPU gpus[XGL_MAX_PHYSICAL_GPUS];')

Mark Lobodzinski

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

[diff] [blame]

1946

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]

1947

ieg_body.append(' replayResult = m_xglFuncs.real_xglEnumerateGpus(remap(pPacket->instance), maxGpus, &gpuCount, &gpus[0]);')

1948

ieg_body.append(' CHECK_RETURN_VALUE(xglEnumerateGpus);')

Tobin Ehlis

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

[diff] [blame]

1949

ieg_body.append(' //TODO handle different number of gpus in trace versus replay')

1950

ieg_body.append(' if (gpuCount != *(pPacket->pGpuCount))')

1951

ieg_body.append(' {')

1952

ieg_body.append(' glv_LogWarn("number of gpus mismatched in replay %u versus trace %u\\n", gpuCount, *(pPacket->pGpuCount));')

1953

ieg_body.append(' }')

1954

ieg_body.append(' else if (gpuCount == 0)')

1955

ieg_body.append(' {')

Tobin Ehlis

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

[diff] [blame]

1956

ieg_body.append(' glv_LogError("xglEnumerateGpus number of gpus is zero\\n");')

Tobin Ehlis

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

[diff] [blame]

1957

ieg_body.append(' }')

1958

ieg_body.append(' else')

1959

ieg_body.append(' {')

1960

ieg_body.append(' glv_LogInfo("Enumerated %d GPUs in the system\\n", gpuCount);')

1961

ieg_body.append(' }')

Tobin Ehlis

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

[diff] [blame]

1962

ieg_body.append(' // Do we care about the instance handel? Need to keep from clearing it? Not sure it will be used again...')

Tobin Ehlis

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

[diff] [blame]

1963

ieg_body.append(' clear_all_map_handles();')

1964

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]

1965

ieg_body.append(' for (uint32_t i = 0; i < gpuCount; i++)')

Tobin Ehlis

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

[diff] [blame]

1966

ieg_body.append(' {')

1967

ieg_body.append(' if (pPacket->pGpus)')

1968

ieg_body.append(' add_to_map(&(pPacket->pGpus[i]), &(gpus[i]));')

1969

ieg_body.append(' }')

1970

ieg_body.append(' }')

1971

return "\n".join(ieg_body)

1972

1973

def _gen_replay_get_gpu_info(self):

1974

ggi_body = []

1975

ggi_body.append(' if (!m_display->m_initedXGL)')

1976

ggi_body.append(' {')

1977

ggi_body.append(' switch (pPacket->infoType) {')

1978

ggi_body.append(' case XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES:')

1979

ggi_body.append(' {')

1980

ggi_body.append(' XGL_PHYSICAL_GPU_PROPERTIES gpuProps;')

Mark Lobodzinski

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

[diff] [blame]

1981

ggi_body.append(' size_t dataSize = sizeof(XGL_PHYSICAL_GPU_PROPERTIES);')

Tobin Ehlis

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

[diff] [blame]

1982

ggi_body.append(' replayResult = m_xglFuncs.real_xglGetGpuInfo(remap(pPacket->gpu), pPacket->infoType, &dataSize,')

1983

ggi_body.append(' (pPacket->pData == NULL) ? NULL : &gpuProps);')

1984

ggi_body.append(' if (pPacket->pData != NULL)')

1985

ggi_body.append(' {')

1986

ggi_body.append(' glv_LogInfo("Replay Gpu Properties\\n");')

1987

ggi_body.append(' glv_LogInfo("Vendor ID %x, Device ID %x, name %s\\n",gpuProps.vendorId, gpuProps.deviceId, gpuProps.gpuName);')

1988

ggi_body.append(' glv_LogInfo("API version %u, Driver version %u, gpu Type %u\\n",gpuProps.apiVersion, gpuProps.driverVersion, gpuProps.gpuType);')

1989

ggi_body.append(' }')

1990

ggi_body.append(' break;')

1991

ggi_body.append(' }')

1992

ggi_body.append(' case XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE:')

1993

ggi_body.append(' {')

1994

ggi_body.append(' XGL_PHYSICAL_GPU_PERFORMANCE gpuPerfs;')

Mark Lobodzinski

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

[diff] [blame]

1995

ggi_body.append(' size_t dataSize = sizeof(XGL_PHYSICAL_GPU_PERFORMANCE);')

Tobin Ehlis

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

[diff] [blame]

1996

ggi_body.append(' replayResult = m_xglFuncs.real_xglGetGpuInfo(remap(pPacket->gpu), pPacket->infoType, &dataSize,')

1997

ggi_body.append(' (pPacket->pData == NULL) ? NULL : &gpuPerfs);')

1998

ggi_body.append(' if (pPacket->pData != NULL)')

1999

ggi_body.append(' {')

2000

ggi_body.append(' glv_LogInfo("Replay Gpu Performance\\n");')

2001

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);')

2002

ggi_body.append(' glv_LogInfo("Max primitives/clock %f, Max pixels/clock %f\\n",gpuPerfs.primsPerClock, gpuPerfs.pixelsPerClock);')

2003

ggi_body.append(' }')

2004

ggi_body.append(' break;')

2005

ggi_body.append(' }')

2006

ggi_body.append(' case XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES:')

2007

ggi_body.append(' {')

2008

ggi_body.append(' XGL_PHYSICAL_GPU_QUEUE_PROPERTIES *pGpuQueue, *pQ;')

Mark Lobodzinski

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

[diff] [blame]

2009

ggi_body.append(' size_t dataSize = sizeof(XGL_PHYSICAL_GPU_QUEUE_PROPERTIES);')

2010

ggi_body.append(' size_t numQueues = 1;')

Tobin Ehlis

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

[diff] [blame]

2011

ggi_body.append(' assert(pPacket->pDataSize);')

2012

ggi_body.append(' if ((*(pPacket->pDataSize) % dataSize) != 0)')

2013

ggi_body.append(' glv_LogWarn("xglGetGpuInfo() for GPU_QUEUE_PROPERTIES not an integral data size assuming 1\\n");')

2014

ggi_body.append(' else')

2015

ggi_body.append(' numQueues = *(pPacket->pDataSize) / dataSize;')

2016

ggi_body.append(' dataSize = numQueues * dataSize;')

2017

ggi_body.append(' pQ = static_cast < XGL_PHYSICAL_GPU_QUEUE_PROPERTIES *> (glv_malloc(dataSize));')

2018

ggi_body.append(' pGpuQueue = pQ;')

2019

ggi_body.append(' replayResult = m_xglFuncs.real_xglGetGpuInfo(remap(pPacket->gpu), pPacket->infoType, &dataSize,')

2020

ggi_body.append(' (pPacket->pData == NULL) ? NULL : pGpuQueue);')

2021

ggi_body.append(' if (pPacket->pData != NULL)')

2022

ggi_body.append(' {')

2023

ggi_body.append(' for (unsigned int i = 0; i < numQueues; i++)')

2024

ggi_body.append(' {')

2025

ggi_body.append(' glv_LogInfo("Replay Gpu Queue Property for index %d, flags %u\\n", i, pGpuQueue->queueFlags);')

2026

ggi_body.append(' glv_LogInfo("Max available count %u, max atomic counters %u, supports timestamps %u\\n",pGpuQueue->queueCount, pGpuQueue->maxAtomicCounters, pGpuQueue->supportsTimestamps);')

2027

ggi_body.append(' pGpuQueue++;')

2028

ggi_body.append(' }')

2029

ggi_body.append(' }')

2030

ggi_body.append(' glv_free(pQ);')

2031

ggi_body.append(' break;')

2032

ggi_body.append(' }')

2033

ggi_body.append(' default:')

2034

ggi_body.append(' {')

Mark Lobodzinski

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

[diff] [blame]

2035

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

Tobin Ehlis

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

[diff] [blame]

2036

ggi_body.append(' void* pData = NULL;')

2037

ggi_body.append(' if (pPacket->pData != NULL && pPacket->pDataSize != NULL)')

2038

ggi_body.append(' {')

2039

ggi_body.append(' size = *pPacket->pDataSize;')

2040

ggi_body.append(' pData = glv_malloc(*pPacket->pDataSize);')

2041

ggi_body.append(' }')

2042

ggi_body.append(' replayResult = m_xglFuncs.real_xglGetGpuInfo(remap(pPacket->gpu), pPacket->infoType, &size, pData);')

2043

ggi_body.append(' if (replayResult == XGL_SUCCESS)')

2044

ggi_body.append(' {')

2045

ggi_body.append(' if (size != *pPacket->pDataSize && pData == NULL)')

2046

ggi_body.append(' {')

2047

ggi_body.append(' glv_LogWarn("xglGetGpuInfo returned a differing data size: replay (%d bytes) vs trace (%d bytes)\\n", size, *pPacket->pDataSize);')

2048

ggi_body.append(' }')

2049

ggi_body.append(' else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0)')

2050

ggi_body.append(' {')

2051

ggi_body.append(' glv_LogWarn("xglGetGpuInfo returned differing data contents than the trace file contained.\\n");')

2052

ggi_body.append(' }')

2053

ggi_body.append(' }')

2054

ggi_body.append(' glv_free(pData);')

2055

ggi_body.append(' break;')

2056

ggi_body.append(' }')

2057

ggi_body.append(' };')

2058

ggi_body.append(' CHECK_RETURN_VALUE(xglGetGpuInfo);')

2059

ggi_body.append(' }')

2060

return "\n".join(ggi_body)

2061

2062

def _gen_replay_create_device(self):

2063

cd_body = []

2064

cd_body.append(' if (!m_display->m_initedXGL)')

2065

cd_body.append(' {')

2066

cd_body.append(' XGL_DEVICE device;')

Peter Lohrmann

be24ff0

2015-01-08 19:47:03 -0800

[diff] [blame]

2067

cd_body.append(' if (g_xglReplaySettings.debugLevel > 0)')

Tobin Ehlis

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

[diff] [blame]

2068

cd_body.append(' {')

Jon Ashburn

6cad43c

2014-12-19 12:31:19 -0700

[diff] [blame]

2069

cd_body.append(' XGL_DEVICE_CREATE_INFO cInfo, *ci, *pCreateInfoSaved;')

Jon Ashburn

2014-12-18 17:03:34 -0700

[diff] [blame]

2070

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]

2071

# cd_body.append(' const char * layersStr[2] = {(char *) "DrawState", (char *) "ObjectTracker"};')

Peter Lohrmann

d445105

2015-01-09 12:34:50 -0800

[diff] [blame]

2072

2073

cd_body.append(' unsigned int numLayers = 0;')

Mark Lobodzinski

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

[diff] [blame]

2074

cd_body.append(' char ** layersStr = get_enableLayers_list(&numLayers);')

Jon Ashburn

2014-12-18 17:03:34 -0700

[diff] [blame]

2075

cd_body.append(' XGL_LAYER_CREATE_INFO layerInfo;')

Jon Ashburn

6cad43c

2014-12-19 12:31:19 -0700

[diff] [blame]

2076

cd_body.append(' pCreateInfoSaved = (XGL_DEVICE_CREATE_INFO *) pPacket->pCreateInfo;')

Jon Ashburn

2014-12-18 17:03:34 -0700

[diff] [blame]

2077

cd_body.append(' ci = (XGL_DEVICE_CREATE_INFO *) pPacket->pCreateInfo;')

Peter Lohrmann

d445105

2015-01-09 12:34:50 -0800

[diff] [blame]

2078

2079

cd_body.append(' if (layersStr != NULL && numLayers > 0)')

2080

cd_body.append(' {')

2081

cd_body.append(' while (ci->pNext != NULL)')

2082

cd_body.append(' ci = (XGL_DEVICE_CREATE_INFO *) ci->pNext;')

2083

cd_body.append(' ci->pNext = &layerInfo;')

2084

cd_body.append(' layerInfo.sType = XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO;')

2085

cd_body.append(' layerInfo.pNext = 0;')

2086

cd_body.append(' layerInfo.layerCount = numLayers;')

2087

cd_body.append(' layerInfo.ppActiveLayerNames = layersStr;')

2088

cd_body.append(' }')

2089

Tobin Ehlis

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

[diff] [blame]

2090

cd_body.append(' memcpy(&cInfo, pPacket->pCreateInfo, sizeof(XGL_DEVICE_CREATE_INFO));')

2091

cd_body.append(' cInfo.flags = pPacket->pCreateInfo->flags | XGL_DEVICE_CREATE_VALIDATION_BIT;')

Tobin Ehlis

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

[diff] [blame]

2092

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]

2093

cd_body.append(' pPacket->pCreateInfo = &cInfo;')

Jon Ashburn

2014-12-18 17:03:34 -0700

[diff] [blame]

2094

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]

2095

cd_body.append(' // restore the packet for next replay')

2096

cd_body.append(' ci->pNext = NULL;')

2097

cd_body.append(' pPacket->pCreateInfo = pCreateInfoSaved;')

Peter Lohrmann

d445105

2015-01-09 12:34:50 -0800

[diff] [blame]

2098

cd_body.append(' release_enableLayer_list(layersStr);')

Jon Ashburn

2014-12-18 17:03:34 -0700

[diff] [blame]

2099

cd_body.append(' if (xglDbgRegisterMsgCallback(g_fpDbgMsgCallback, NULL) != XGL_SUCCESS)')

2100

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]

2101

cd_body.append(' }')

Jon Ashburn

2014-12-18 17:03:34 -0700

[diff] [blame]

2102

cd_body.append(' else ')

2103

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]

2104

cd_body.append(' CHECK_RETURN_VALUE(xglCreateDevice);')

2105

cd_body.append(' if (replayResult == XGL_SUCCESS)')

2106

cd_body.append(' {')

2107

cd_body.append(' add_to_map(pPacket->pDevice, &device);')

2108

cd_body.append(' }')

2109

cd_body.append(' }')

2110

return "\n".join(cd_body)

2111

2112

def _gen_replay_get_extension_support(self):

2113

ges_body = []

2114

ges_body.append(' if (!m_display->m_initedXGL) {')

2115

ges_body.append(' replayResult = m_xglFuncs.real_xglGetExtensionSupport(remap(pPacket->gpu), pPacket->pExtName);')

2116

ges_body.append(' CHECK_RETURN_VALUE(xglGetExtensionSupport);')

2117

ges_body.append(' if (replayResult == XGL_SUCCESS) {')

2118

ges_body.append(' for (unsigned int ext = 0; ext < sizeof(g_extensions) / sizeof(g_extensions[0]); ext++)')

2119

ges_body.append(' {')

Chia-I Wu

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

[diff] [blame]

2120

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]

2121

ges_body.append(' bool extInList = false;')

2122

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]

2123

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]

2124

ges_body.append(' extInList = true;')

2125

ges_body.append(' break;')

2126

ges_body.append(' }')

2127

ges_body.append(' if (!extInList)')

Mark Lobodzinski

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

[diff] [blame]

2128

ges_body.append(' m_display->m_extensions.push_back((char *) g_extensions[ext]);')

Tobin Ehlis

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

[diff] [blame]

2129

ges_body.append(' break;')

2130

ges_body.append(' }')

2131

ges_body.append(' }')

2132

ges_body.append(' }')

2133

ges_body.append(' }')

2134

return "\n".join(ges_body)

2135

2136

def _gen_replay_queue_submit(self):

2137

qs_body = []

2138

qs_body.append(' XGL_CMD_BUFFER *remappedBuffers = NULL;')

2139

qs_body.append(' if (pPacket->pCmdBuffers != NULL)')

2140

qs_body.append(' {')

2141

qs_body.append(' remappedBuffers = GLV_NEW_ARRAY( XGL_CMD_BUFFER, pPacket->cmdBufferCount);')

Mark Lobodzinski

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

[diff] [blame]

2142

qs_body.append(' for (uint32_t i = 0; i < pPacket->cmdBufferCount; i++)')

Tobin Ehlis

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

[diff] [blame]

2143

qs_body.append(' {')

2144

qs_body.append(' *(remappedBuffers + i) = remap(*(pPacket->pCmdBuffers + i));')

2145

qs_body.append(' }')

2146

qs_body.append(' }')

2147

qs_body.append(' XGL_MEMORY_REF* memRefs = NULL;')

2148

qs_body.append(' if (pPacket->pMemRefs != NULL)')

2149

qs_body.append(' {')

2150

qs_body.append(' memRefs = GLV_NEW_ARRAY(XGL_MEMORY_REF, pPacket->memRefCount);')

2151

qs_body.append(' memcpy(memRefs, pPacket->pMemRefs, sizeof(XGL_MEMORY_REF) * pPacket->memRefCount);')

Mark Lobodzinski

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

[diff] [blame]

2152

qs_body.append(' for (uint32_t i = 0; i < pPacket->memRefCount; i++)')

Tobin Ehlis

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

[diff] [blame]

2153

qs_body.append(' {')

2154

qs_body.append(' memRefs[i].mem = remap(pPacket->pMemRefs[i].mem);')

2155

qs_body.append(' }')

2156

qs_body.append(' }')

2157

qs_body.append(' replayResult = m_xglFuncs.real_xglQueueSubmit(remap(pPacket->queue), pPacket->cmdBufferCount, remappedBuffers, pPacket->memRefCount,')

2158

qs_body.append(' memRefs, remap(pPacket->fence));')

2159

qs_body.append(' GLV_DELETE(remappedBuffers);')

2160

qs_body.append(' GLV_DELETE(memRefs);')

2161

return "\n".join(qs_body)

2162

Tobin Ehlis

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

[diff] [blame]

2163

def _gen_replay_get_object_info(self):

2164

goi_body = []

Mark Lobodzinski

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

[diff] [blame]

2165

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

Tobin Ehlis

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

[diff] [blame]

2166

goi_body.append(' void* pData = NULL;')

2167

goi_body.append(' if (pPacket->pData != NULL && pPacket->pDataSize != NULL)')

2168

goi_body.append(' {')

2169

goi_body.append(' size = *pPacket->pDataSize;')

2170

goi_body.append(' pData = glv_malloc(*pPacket->pDataSize);')

2171

goi_body.append(' memcpy(pData, pPacket->pData, *pPacket->pDataSize);')

2172

goi_body.append(' }')

2173

goi_body.append(' replayResult = m_xglFuncs.real_xglGetObjectInfo(remap(pPacket->object), pPacket->infoType, &size, pData);')

2174

goi_body.append(' if (replayResult == XGL_SUCCESS)')

2175

goi_body.append(' {')

2176

goi_body.append(' if (size != *pPacket->pDataSize && pData == NULL)')

2177

goi_body.append(' {')

2178

goi_body.append(' glv_LogWarn("xglGetObjectInfo returned a differing data size: replay (%d bytes) vs trace (%d bytes)\\n", size, *pPacket->pDataSize);')

2179

goi_body.append(' }')

2180

goi_body.append(' else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0)')

2181

goi_body.append(' {')

2182

goi_body.append(' glv_LogWarn("xglGetObjectInfo returned differing data contents than the trace file contained.\\n");')

2183

goi_body.append(' }')

2184

goi_body.append(' }')

2185

goi_body.append(' glv_free(pData);')

2186

return "\n".join(goi_body)

2187

2188

def _gen_replay_get_format_info(self):

2189

gfi_body = []

Mark Lobodzinski

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

[diff] [blame]

2190

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

Tobin Ehlis

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

[diff] [blame]

2191

gfi_body.append(' void* pData = NULL;')

2192

gfi_body.append(' if (pPacket->pData != NULL && pPacket->pDataSize != NULL)')

2193

gfi_body.append(' {')

2194

gfi_body.append(' size = *pPacket->pDataSize;')

2195

gfi_body.append(' pData = glv_malloc(*pPacket->pDataSize);')

2196

gfi_body.append(' }')

2197

gfi_body.append(' replayResult = m_xglFuncs.real_xglGetFormatInfo(remap(pPacket->device), pPacket->format, pPacket->infoType, &size, pData);')

2198

gfi_body.append(' if (replayResult == XGL_SUCCESS)')

2199

gfi_body.append(' {')

2200

gfi_body.append(' if (size != *pPacket->pDataSize && pData == NULL)')

2201

gfi_body.append(' {')

2202

gfi_body.append(' glv_LogWarn("xglGetFormatInfo returned a differing data size: replay (%d bytes) vs trace (%d bytes)\\n", size, *pPacket->pDataSize);')

2203

gfi_body.append(' }')

2204

gfi_body.append(' else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0)')

2205

gfi_body.append(' {')

2206

gfi_body.append(' glv_LogWarn("xglGetFormatInfo returned differing data contents than the trace file contained.\\n");')

2207

gfi_body.append(' }')

2208

gfi_body.append(' }')

2209

gfi_body.append(' glv_free(pData);')

2210

return "\n".join(gfi_body)

2211

2212

def _gen_replay_get_image_subresource_info(self):

2213

isi_body = []

Mark Lobodzinski

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

[diff] [blame]

2214

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

Tobin Ehlis

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

[diff] [blame]

2215

isi_body.append(' void* pData = NULL;')

2216

isi_body.append(' if (pPacket->pData != NULL && pPacket->pDataSize != NULL)')

2217

isi_body.append(' {')

2218

isi_body.append(' size = *pPacket->pDataSize;')

2219

isi_body.append(' pData = glv_malloc(*pPacket->pDataSize);')

2220

isi_body.append(' }')

2221

isi_body.append(' replayResult = m_xglFuncs.real_xglGetImageSubresourceInfo(remap(pPacket->image), pPacket->pSubresource, pPacket->infoType, &size, pData);')

2222

isi_body.append(' if (replayResult == XGL_SUCCESS)')

2223

isi_body.append(' {')

2224

isi_body.append(' if (size != *pPacket->pDataSize && pData == NULL)')

2225

isi_body.append(' {')

2226

isi_body.append(' glv_LogWarn("xglGetImageSubresourceInfo returned a differing data size: replay (%d bytes) vs trace (%d bytes)\\n", size, *pPacket->pDataSize);')

2227

isi_body.append(' }')

2228

isi_body.append(' else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0)')

2229

isi_body.append(' {')

2230

isi_body.append(' glv_LogWarn("xglGetImageSubresourceInfo returned differing data contents than the trace file contained.\\n");')

2231

isi_body.append(' }')

2232

isi_body.append(' }')

2233

isi_body.append(' glv_free(pData);')

2234

return "\n".join(isi_body)

2235

2236

def _gen_replay_create_graphics_pipeline(self):

2237

cgp_body = []

2238

cgp_body.append(' XGL_GRAPHICS_PIPELINE_CREATE_INFO createInfo;')

2239

cgp_body.append(' struct shaderPair saveShader[10];')

2240

cgp_body.append(' unsigned int idx = 0;')

2241

cgp_body.append(' memcpy(&createInfo, pPacket->pCreateInfo, sizeof(XGL_GRAPHICS_PIPELINE_CREATE_INFO));')

2242

cgp_body.append(' // Cast to shader type, as those are of primariy interest and all structs in LL have same header w/ sType & pNext')

2243

cgp_body.append(' XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pPacketNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pPacket->pCreateInfo->pNext;')

2244

cgp_body.append(' XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)createInfo.pNext;')

2245

cgp_body.append(' while (XGL_NULL_HANDLE != pPacketNext)')

2246

cgp_body.append(' {')

2247

cgp_body.append(' if (XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO == pNext->sType)')

2248

cgp_body.append(' {')

2249

cgp_body.append(' saveShader[idx].val = pNext->shader.shader;')

2250

cgp_body.append(' saveShader[idx++].addr = &(pNext->shader.shader);')

2251

cgp_body.append(' pNext->shader.shader = remap(pPacketNext->shader.shader);')

2252

cgp_body.append(' }')

2253

cgp_body.append(' pPacketNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pPacketNext->pNext;')

2254

cgp_body.append(' pNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pNext->pNext;')

2255

cgp_body.append(' }')

2256

cgp_body.append(' XGL_PIPELINE pipeline;')

2257

cgp_body.append(' replayResult = m_xglFuncs.real_xglCreateGraphicsPipeline(remap(pPacket->device), &createInfo, &pipeline);')

2258

cgp_body.append(' if (replayResult == XGL_SUCCESS)')

2259

cgp_body.append(' {')

2260

cgp_body.append(' add_to_map(pPacket->pPipeline, &pipeline);')

2261

cgp_body.append(' }')

2262

cgp_body.append(' for (unsigned int i = 0; i < idx; i++)')

2263

cgp_body.append(' *(saveShader[i].addr) = saveShader[i].val;')

2264

return "\n".join(cgp_body)

2265

Jon Ashburn

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

[diff] [blame]

2266

def _gen_replay_create_framebuffer(self):

2267

cf_body = []

2268

cf_body.append(' XGL_FRAMEBUFFER_CREATE_INFO *pInfo = (XGL_FRAMEBUFFER_CREATE_INFO *) pPacket->pCreateInfo;')

2269

cf_body.append(' XGL_COLOR_ATTACHMENT_BIND_INFO *pColorAttachments, *pSavedColor = (XGL_COLOR_ATTACHMENT_BIND_INFO*)pInfo->pColorAttachments;')

2270

cf_body.append(' bool allocatedColorAttachments = false;')

2271

cf_body.append(' if (pSavedColor != NULL)')

2272

cf_body.append(' {')

2273

cf_body.append(' allocatedColorAttachments = true;')

2274

cf_body.append(' pColorAttachments = GLV_NEW_ARRAY(XGL_COLOR_ATTACHMENT_BIND_INFO, pInfo->colorAttachmentCount);')

2275

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]

2276

cf_body.append(' for (uint32_t i = 0; i < pInfo->colorAttachmentCount; i++)')

Jon Ashburn

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

[diff] [blame]

2277

cf_body.append(' {')

2278

cf_body.append(' pColorAttachments[i].view = remap(pInfo->pColorAttachments[i].view);')

2279

cf_body.append(' }')

2280

cf_body.append(' pInfo->pColorAttachments = pColorAttachments;')

2281

cf_body.append(' }')

2282

cf_body.append(' // remap depth stencil target')

Tobin Ehlis

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

[diff] [blame]

2283

cf_body.append(' const XGL_DEPTH_STENCIL_BIND_INFO *pSavedDS = pInfo->pDepthStencilAttachment;')

Jon Ashburn

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

[diff] [blame]

2284

cf_body.append(' XGL_DEPTH_STENCIL_BIND_INFO depthTarget;')

2285

cf_body.append(' if (pSavedDS != NULL)')

2286

cf_body.append(' {')

2287

cf_body.append(' memcpy(&depthTarget, pSavedDS, sizeof(XGL_DEPTH_STENCIL_BIND_INFO));')

2288

cf_body.append(' depthTarget.view = remap(pSavedDS->view);')

2289

cf_body.append(' pInfo->pDepthStencilAttachment = &depthTarget;')

2290

cf_body.append(' }')

2291

cf_body.append(' XGL_FRAMEBUFFER local_framebuffer;')

2292

cf_body.append(' replayResult = m_xglFuncs.real_xglCreateFramebuffer(remap(pPacket->device), pPacket->pCreateInfo, &local_framebuffer);')

2293

cf_body.append(' pInfo->pColorAttachments = pSavedColor;')

2294

cf_body.append(' pInfo->pDepthStencilAttachment = pSavedDS;')

2295

cf_body.append(' if (replayResult == XGL_SUCCESS)')

2296

cf_body.append(' {')

2297

cf_body.append(' add_to_map(pPacket->pFramebuffer, &local_framebuffer);')

2298

cf_body.append(' }')

2299

cf_body.append(' if (allocatedColorAttachments)')

2300

cf_body.append(' {')

2301

cf_body.append(' GLV_DELETE((void*)pColorAttachments);')

2302

cf_body.append(' }')

2303

return "\n".join(cf_body)

2304

2305

def _gen_replay_create_renderpass(self):

2306

cr_body = []

2307

cr_body.append(' XGL_RENDER_PASS_CREATE_INFO *pInfo = (XGL_RENDER_PASS_CREATE_INFO *) pPacket->pCreateInfo;')

2308

cr_body.append(' // remap framebuffer')

2309

cr_body.append(' XGL_FRAMEBUFFER savedFB, *pFB = &(pInfo->framebuffer);')

2310

cr_body.append(' if (*pFB != NULL)')

2311

cr_body.append(' {')

2312

cr_body.append(' savedFB = pInfo->framebuffer;')

2313

cr_body.append(' *pFB = remap(pInfo->framebuffer);')

2314

cr_body.append(' }')

2315

cr_body.append(' XGL_RENDER_PASS local_renderpass;')

2316

cr_body.append(' replayResult = m_xglFuncs.real_xglCreateRenderPass(remap(pPacket->device), pPacket->pCreateInfo, &local_renderpass);')

2317

cr_body.append(' pInfo->framebuffer = savedFB;')

2318

cr_body.append(' if (replayResult == XGL_SUCCESS)')

2319

cr_body.append(' {')

2320

cr_body.append(' add_to_map(pPacket->pRenderPass, &local_renderpass);')

2321

cr_body.append(' }')

2322

return "\n".join(cr_body)

2323

2324

def _gen_replay_begin_command_buffer(self):

2325

bcb_body = []

2326

bcb_body.append(' XGL_CMD_BUFFER_BEGIN_INFO* pInfo = (XGL_CMD_BUFFER_BEGIN_INFO*)pPacket->pBeginInfo;')

2327

bcb_body.append(' // assume only zero or one graphics_begin_info in the chain')

2328

bcb_body.append(' XGL_RENDER_PASS savedRP, *pRP;')

2329

bcb_body.append(' XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO *pGInfo = NULL;')

2330

bcb_body.append(' while (pInfo != NULL)')

2331

bcb_body.append(' {')

2332

bcb_body.append('')

2333

bcb_body.append(' if (pInfo->sType == XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO)')

2334

bcb_body.append(' {')

2335

bcb_body.append(' pGInfo = (XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO *) pInfo;')

2336

bcb_body.append(' savedRP = pGInfo->renderPass;')

2337

bcb_body.append(' pRP = &(pGInfo->renderPass);')

2338

bcb_body.append(' *pRP = remap(pGInfo->renderPass);')

2339

bcb_body.append(' break;')

2340

bcb_body.append(' }')

2341

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

2342

bcb_body.append(' }')

2343

bcb_body.append(' replayResult = m_xglFuncs.real_xglBeginCommandBuffer(remap(pPacket->cmdBuffer), pPacket->pBeginInfo);')

2344

bcb_body.append(' if (pGInfo != NULL)')

2345

bcb_body.append(' pGInfo->renderPass = savedRP;')

2346

return "\n".join(bcb_body)

2347

Tobin Ehlis

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

[diff] [blame]

2348

def _gen_replay_store_pipeline(self):

2349

sp_body = []

Mark Lobodzinski

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

[diff] [blame]

2350

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

Tobin Ehlis

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

[diff] [blame]

2351

sp_body.append(' void* pData = NULL;')

2352

sp_body.append(' if (pPacket->pData != NULL && pPacket->pDataSize != NULL)')

2353

sp_body.append(' {')

2354

sp_body.append(' size = *pPacket->pDataSize;')

2355

sp_body.append(' pData = glv_malloc(*pPacket->pDataSize);')

2356

sp_body.append(' }')

2357

sp_body.append(' replayResult = m_xglFuncs.real_xglStorePipeline(remap(pPacket->pipeline), &size, pData);')

2358

sp_body.append(' if (replayResult == XGL_SUCCESS)')

2359

sp_body.append(' {')

2360

sp_body.append(' if (size != *pPacket->pDataSize && pData == NULL)')

2361

sp_body.append(' {')

2362

sp_body.append(' glv_LogWarn("xglStorePipeline returned a differing data size: replay (%d bytes) vs trace (%d bytes)\\n", size, *pPacket->pDataSize);')

2363

sp_body.append(' }')

2364

sp_body.append(' else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0)')

2365

sp_body.append(' {')

2366

sp_body.append(' glv_LogWarn("xglStorePipeline returned differing data contents than the trace file contained.\\n");')

2367

sp_body.append(' }')

2368

sp_body.append(' }')

2369

sp_body.append(' glv_free(pData);')

2370

return "\n".join(sp_body)

2371

Tobin Ehlis

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

[diff] [blame]

2372

def _gen_replay_get_multi_gpu_compatibility(self):

2373

gmgc_body = []

2374

gmgc_body.append(' XGL_GPU_COMPATIBILITY_INFO cInfo;')

2375

gmgc_body.append(' XGL_PHYSICAL_GPU handle0, handle1;')

2376

gmgc_body.append(' handle0 = remap(pPacket->gpu0);')

2377

gmgc_body.append(' handle1 = remap(pPacket->gpu1);')

2378

gmgc_body.append(' replayResult = m_xglFuncs.real_xglGetMultiGpuCompatibility(handle0, handle1, &cInfo);')

2379

return "\n".join(gmgc_body)

2380

2381

def _gen_replay_destroy_object(self):

2382

do_body = []

2383

do_body.append(' XGL_OBJECT object = remap(pPacket->object);')

2384

do_body.append(' if (object != XGL_NULL_HANDLE)')

2385

do_body.append(' replayResult = m_xglFuncs.real_xglDestroyObject(object);')

2386

do_body.append(' if (replayResult == XGL_SUCCESS)')

2387

do_body.append(' rm_from_map(pPacket->object);')

2388

return "\n".join(do_body)

2389

2390

def _gen_replay_wait_for_fences(self):

2391

wf_body = []

2392

wf_body.append(' XGL_FENCE *pFence = GLV_NEW_ARRAY(XGL_FENCE, pPacket->fenceCount);')

Mark Lobodzinski

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

[diff] [blame]

2393

wf_body.append(' for (uint32_t i = 0; i < pPacket->fenceCount; i++)')

Tobin Ehlis

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

[diff] [blame]

2394

wf_body.append(' {')

2395

wf_body.append(' *(pFence + i) = remap(*(pPacket->pFences + i));')

2396

wf_body.append(' }')

2397

wf_body.append(' replayResult = m_xglFuncs.real_xglWaitForFences(remap(pPacket->device), pPacket->fenceCount, pFence, pPacket->waitAll, pPacket->timeout);')

2398

wf_body.append(' GLV_DELETE(pFence);')

2399

return "\n".join(wf_body)

2400

2401

def _gen_replay_wsi_associate_connection(self):

2402

wac_body = []

2403

wac_body.append(' //associate with the replayers Wsi connection rather than tracers')

2404

wac_body.append(' replayResult = m_xglFuncs.real_xglWsiX11AssociateConnection(remap(pPacket->gpu), &(m_display->m_WsiConnection));')

2405

return "\n".join(wac_body)

2406

2407

def _gen_replay_wsi_get_msc(self):

2408

wgm_body = []

2409

wgm_body.append(' xcb_window_t window = m_display->m_XcbWindow;')

2410

wgm_body.append(' replayResult = m_xglFuncs.real_xglWsiX11GetMSC(remap(pPacket->device), window, pPacket->crtc, pPacket->pMsc);')

2411

return "\n".join(wgm_body)

2412

2413

def _gen_replay_wsi_create_presentable_image(self):

2414

cpi_body = []

2415

cpi_body.append(' XGL_IMAGE img;')

2416

cpi_body.append(' XGL_GPU_MEMORY mem;')

2417

cpi_body.append(' replayResult = m_xglFuncs.real_xglWsiX11CreatePresentableImage(remap(pPacket->device), pPacket->pCreateInfo, &img, &mem);')

2418

cpi_body.append(' if (replayResult == XGL_SUCCESS)')

2419

cpi_body.append(' {')

2420

cpi_body.append(' if (pPacket->pImage != NULL)')

2421

cpi_body.append(' add_to_map(pPacket->pImage, &img);')

2422

cpi_body.append(' if(pPacket->pMem != NULL)')

2423

cpi_body.append(' add_to_map(pPacket->pMem, &mem);')

2424

cpi_body.append(' }')

2425

return "\n".join(cpi_body)

2426

2427

def _gen_replay_wsi_queue_present(self):

2428

wqp_body = []

2429

wqp_body.append(' XGL_WSI_X11_PRESENT_INFO pInfo;')

2430

wqp_body.append(' memcpy(&pInfo, pPacket->pPresentInfo, sizeof(XGL_WSI_X11_PRESENT_INFO));')

2431

wqp_body.append(' pInfo.srcImage = remap(pPacket->pPresentInfo->srcImage);')

2432

wqp_body.append(' // use replayers Xcb window')

2433

wqp_body.append(' pInfo.destWindow = m_display->m_XcbWindow;')

2434

wqp_body.append(' replayResult = m_xglFuncs.real_xglWsiX11QueuePresent(remap(pPacket->queue), &pInfo, remap(pPacket->fence));')

2435

return "\n".join(wqp_body)

2436

2437

# I don't like making these 3 mem functions 'fully' custom, but just doing it for now to avoid being too cute

2438

def _gen_replay_free_memory(self):

2439

fm_body = []

2440

fm_body.append(' XGL_GPU_MEMORY handle = remap(pPacket->mem);')

2441

fm_body.append(' replayResult = m_xglFuncs.real_xglFreeMemory(handle);')

2442

fm_body.append(' if (replayResult == XGL_SUCCESS) ')

2443

fm_body.append(' {')

2444

fm_body.append(' rm_entry_from_mapData(handle);')

2445

fm_body.append(' rm_from_map(pPacket->mem);')

2446

fm_body.append(' }')

2447

return "\n".join(fm_body)

2448

2449

def _gen_replay_map_memory(self):

2450

mm_body = []

2451

mm_body.append(' XGL_GPU_MEMORY handle = remap(pPacket->mem);')

Mark Lobodzinski

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

[diff] [blame]

2452

mm_body.append(' void* pData;')

Tobin Ehlis

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

[diff] [blame]

2453

mm_body.append(' replayResult = m_xglFuncs.real_xglMapMemory(handle, pPacket->flags, &pData);')

2454

mm_body.append(' if (replayResult == XGL_SUCCESS)')

2455

mm_body.append(' add_mapping_to_mapData(handle, pData);')

2456

return "\n".join(mm_body)

2457

2458

def _gen_replay_unmap_memory(self):

2459

um_body = []

2460

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

2461

um_body.append(' rm_mapping_from_mapData(handle, pPacket->pData); // copies data from packet into memory buffer')

2462

um_body.append(' replayResult = m_xglFuncs.real_xglUnmapMemory(handle);')

2463

return "\n".join(um_body)

2464

2465

def _gen_replay_bind_dynamic_memory_view(self):

2466

bdmv_body = []

2467

bdmv_body.append(' XGL_MEMORY_VIEW_ATTACH_INFO memView;')

2468

bdmv_body.append(' memcpy(&memView, pPacket->pMemView, sizeof(XGL_MEMORY_VIEW_ATTACH_INFO));')

2469

bdmv_body.append(' memView.mem = remap(pPacket->pMemView->mem);')

2470

bdmv_body.append(' m_xglFuncs.real_xglCmdBindDynamicMemoryView(remap(pPacket->cmdBuffer), pPacket->pipelineBindPoint, &memView);')

2471

return "\n".join(bdmv_body)

2472

2473

def _generate_replay(self):

2474

# map protos to custom functions if body is fully custom

Tobin Ehlis

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

[diff] [blame]

2475

custom_body_dict = {'EnumerateGpus': self._gen_replay_enum_gpus,

Tobin Ehlis

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

[diff] [blame]

2476

'GetGpuInfo': self._gen_replay_get_gpu_info,

2477

'CreateDevice': self._gen_replay_create_device,

2478

'GetExtensionSupport': self._gen_replay_get_extension_support,

2479

'QueueSubmit': self._gen_replay_queue_submit,

Tobin Ehlis

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

[diff] [blame]

2480

'GetObjectInfo': self._gen_replay_get_object_info,

2481

'GetFormatInfo': self._gen_replay_get_format_info,

2482

'GetImageSubresourceInfo': self._gen_replay_get_image_subresource_info,

2483

'CreateGraphicsPipeline': self._gen_replay_create_graphics_pipeline,

Jon Ashburn

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

[diff] [blame]

2484

'CreateFramebuffer': self._gen_replay_create_framebuffer,

2485

'CreateRenderPass': self._gen_replay_create_renderpass,

2486

'BeginCommandBuffer': self._gen_replay_begin_command_buffer,

Tobin Ehlis

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

[diff] [blame]

2487

'StorePipeline': self._gen_replay_store_pipeline,

Tobin Ehlis

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

[diff] [blame]

2488

'GetMultiGpuCompatibility': self._gen_replay_get_multi_gpu_compatibility,

2489

'DestroyObject': self._gen_replay_destroy_object,

2490

'WaitForFences': self._gen_replay_wait_for_fences,

2491

'WsiX11AssociateConnection': self._gen_replay_wsi_associate_connection,

2492

'WsiX11GetMSC': self._gen_replay_wsi_get_msc,

2493

'WsiX11CreatePresentableImage': self._gen_replay_wsi_create_presentable_image,

2494

'WsiX11QueuePresent': self._gen_replay_wsi_queue_present,

2495

'FreeMemory': self._gen_replay_free_memory,

2496

'MapMemory': self._gen_replay_map_memory,

2497

'UnmapMemory': self._gen_replay_unmap_memory,

2498

'CmdBindDynamicMemoryView': self._gen_replay_bind_dynamic_memory_view}

2499

# Despite returning a value, don't check these funcs b/c custom code includes check already

2500

custom_check_ret_val = ['InitAndEnumerateGpus', 'GetGpuInfo', 'CreateDevice', 'GetExtensionSupport']

2501

# multi-gpu Open funcs w/ list of local params to create

2502

custom_open_params = {'OpenSharedMemory': (-1,),

2503

'OpenSharedQueueSemaphore': (-1,),

2504

'OpenPeerMemory': (-1,),

2505

'OpenPeerImage': (-1, -2,)}

2506

# Functions that create views are unique from other create functions

2507

create_view_list = ['CreateImageView', 'CreateColorAttachmentView', 'CreateDepthStencilView', 'CreateComputePipeline']

2508

# Functions to treat as "Create' that don't have 'Create' in the name

Tobin Ehlis

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

[diff] [blame^]

2509

special_create_list = ['LoadPipeline', 'AllocMemory', 'GetDeviceQueue', 'PinSystemMemory', 'AllocDescriptorSets']

Tobin Ehlis

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

[diff] [blame]

2510

# A couple funcs use do while loops

2511

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'}

2512

rbody = []

2513

rbody.append('#define CHECK_RETURN_VALUE(entrypoint) returnValue = handle_replay_errors(#entrypoint, replayResult, pPacket->result, returnValue);\n')

2514

rbody.append('glv_replay::GLV_REPLAY_RESULT xglReplay::replay(glv_trace_packet_header *packet)')

2515

rbody.append('{')

2516

rbody.append(' glv_replay::GLV_REPLAY_RESULT returnValue = glv_replay::GLV_REPLAY_SUCCESS;')

2517

rbody.append(' XGL_RESULT replayResult = XGL_ERROR_UNKNOWN;')

2518

rbody.append(' switch (packet->packet_id)')

2519

rbody.append(' {')

Jon Ashburn

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

[diff] [blame]

2520

rbody.append(' case GLV_TPI_XGL_xglApiVersion:')

2521

rbody.append(' break; // nothing to replay on the version packet')

Tobin Ehlis

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

[diff] [blame]

2522

for proto in self.protos:

ret_value = False

create_view = False

create_func = False

transitions = False

ds_attach = False

Tobin Ehlis

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

[diff] [blame]

2528

# TODO : How to handle void* return of GetProcAddr?

2529

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]

2530

ret_value = True

2531

if proto.name in create_view_list:

2532

create_view = True

2533

elif 'Create' in proto.name or proto.name in special_create_list:

2534

create_func = True

2535

elif 'pStateTransitions' in [p.name for p in proto.params]:

2536

transitions = True

2537

elif proto.name.startswith('Attach'):

2538

ds_attach = True

2539

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

2540

rbody.append(' {')

2541

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

2542

if proto.name in custom_body_dict:

2543

rbody.append(custom_body_dict[proto.name]())

2544

else:

2545

if proto.name in custom_open_params:

2546

rbody.append(' XGL_DEVICE handle;')

2547

for pidx in custom_open_params[proto.name]:

Tobin Ehlis

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

[diff] [blame]

2548

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]

2549

rbody.append(' handle = remap(pPacket->device);')

2550

elif create_view:

Tobin Ehlis

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

[diff] [blame]

2551

rbody.append(' %s createInfo;' % (proto.params[1].ty.strip('*').replace('const ', '')))

2552

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]

2553

if 'CreateComputePipeline' == proto.name:

2554

rbody.append(' createInfo.cs.shader = remap(pPacket->pCreateInfo->cs.shader);')

2555

else:

2556

rbody.append(' createInfo.image = remap(pPacket->pCreateInfo->image);')

Tobin Ehlis

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

[diff] [blame]

2557

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]

2558

elif create_func: # Declare local var to store created handle into

Tobin Ehlis

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

[diff] [blame]

2559

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^]

2560

if 'AllocDescriptorSets' == proto.name:

2561

rbody.append(' %s* local_%s = NULL;' % (proto.params[-2].ty.strip('*').replace('const ', ''), proto.params[-2].name))

Tobin Ehlis

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

[diff] [blame]

2562

elif transitions:

Tobin Ehlis

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

[diff] [blame]

2563

rbody.append(' %s pStateTransitions = (%s)pPacket->pStateTransitions;' % (proto.params[-1].ty.replace('const ', ''), proto.params[-1].ty.replace('const ', '')))

Tobin Ehlis

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

[diff] [blame]

2564

rbody.append(' bool allocatedMem = false;')

2565

rbody.append(' if (pStateTransitions != NULL)')

2566

rbody.append(' {')

2567

rbody.append(' allocatedMem = true;')

Tobin Ehlis

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

[diff] [blame]

2568

rbody.append(' pStateTransitions = GLV_NEW_ARRAY(%s, pPacket->transitionCount);' % (proto.params[-1].ty.strip('*').replace('const ', '')))

2569

rbody.append(' memcpy(pStateTransitions, pPacket->pStateTransitions, sizeof(%s) * pPacket->transitionCount);' % (proto.params[-1].ty.strip('*').replace('const ', '')))

Mark Lobodzinski

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

[diff] [blame]

2570

rbody.append(' for (uint32_t i = 0; i < pPacket->transitionCount; i++)')

Tobin Ehlis

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

[diff] [blame]

2571

rbody.append(' {')

2572

if 'Memory' in proto.name:

2573

rbody.append(' pStateTransitions[i].mem = remap(pPacket->pStateTransitions[i].mem);')

2574

else:

2575

rbody.append(' pStateTransitions[i].image = remap(pPacket->pStateTransitions[i].image);')

rbody.append(' }')

rbody.append(' }')

elif ds_attach:

rbody.append(' %s %s = GLV_NEW_ARRAY(%s, pPacket->slotCount);' % (proto.params[-1].ty.strip('const '), proto.params[-1].name, proto.params[-1].ty.strip('const ').strip('*')))

2580

rbody.append(' memcpy(%s, pPacket->%s, pPacket->slotCount * sizeof(%s));' % (proto.params[-1].name, proto.params[-1].name, proto.params[-1].ty.strip('const ').strip('*')))

Mark Lobodzinski

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

[diff] [blame]

2581

rbody.append(' for (uint32_t i = 0; i < pPacket->slotCount; i++)')

Tobin Ehlis

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

[diff] [blame]

2582

rbody.append(' {')

2583

if 'Sampler' in proto.name:

2584

rbody.append(' %s[i] = remap(pPacket->%s[i]);' % (proto.params[-1].name, proto.params[-1].name))

2585

elif 'Image' in proto.name:

2586

rbody.append(' %s[i].view = remap(pPacket->%s[i].view);' % (proto.params[-1].name, proto.params[-1].name))

2587

elif 'Memory' in proto.name:

2588

rbody.append(' %s[i].mem = remap(pPacket->%s[i].mem);' % (proto.params[-1].name, proto.params[-1].name))

2589

else:

2590

rbody.append(' %s[i].descriptorSet = remap(pPacket->%s[i].descriptorSet);' % (proto.params[-1].name, proto.params[-1].name))

2591

rbody.append(' }')

2592

elif proto.name in do_while_dict:

2593

rbody.append(' do {')

2594

rr_string = ' '

2595

if ret_value:

2596

rr_string = ' replayResult = '

2597

rr_string += 'm_xglFuncs.real_xgl%s(' % proto.name

2598

for p in proto.params:

2599

# For last param of Create funcs, pass address of param

Tobin Ehlis

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

[diff] [blame^]

2600

if create_func:

2601

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

2602

rr_string += '&local_%s, ' % p.name

2603

elif proto.name == 'AllocDescriptorSets' and p.name == proto.params[-2].name:

2604

rr_string += 'local_%s, ' % p.name

2605

else:

2606

rr_string += '%s, ' % self._get_packet_param(p.ty, p.name)

Tobin Ehlis

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

[diff] [blame]

2607

else:

2608

rr_string += '%s, ' % self._get_packet_param(p.ty, p.name)

2609

rr_string = '%s);' % rr_string[:-2]

2610

if transitions:

2611

rr_string = rr_string.replace('pPacket->pState', 'pState')

2612

elif ds_attach:

2613

rr_list = rr_string.split(', ')

2614

rr_list[-1] = '%s);' % proto.params[-1].name

2615

rr_string = ', '.join(rr_list)

2616

elif proto.name in custom_open_params:

2617

rr_list = rr_string.split(', ')

2618

rr_list[0] = rr_list[0].replace('remap(pPacket->device)', 'handle')

2619

for pidx in custom_open_params[proto.name]:

2620

rr_list[pidx] = '&local_%s' % proto.params[pidx].name

2621

rr_string = ', '.join(rr_list)

2622

rr_string += ');'

2623

elif create_view:

2624

rr_list = rr_string.split(', ')

2625

rr_list[-2] = '&createInfo'

2626

rr_list[-1] = '&local_%s);' % proto.params[-1].name

2627

rr_string = ', '.join(rr_list)

2628

# this is a sneaky shortcut to use generic create code below to add_to_map

2629

create_func = True

2630

rbody.append(rr_string)

2631

if 'DestroyDevice' in proto.name:

2632

rbody.append(' if (replayResult == XGL_SUCCESS)')

2633

rbody.append(' {')

2634

rbody.append(' rm_from_map(pPacket->device);')

2635

rbody.append(' m_display->m_initedXGL = false;')

2636

rbody.append(' }')

Tobin Ehlis

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

[diff] [blame^]

2637

elif 'AllocDescriptorSets' in proto.name:

2638

rbody.append(' if (replayResult == XGL_SUCCESS)')

2639

rbody.append(' {')

2640

rbody.append(' for (uint32_t i = 0; i < local_pCount; i++) {')

2641

rbody.append(' add_to_map(pPacket->%s, &local_%s[i]);' % (proto.params[-2].name, proto.params[-2].name))

2642

rbody.append(' }')

2643

rbody.append(' }')

Tobin Ehlis

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

[diff] [blame]

2644

elif create_func: # save handle mapping if create successful

2645

rbody.append(' if (replayResult == XGL_SUCCESS)')

2646

rbody.append(' {')

2647

rbody.append(' add_to_map(pPacket->%s, &local_%s);' % (proto.params[-1].name, proto.params[-1].name))

2648

if 'AllocMemory' == proto.name:

2649

rbody.append(' add_entry_to_mapData(local_%s, pPacket->pAllocInfo->allocationSize);' % (proto.params[-1].name))

2650

rbody.append(' }')

2651

elif transitions:

2652

rbody.append(' if (allocatedMem)')

2653

rbody.append(' {')

2654

rbody.append(' GLV_DELETE((void*)pStateTransitions);')

2655

rbody.append(' }')

2656

elif ds_attach:

2657

rbody.append(' GLV_DELETE(%s);' % proto.params[-1].name)

2658

elif proto.name in do_while_dict:

2659

rbody[-1] = ' %s' % rbody[-1]

2660

rbody.append(' } while (%s);' % do_while_dict[proto.name])

2661

if ret_value:

2662

rbody.append(' CHECK_RETURN_VALUE(xgl%s);' % proto.name)

2663

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.')

2668

rbody.append(' break;')

2669

rbody.append(' }')

2670

rbody.append(' default:')

2671

rbody.append(' glv_LogWarn("Unrecognized packet_id %u, skipping\\n", packet->packet_id);')

2672

rbody.append(' returnValue = glv_replay::GLV_REPLAY_INVALID_ID;')

2673

rbody.append(' break;')

2674

rbody.append(' }')

2675

rbody.append(' return returnValue;')

2676

rbody.append('}')

2677

return "\n".join(rbody)

2678

2679

class GlaveTraceHeader(Subcommand):

2680

def generate_header(self):

2681

header_txt = []

2682

header_txt.append('#include "glvtrace_xgl_xgl_structs.h"')

2683

header_txt.append('#include "glvtrace_xgl_packet_id.h"\n')

2684

header_txt.append('void AttachHooks();')

2685

header_txt.append('void DetachHooks();')

2686

header_txt.append('void InitTracer();\n')

2687

return "\n".join(header_txt)

2688

2689

def generate_body(self):

2690

body = [self._generate_trace_func_ptrs(),

2691

self._generate_trace_func_protos()]

2692

2693

return "\n".join(body)

2694

2695

class GlaveTraceC(Subcommand):

2696

def generate_header(self):

2697

header_txt = []

2698

header_txt.append('#include "glv_platform.h"')

2699

header_txt.append('#include "glv_common.h"')

2700

header_txt.append('#include "glvtrace_xgl_xgl.h"')

2701

header_txt.append('#include "glvtrace_xgl_xgldbg.h"')

2702

header_txt.append('#include "glvtrace_xgl_xglwsix11ext.h"')

2703

header_txt.append('#include "glv_interconnect.h"')

2704

header_txt.append('#include "glv_filelike.h"')

2705

header_txt.append('#ifdef WIN32')

2706

header_txt.append('#include "mhook/mhook-lib/mhook.h"')

2707

header_txt.append('#endif')

2708

header_txt.append('#include "glv_trace_packet_utils.h"')

2709

header_txt.append('#include <stdio.h>\n')

2710

return "\n".join(header_txt)

2711

2712

def generate_body(self):

2713

body = [self._generate_func_ptr_assignments(),

2714

self._generate_attach_hooks(),

2715

self._generate_detach_hooks(),

Jon Ashburn

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

[diff] [blame]

2716

self._generate_init_funcs(),

Tobin Ehlis

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

[diff] [blame]

2717

self._generate_helper_funcs(),

2718

self._generate_trace_funcs()]

2719

2720

return "\n".join(body)

2721

2722

class GlavePacketID(Subcommand):

2723

def generate_header(self):

2724

header_txt = []

2725

header_txt.append('#pragma once\n')

2726

header_txt.append('#include "glv_trace_packet_utils.h"')

2727

header_txt.append('#include "glv_trace_packet_identifiers.h"')

2728

header_txt.append('#include "glv_interconnect.h"')

2729

header_txt.append('#include "glvtrace_xgl_xgl_structs.h"')

2730

header_txt.append('#include "glvtrace_xgl_xgldbg_structs.h"')

2731

header_txt.append('#include "glvtrace_xgl_xglwsix11ext_structs.h"')

2732

header_txt.append('#include "xgl_enum_string_helper.h"')

2733

header_txt.append('#define SEND_ENTRYPOINT_ID(entrypoint) ;')

2734

header_txt.append('//#define SEND_ENTRYPOINT_ID(entrypoint) glv_TraceInfo(#entrypoint "\\n");\n')

2735

header_txt.append('#define SEND_ENTRYPOINT_PARAMS(entrypoint, ...) ;')

2736

header_txt.append('//#define SEND_ENTRYPOINT_PARAMS(entrypoint, ...) glv_TraceInfo(entrypoint, __VA_ARGS__);\n')

2737

header_txt.append('#define CREATE_TRACE_PACKET(entrypoint, buffer_bytes_needed) \\')

2738

header_txt.append(' pHeader = glv_create_trace_packet(GLV_TID_XGL, GLV_TPI_XGL_##entrypoint, sizeof(struct_##entrypoint), buffer_bytes_needed);\n')

2739

header_txt.append('#define FINISH_TRACE_PACKET() \\')

2740

header_txt.append(' glv_finalize_trace_packet(pHeader); \\')

2741

header_txt.append(' glv_write_trace_packet(pHeader, glv_trace_get_trace_file()); \\')

2742

header_txt.append(' glv_delete_trace_packet(&pHeader);')

2743

return "\n".join(header_txt)

2744

2745

def generate_body(self):

2746

body = [self._generate_packet_id_enum(),

2747

self._generate_stringify_func(),

2748

self._generate_interp_func()]

2749

2750

return "\n".join(body)

2751

2752

class GlaveCoreStructs(Subcommand):

2753

def generate_header(self):

2754

header_txt = []

2755

header_txt.append('#pragma once\n')

2756

header_txt.append('#include "xgl.h"')

2757

header_txt.append('#include "glv_trace_packet_utils.h"\n')

2758

return "\n".join(header_txt)

2759

2760

def generate_body(self):

2761

body = [self._generate_struct_util_funcs(),

2762

self._generate_interp_funcs()]

2763

2764

return "\n".join(body)

2765

2766

class GlaveWsiHeader(Subcommand):

2767

def generate_header(self):

2768

header_txt = []

2769

header_txt.append('#pragma once\n')

2770

header_txt.append('#include "xgl.h"')

2771

header_txt.append('#include "xglWsiX11Ext.h"\n')

2772

header_txt.append('void AttachHooks_xglwsix11ext();')

2773

header_txt.append('void DetachHooks_xglwsix11ext();')

2774

return "\n".join(header_txt)

2775

2776

def generate_body(self):

2777

body = [self._generate_trace_func_ptrs_ext(),

2778

self._generate_trace_func_protos_ext()]

2779

2780

return "\n".join(body)

2781

2782

class GlaveWsiC(Subcommand):

2783

def generate_header(self):

2784

header_txt = []

2785

header_txt.append('#include "glv_platform.h"')

2786

header_txt.append('#include "glv_common.h"')

2787

header_txt.append('#include "glvtrace_xgl_xglwsix11ext.h"')

2788

header_txt.append('#include "glvtrace_xgl_xglwsix11ext_structs.h"')

2789

header_txt.append('#include "glvtrace_xgl_packet_id.h"')

2790

header_txt.append('#ifdef WIN32')

2791

header_txt.append('#include "mhook/mhook-lib/mhook.h"')

2792

header_txt.append('#endif')

2793

return "\n".join(header_txt)

2794

2795

def generate_body(self):

2796

body = [self._generate_func_ptr_assignments_ext(),

2797

self._generate_attach_hooks_ext(),

2798

self._generate_detach_hooks_ext(),

2799

self._generate_trace_funcs_ext()]

2800

2801

return "\n".join(body)

2802

2803

class GlaveWsiStructs(Subcommand):

2804

def generate_header(self):

2805

header_txt = []

2806

header_txt.append('#pragma once\n')

2807

header_txt.append('#include "xglWsiX11Ext.h"')

2808

header_txt.append('#include "glv_trace_packet_utils.h"\n')

2809

return "\n".join(header_txt)

2810

2811

def generate_body(self):

2812

body = [self._generate_interp_funcs_ext()]

2813

2814

return "\n".join(body)

2815

2816

class GlaveDbgHeader(Subcommand):

2817

def generate_header(self):

2818

header_txt = []

2819

header_txt.append('#pragma once\n')

2820

header_txt.append('#include "xgl.h"')

2821

header_txt.append('#include "xglDbg.h"\n')

2822

header_txt.append('void AttachHooks_xgldbg();')

2823

header_txt.append('void DetachHooks_xgldbg();')

2824

return "\n".join(header_txt)

2825

2826

def generate_body(self):

2827

body = [self._generate_trace_func_ptrs_ext('Dbg'),

2828

self._generate_trace_func_protos_ext('Dbg')]

2829

2830

return "\n".join(body)

2831

2832

class GlaveDbgC(Subcommand):

2833

def generate_header(self):

2834

header_txt = []

2835

header_txt.append('#include "glv_platform.h"')

2836

header_txt.append('#include "glv_common.h"')

2837

header_txt.append('#include "glvtrace_xgl_xgl.h"')

2838

header_txt.append('#include "glvtrace_xgl_xgldbg.h"')

2839

header_txt.append('#include "glvtrace_xgl_xgldbg_structs.h"')

2840

header_txt.append('#include "glvtrace_xgl_packet_id.h"')

2841

header_txt.append('#ifdef WIN32')

2842

header_txt.append('#include "mhook/mhook-lib/mhook.h"')

2843

header_txt.append('#endif')

2844

return "\n".join(header_txt)

2845

2846

def generate_body(self):

2847

body = [self._generate_func_ptr_assignments_ext('Dbg'),

2848

self._generate_attach_hooks_ext('Dbg'),

2849

self._generate_detach_hooks_ext('Dbg'),

2850

self._generate_trace_funcs_ext('Dbg')]

2851

2852

return "\n".join(body)

2853

2854

class GlaveDbgStructs(Subcommand):

2855

def generate_header(self):

2856

header_txt = []

2857

header_txt.append('#pragma once\n')

2858

header_txt.append('#include "xglDbg.h"')

2859

header_txt.append('#include "glv_trace_packet_utils.h"\n')

2860

return "\n".join(header_txt)

2861

2862

def generate_body(self):

2863

body = [self._generate_interp_funcs_ext('Dbg')]

2864

2865

return "\n".join(body)

2866

2867

class GlaveReplayHeader(Subcommand):

2868

def generate_header(self):

2869

header_txt = []

2870

header_txt.append('#pragma once\n')

2871

header_txt.append('#include <set>')

2872

header_txt.append('#include <map>')

2873

header_txt.append('#include <vector>')

2874

header_txt.append('#include <xcb/xcb.h>\n')

2875

header_txt.append('#include "glvreplay_window.h"')

2876

header_txt.append('#include "glvreplay_factory.h"')

2877

header_txt.append('#include "glv_trace_packet_identifiers.h"\n')

2878

header_txt.append('#include "xgl.h"')

2879

header_txt.append('#include "xglDbg.h"')

2880

header_txt.append('#include "xglWsiX11Ext.h"')

2881

return "\n".join(header_txt)

2882

2883

def generate_body(self):

2884

body = [self._generate_replay_class_decls(),

2885

self._generate_replay_func_ptrs(),

2886

self._generate_replay_class()]

2887

2888

return "\n".join(body)

2889

2890

class GlaveReplayC(Subcommand):

2891

def generate_header(self):

2892

header_txt = []

2893

header_txt.append('#include "glvreplay_xgl_replay.h"\n')

Jon Ashburn

2014-12-18 17:03:34 -0700

[diff] [blame]

2894

header_txt.append('#include "glvreplay_xgl.h"\n')

Tobin Ehlis

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

[diff] [blame]

2895

header_txt.append('extern "C" {')

2896

header_txt.append('#include "glvtrace_xgl_xgl_structs.h"')

2897

header_txt.append('#include "glvtrace_xgl_xgldbg_structs.h"')

2898

header_txt.append('#include "glvtrace_xgl_xglwsix11ext_structs.h"')

2899

header_txt.append('#include "glvtrace_xgl_packet_id.h"')

2900

header_txt.append('#include "xgl_enum_string_helper.h"\n}\n')

2901

header_txt.append('#define APP_NAME "glvreplay_xgl"')

2902

header_txt.append('#define IDI_ICON 101\n')

2903

header_txt.append('static const char* g_extensions[] =')

2904

header_txt.append('{')

2905

header_txt.append(' "XGL_WSI_WINDOWS",')

2906

header_txt.append(' "XGL_TIMER_QUEUE",')

2907

header_txt.append(' "XGL_GPU_TIMESTAMP_CALIBRATION",')

2908

header_txt.append(' "XGL_DMA_QUEUE",')

2909

header_txt.append(' "XGL_COMMAND_BUFFER_CONTROL_FLOW",')

2910

header_txt.append(' "XGL_COPY_OCCLUSION_QUERY_DATA",')

2911

header_txt.append(' "XGL_ADVANCED_MULTISAMPLING",')

2912

header_txt.append(' "XGL_BORDER_COLOR_PALETTE"')

2913

header_txt.append('};')

2914

return "\n".join(header_txt)

2915

2916

def generate_body(self):

2917

body = [self._generate_replay_display_init_xgl(),

2918

self._generate_replay_display_init(),

2919

self._generate_replay_display_structors(),

2920

self._generate_replay_display_window(),

2921

self._generate_replay_structors(),

2922

self._generate_replay_init(),

Tobin Ehlis

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

[diff] [blame]

2923

self._generate_replay_errors(),

Jon Ashburn

2014-12-18 17:03:34 -0700

[diff] [blame]

2924

self._generate_replay_validation_funcs(),

Tobin Ehlis