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

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

[diff] [blame]

292

def _generate_init_funcs(self):

Tobin Ehlis

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

[diff] [blame]

293

init_tracer = []

Jon Ashburn

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

[diff] [blame]

294

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

295

init_tracer.append(' struct_xglApiVersion* pPacket;')

296

init_tracer.append(' glv_trace_packet_header* pHeader;')

297

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

298

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

299

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

300

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

301

Tobin Ehlis

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

[diff] [blame]

302

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

303

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

304

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

305

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]

306

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

307

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

Tobin Ehlis

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

[diff] [blame]

308

return "\n".join(init_tracer)

309

310

# InitAndEnumerateGpus is unique enough that it gets custom generation code

311

def _gen_iande_gpus(self):

312

iae_body = []

313

iae_body.append('GLVTRACER_EXPORT XGL_RESULT XGLAPI __HOOKED_xglInitAndEnumerateGpus(')

314

iae_body.append(' const XGL_APPLICATION_INFO* pAppInfo,')

315

iae_body.append(' const XGL_ALLOC_CALLBACKS* pAllocCb,')

316

iae_body.append(' XGL_UINT maxGpus,')

317

iae_body.append(' XGL_UINT* pGpuCount,')

318

iae_body.append(' XGL_PHYSICAL_GPU* pGpus)')

319

iae_body.append('{')

320

iae_body.append(' glv_trace_packet_header* pHeader;')

321

iae_body.append(' XGL_RESULT result;')

322

iae_body.append(' uint64_t startTime;')

323

iae_body.append(' struct_xglInitAndEnumerateGpus* pPacket;')

324

iae_body.append('')

325

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

326

iae_body.append(' SEND_ENTRYPOINT_ID(xglInitAndEnumerateGpus);')

327

iae_body.append(' if (real_xglInitAndEnumerateGpus == xglInitAndEnumerateGpus)')

328

iae_body.append(' {')

329

iae_body.append(' glv_platform_get_next_lib_sym((void **) &real_xglInitAndEnumerateGpus,"xglInitAndEnumerateGpus");')

330

iae_body.append(' }')

331

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

332

iae_body.append(' result = real_xglInitAndEnumerateGpus(pAppInfo, pAllocCb, maxGpus, pGpuCount, pGpus);')

333

iae_body.append('')

334

iae_body.append(' // since we do not know how many gpus will be found must create trace packet after calling xglInit')

335

iae_body.append(' CREATE_TRACE_PACKET(xglInitAndEnumerateGpus, calc_size_XGL_APPLICATION_INFO(pAppInfo) + ((pAllocCb == NULL) ? 0 :sizeof(XGL_ALLOC_CALLBACKS))')

336

iae_body.append(' + sizeof(XGL_UINT) + ((pGpus && pGpuCount) ? *pGpuCount * sizeof(XGL_PHYSICAL_GPU) : 0));')

337

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

338

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

339

iae_body.append(' AttachHooks();')

340

iae_body.append(' AttachHooks_xgldbg();')

341

iae_body.append(' AttachHooks_xglwsix11ext();')

342

iae_body.append(' }')

343

iae_body.append(' pPacket = interpret_body_as_xglInitAndEnumerateGpus(pHeader);')

344

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

345

iae_body.append(' if (pAllocCb) {')

346

iae_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pAllocCb), sizeof(XGL_ALLOC_CALLBACKS), pAllocCb);')

347

iae_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pAllocCb));')

348

iae_body.append(' }')

349

iae_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pGpuCount), sizeof(XGL_UINT), pGpuCount);')

350

iae_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pGpuCount));')

351

iae_body.append(' if (pGpuCount && pGpus)')

352

iae_body.append(' {')

353

iae_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(pPacket->pGpus), sizeof(XGL_PHYSICAL_GPU) * *pGpuCount, pGpus);')

354

iae_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(pPacket->pGpus));')

355

iae_body.append(' }')

356

iae_body.append(' pPacket->maxGpus = maxGpus;')

357

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

358

iae_body.append(' FINISH_TRACE_PACKET();')

359

iae_body.append(' return result;')

360

iae_body.append('}\n')

361

return "\n".join(iae_body)

362

363

def _gen_unmap_memory(self):

364

um_body = []

365

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

366

um_body.append(' XGL_GPU_MEMORY mem)')

367

um_body.append('{')

368

um_body.append(' glv_trace_packet_header* pHeader;')

369

um_body.append(' XGL_RESULT result;')

370

um_body.append(' struct_xglUnmapMemory* pPacket;')

371

um_body.append(' XGLAllocInfo *entry;')

372

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

373

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

374

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

375

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

376

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

377

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

378

um_body.append(' if (entry)')

379

um_body.append(' {')

380

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

381

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

382

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

383

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

384

um_body.append(' }')

385

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

386

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

387

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

388

um_body.append(' FINISH_TRACE_PACKET();')

389

um_body.append(' return result;')

390

um_body.append('}\n')

391

return "\n".join(um_body)

392

393

#EL == EnumerateLayers

394

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

395

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

396

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

397

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

398

399

def _generate_trace_funcs(self):

400

func_body = []

401

for proto in self.protos:

402

if 'InitAndEnumerateGpus' == proto.name:

403

func_body.append(self._gen_iande_gpus())

404

elif 'UnmapMemory' == proto.name:

405

func_body.append(self._gen_unmap_memory())

406

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

407

packet_update_txt = ''

408

return_txt = ''

409

packet_size = ''

410

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

411

buff_ptr_indices = []

412

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

413

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

414

if 'color' == p.name:

415

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

416

else:

417

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

418

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

419

if 'pData' == p.name:

420

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

421

packet_size += 'dataSize + '

422

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

423

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

424

else:

425

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

426

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

427

packet_size += 'sizeof(XGL_VOID*) + '

428

elif 'VOID' in p.ty:

429

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

430

elif 'CHAR' in p.ty:

Chia-I Wu

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

[diff] [blame]

431

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

Tobin Ehlis

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

[diff] [blame]

432

elif 'DEVICE_CREATE_INFO' in p.ty:

433

packet_size += 'calc_size_XGL_DEVICE_CREATE_INFO(pCreateInfo) + '

434

elif 'pDataSize' in p.name:

435

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

436

in_data_size = True;

437

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

438

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

439

else:

440

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

441

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

442

else:

443

if 'color' == p.name:

444

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

445

else:

446

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

447

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

448

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

449

if '' == packet_size:

450

packet_size = '0'

451

else:

452

packet_size = packet_size.strip(' + ')

453

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

454

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

455

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

456

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

457

return_txt = 'result = '

458

if in_data_size:

459

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

460

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

461

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

462

if 'EnumerateLayers' == proto.name:

463

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

464

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

465

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

466

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

Chia-I Wu

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

[diff] [blame]

467

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

Tobin Ehlis

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

[diff] [blame]

468

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

469

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

470

func_body.append(' size_t customSize;')

471

if 'CreateShader' == proto.name:

472

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

473

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

474

elif 'CreateGraphicsPipeline' == proto.name:

475

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

476

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

477

else: #'CreateComputePipeline'

478

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

479

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

480

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

481

else:

482

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

483

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

484

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

485

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

486

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

487

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

488

func_body.append(' {')

489

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

490

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

491

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

492

func_body.append(' }')

493

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

494

func_body.append(' FINISH_TRACE_PACKET();')

495

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

496

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

497

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

498

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

499

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

Chia-I Wu

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

[diff] [blame]

500

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]

501

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

502

func_body.append(' }')

503

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

504

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

505

506

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

507

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

508

func_body.append(' FINISH_TRACE_PACKET();')

509

else:

510

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

511

for idx in buff_ptr_indices:

512

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

513

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

514

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

Chia-I Wu

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

[diff] [blame]

515

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]

516

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

517

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

518

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

519

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

520

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

521

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

522

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

523

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

524

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

525

elif in_data_size:

526

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

527

else:

528

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

529

else:

530

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('*').strip('const '), proto.params[idx].name))

531

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

532

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

533

if 'CreateShader' == proto.name:

534

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

535

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

536

elif 'CreateGraphicsPipeline' == proto.name:

537

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

538

else:

539

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

540

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

541

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

542

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

543

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

544

for idx in buff_ptr_indices:

545

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

546

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

547

func_body.append(' FINISH_TRACE_PACKET();')

548

if 'AllocMemory' in proto.name:

549

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

550

elif 'FreeMemory' in proto.name:

551

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

552

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

553

func_body.append(' return result;')

554

func_body.append('}\n')

555

return "\n".join(func_body)

556

557

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

558

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

559

func_body = []

560

for proto in self.protos:

561

if func_class in proto.name:

562

packet_update_txt = ''

563

return_txt = ''

564

packet_size = ''

565

buff_ptr_indices = []

566

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

567

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

568

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

569

if 'Size' in p.name:

570

packet_size += p.name

571

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

572

if 'CHAR' in p.ty:

Chia-I Wu

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

[diff] [blame]

573

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

Tobin Ehlis

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

[diff] [blame]

574

elif 'Size' not in packet_size:

575

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

576

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

577

if 'pConnectionInfo' in p.name:

578

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

579

else:

580

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

581

if '' == packet_size:

582

packet_size = '0'

583

else:

584

packet_size = packet_size.strip(' + ')

585

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

586

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

587

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

588

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

589

return_txt = 'result = '

590

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

591

if proto.name in thread_once_funcs:

592

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

593

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

594

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

595

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

596

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

597

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

598

for idx in buff_ptr_indices:

599

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

Chia-I Wu

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

[diff] [blame]

600

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]

601

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

602

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

603

else:

604

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('*').strip('const '), proto.params[idx].name))

605

if 'WsiX11AssociateConnection' in proto.name:

606

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

607

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

608

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

609

func_body.append(' }')

610

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

611

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

612

for idx in buff_ptr_indices:

613

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

614

func_body.append(' FINISH_TRACE_PACKET();')

615

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

616

func_body.append(' return result;')

617

func_body.append('}\n')

618

return "\n".join(func_body)

619

620

def _generate_helper_funcs(self):

621

hf_body = []

622

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

623

hf_body.append('typedef struct _XGLAllocInfo {')

624

hf_body.append(' XGL_GPU_SIZE size;')

625

hf_body.append(' XGL_GPU_MEMORY handle;')

626

hf_body.append(' XGL_VOID *pData;')

627

hf_body.append(' BOOL valid;')

628

hf_body.append('} XGLAllocInfo;')

629

hf_body.append('typedef struct _XGLMemInfo {')

630

hf_body.append(' unsigned int numEntrys;')

631

hf_body.append(' XGLAllocInfo *pEntrys;')

632

hf_body.append(' XGLAllocInfo *pLastMapped;')

633

hf_body.append(' unsigned int capacity;')

634

hf_body.append('} XGLMemInfo;')

635

hf_body.append('')

636

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

637

hf_body.append('')

638

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

639

hf_body.append('{')

640

hf_body.append(' unsigned int i;')

641

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

642

hf_body.append(' {')

643

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

644

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

645

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

646

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

647

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

hf_body.append(' }')

hf_body.append('}')

hf_body.append('')

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

652

hf_body.append('{')

653

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

654

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

655

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

656

hf_body.append('')

657

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

658

hf_body.append('')

659

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

660

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

661

hf_body.append(' else')

662

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

663

hf_body.append('}')

664

hf_body.append('')

665

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

666

hf_body.append('{')

667

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

668

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

669

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

670

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

671

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

672

hf_body.append('}')

673

hf_body.append('')

674

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

675

hf_body.append('{')

676

hf_body.append(' unsigned int i;')

677

hf_body.append(' XGLAllocInfo *entry;')

678

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

679

hf_body.append(' {')

680

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

681

hf_body.append(' return NULL;')

682

hf_body.append(' }')

683

hf_body.append('')

684

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

685

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

686

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

687

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

688

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

689

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

690

hf_body.append(' }')

691

hf_body.append('')

692

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

693

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

694

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

695

hf_body.append(' {')

696

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

697

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

698

hf_body.append(' }')

699

hf_body.append('')

700

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

701

hf_body.append(' return NULL;')

702

hf_body.append('}')

703

hf_body.append('')

704

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

705

hf_body.append('{')

706

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

707

hf_body.append(' unsigned int i;')

708

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

709

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

710

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

711

hf_body.append(' {')

712

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

713

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

714

hf_body.append(' }')

715

hf_body.append('')

716

hf_body.append(' return NULL;')

717

hf_body.append('}')

718

hf_body.append('')

719

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

720

hf_body.append('{')

721

hf_body.append(' XGLAllocInfo *entry;')

722

hf_body.append('')

723

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

724

hf_body.append(' init_mem_info();')

725

hf_body.append('')

726

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

727

hf_body.append(' if (entry)')

728

hf_body.append(' {')

729

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

730

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

731

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

732

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

733

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

hf_body.append(' }')

hf_body.append('}')

hf_body.append('')

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

738

hf_body.append('{')

739

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

740

hf_body.append('')

741

hf_body.append(' if (entry)')

742

hf_body.append(' {')

743

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

744

hf_body.append(' }')

745

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

746

hf_body.append('}')

747

hf_body.append('')

748

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

749

hf_body.append('{')

750

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

751

hf_body.append('')

752

hf_body.append(' if (entry)')

753

hf_body.append(' {')

754

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

755

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

756

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

757

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

758

hf_body.append('')

759

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

760

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

761

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

762

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

763

hf_body.append(' delete_mem_info();')

hf_body.append(' }')

hf_body.append('}')

hf_body.append('')

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

768

hf_body.append('{')

769

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

770

hf_body.append(' XGL_UINT i, j;')

771

hf_body.append(' ')

772

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

773

hf_body.append(' // descriptor sets')

774

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

775

hf_body.append(' {')

776

hf_body.append(' for (j = 0; j < shader->descriptorSetMapping[i].descriptorCount; j++)')

777

hf_body.append(' {')

778

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

779

hf_body.append(' if (shader->descriptorSetMapping[i].pDescriptorInfo[j].slotObjectType == XGL_SLOT_NEXT_DESCRIPTOR_SET)')

780

hf_body.append(' {')

781

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

hf_body.append(' }')

hf_body.append(' }')

hf_body.append(' }')

hf_body.append('')

hf_body.append(' // constant buffers')

787

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

788

hf_body.append(' {')

789

hf_body.append(' XGL_UINT i;')

790

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

791

hf_body.append(' {')

792

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

793

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

794

hf_body.append(' }')

795

hf_body.append(' }')

796

hf_body.append(' return size;')

797

hf_body.append('}')

798

hf_body.append('')

799

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

800

hf_body.append('{')

801

hf_body.append(' XGL_UINT i, j;')

802

hf_body.append(' // descriptor sets')

803

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

804

hf_body.append(' {')

805

hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(packetShader->descriptorSetMapping[i].pDescriptorInfo), sizeof(XGL_DESCRIPTOR_SLOT_INFO)* paramShader->descriptorSetMapping[i].descriptorCount, paramShader->descriptorSetMapping[i].pDescriptorInfo);')

806

hf_body.append(' for (j = 0; j < paramShader->descriptorSetMapping[i].descriptorCount; j++)')

807

hf_body.append(' {')

808

hf_body.append(' if (paramShader->descriptorSetMapping[i].pDescriptorInfo[j].slotObjectType == XGL_SLOT_NEXT_DESCRIPTOR_SET)')

809

hf_body.append(' {')

810

hf_body.append(' glv_add_buffer_to_trace_packet(pHeader, (void**)&(packetShader->descriptorSetMapping[i].pDescriptorInfo[j].pNextLevelSet), sizeof(XGL_DESCRIPTOR_SET_MAPPING), paramShader->descriptorSetMapping[i].pDescriptorInfo[j].pNextLevelSet);')

811

hf_body.append(' }')

812

hf_body.append(' }')

813

hf_body.append(' packetShader->descriptorSetMapping[i].descriptorCount = paramShader->descriptorSetMapping[i].descriptorCount;')

814

hf_body.append(' }')

815

hf_body.append('')

816

hf_body.append(' // constant buffers')

817

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

818

hf_body.append(' {')

819

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

820

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

821

hf_body.append(' {')

822

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

828

hf_body.append('{')

829

hf_body.append(' XGL_UINT i, j;')

830

hf_body.append(' // descriptor sets')

831

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

832

hf_body.append(' {')

833

hf_body.append(' for (j = 0; j < packetShader->descriptorSetMapping[i].descriptorCount; j++)')

834

hf_body.append(' {')

835

hf_body.append(' if (packetShader->descriptorSetMapping[i].pDescriptorInfo[j].slotObjectType == XGL_SLOT_NEXT_DESCRIPTOR_SET)')

836

hf_body.append(' {')

837

hf_body.append(' glv_finalize_buffer_address(pHeader, (void**)&(packetShader->descriptorSetMapping[i].pDescriptorInfo[j].pNextLevelSet));')

838

hf_body.append(' }')

839

hf_body.append(' }')

840

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

841

hf_body.append(' }')

842

hf_body.append('')

843

hf_body.append(' // constant buffers')

844

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

845

hf_body.append(' {')

846

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

847

hf_body.append(' {')

848

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

849

hf_body.append(' }')

850

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

hf_body.append(' }')

hf_body.append('}')

hf_body.append('')

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

855

hf_body.append('{')

856

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

857

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

858

hf_body.append(' while (pNext)')

859

hf_body.append(' {')

860

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

861

hf_body.append(' {')

862

hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO:')

863

hf_body.append(' totalStateSize += sizeof(XGL_PIPELINE_IA_STATE_CREATE_INFO);')

864

hf_body.append(' break;')

865

hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO:')

866

hf_body.append(' totalStateSize += sizeof(XGL_PIPELINE_TESS_STATE_CREATE_INFO);')

867

hf_body.append(' break;')

868

hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO:')

869

hf_body.append(' totalStateSize += sizeof(XGL_PIPELINE_RS_STATE_CREATE_INFO);')

870

hf_body.append(' break;')

871

hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_DB_STATE_CREATE_INFO:')

872

hf_body.append(' totalStateSize += sizeof(XGL_PIPELINE_DB_STATE_CREATE_INFO);')

873

hf_body.append(' break;')

874

hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:')

875

hf_body.append(' totalStateSize += sizeof(XGL_PIPELINE_CB_STATE);')

876

hf_body.append(' break;')

877

hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:')

878

hf_body.append(' {')

879

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

880

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

881

hf_body.append(' break;')

882

hf_body.append(' }')

883

hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:')

884

hf_body.append(' {')

885

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

886

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

887

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

888

hf_body.append(' break;')

889

hf_body.append(' }')

890

hf_body.append(' default:')

891

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

892

hf_body.append(' }')

893

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

894

hf_body.append(' }')

895

hf_body.append(' return totalStateSize;')

896

hf_body.append('}')

897

hf_body.append('')

898

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

899

hf_body.append('{')

900

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

901

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

902

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

903

hf_body.append(' {')

904

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

905

hf_body.append(' ppOutNext = NULL;')

906

hf_body.append('')

907

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

908

hf_body.append(' {')

909

hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO:')

910

hf_body.append(' {')

911

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

912

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

913

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

914

hf_body.append(' break;')

915

hf_body.append(' }')

916

hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO:')

917

hf_body.append(' {')

918

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

919

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

920

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

921

hf_body.append(' break;')

922

hf_body.append(' }')

923

hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO:')

924

hf_body.append(' {')

925

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

926

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

927

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

928

hf_body.append(' break;')

929

hf_body.append(' }')

930

hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_DB_STATE_CREATE_INFO:')

931

hf_body.append(' {')

932

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

933

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

934

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

935

hf_body.append(' break;')

936

hf_body.append(' }')

937

hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:')

938

hf_body.append(' {')

939

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

940

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

941

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

942

hf_body.append(' break;')

943

hf_body.append(' }')

944

hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:')

945

hf_body.append(' {')

946

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

947

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

948

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

949

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

950

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

951

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

952

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

953

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

954

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

955

hf_body.append(' break;')

956

hf_body.append(' }')

957

hf_body.append(' case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:')

958

hf_body.append(' {')

959

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

960

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

961

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

962

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

963

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

964

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

965

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

966

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

967

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

968

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

969

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

970

hf_body.append(' break;')

971

hf_body.append(' }')

972

hf_body.append(' default:')

973

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

974

hf_body.append(' }')

975

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

976

hf_body.append(' }')

977

hf_body.append(' return;')

978

hf_body.append('}')

979

return "\n".join(hf_body)

980

981

def _generate_packet_id_enum(self):

982

pid_enum = []

983

pid_enum.append('enum GLV_TRACE_PACKET_ID_XGL')

984

pid_enum.append('{')

985

first_func = True

986

for proto in self.protos:

987

if first_func:

988

first_func = False

Jon Ashburn

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

[diff] [blame]

989

pid_enum.append(' GLV_TPI_XGL_xglApiVersion = GLV_TPI_BEGIN_API_HERE,')

990

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

Tobin Ehlis

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

[diff] [blame]

991

else:

992

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

993

pid_enum.append('};\n')

994

return "\n".join(pid_enum)

995

996

def _generate_stringify_func(self):

997

func_body = []

998

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

999

func_body.append('{')

1000

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

1001

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

Jon Ashburn

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

[diff] [blame]

1002

func_body.append(' case GLV_TPI_XGL_xglApiVersion:')

1003

func_body.append(' {')

1004

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

1005

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

1006

func_body.append(' return str;')

1007

func_body.append(' }')

Tobin Ehlis

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

[diff] [blame]

1008

for proto in self.protos:

1009

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

1010

func_body.append(' {')

1011

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

1012

print_vals = ''

1013

create_func = False

1014

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

1015

create_func = True

1016

for p in proto.params:

1017

last_param = False

1018

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

1019

last_param = True

1020

if last_param and create_func: # last param of create func

1021

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

1022

else:

1023

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

1024

if last_param == True:

1025

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

1026

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

1027

else:

1028

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

1029

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

1030

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

1031

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

1032

func_body.append(' return str;')

1033

func_body.append(' }')

1034

func_body.append(' default:')

1035

func_body.append(' return NULL;')

1036

func_body.append(' }')

1037

func_body.append('};\n')

1038

return "\n".join(func_body)

1039

1040

def _generate_interp_func(self):

1041

interp_func_body = []

1042

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

1043

interp_func_body.append('{')

1044

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

1045

interp_func_body.append(' {')

1046

interp_func_body.append(' return NULL;')

1047

interp_func_body.append(' }')

1048

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

1049

interp_func_body.append(' {')

Jon Ashburn

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

[diff] [blame]

1050

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

1051

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

Tobin Ehlis

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

[diff] [blame]

1052

for proto in self.protos:

1053

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

1054

header_prefix = 'h'

1055

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

1056

header_prefix = 'pH'

1057

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

1058

interp_func_body.append(' default:')

1059

interp_func_body.append(' return NULL;')

1060

interp_func_body.append(' }')

1061

interp_func_body.append(' return NULL;')

1062

interp_func_body.append('}')

1063

return "\n".join(interp_func_body)

1064

1065

def _generate_struct_util_funcs(self):

1066

pid_enum = []

1067

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

1068

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

1069

pid_enum.append('{')

Chia-I Wu

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

[diff] [blame]

1070

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]

1071

pid_enum.append('}\n')

1072

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

1073

pid_enum.append('{')

1074

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]

1075

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

1076

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]

1077

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

1078

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

1079

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

1080

pid_enum.append('};\n')

1081

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

1082

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

1083

pid_enum.append('{')

1084

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

1085

pid_enum.append(' uint32_t i;')

1086

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

1087

pid_enum.append(' {')

Chia-I Wu

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

[diff] [blame]

1088

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

Tobin Ehlis

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

[diff] [blame]

1089

pid_enum.append(' }')

Jon Ashburn

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

[diff] [blame^]

1090

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

1091

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

1092

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

1093

pid_enum.append(' {')

1094

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

1095

pid_enum.append(' {')

1096

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

1097

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

1098

pid_enum.append(' {')

1099

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

1100

pid_enum.append(' }')

1101

pid_enum.append(' }')

1102

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

1103

pid_enum.append(' }')

1104

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]

1105

pid_enum.append('}\n')

1106

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

1107

pid_enum.append('{')

1108

pid_enum.append(' uint32_t i;')

1109

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

1110

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

1111

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

1112

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

1113

pid_enum.append(' {')

1114

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

1115

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

1116

pid_enum.append(' {')

Chia-I Wu

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

[diff] [blame]

1117

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]

1118

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

1119

pid_enum.append(' }')

1120

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

1121

pid_enum.append(' }')

Jon Ashburn

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

[diff] [blame^]

1122

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

1123

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

1124

pid_enum.append(' {')

1125

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

1126

pid_enum.append(' {')

1127

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

1128

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

1129

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

1130

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

1131

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

1132

pid_enum.append(' {')

1133

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

1134

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

1135

pid_enum.append(' }')

1136

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

1137

pid_enum.append(' }')

1138

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

1139

pid_enum.append(' }')

Tobin Ehlis

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

[diff] [blame]

1140

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

1141

pid_enum.append('}\n')

1142

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

1143

pid_enum.append('{')

1144

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

1145

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

1146

pid_enum.append(' {')

Jon Ashburn

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

[diff] [blame^]

1147

pid_enum.append(' uint32_t i;')

1148

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

Tobin Ehlis

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

[diff] [blame]

1149

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

1150

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

1151

pid_enum.append(' {')

Tobin Ehlis

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

[diff] [blame]

1152

pid_enum.append(' pXGL_DEVICE_CREATE_INFO->ppEnabledExtensionNames = (const XGL_CHAR *const*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pXGL_DEVICE_CREATE_INFO->ppEnabledExtensionNames);')

1153

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

1154

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

1155

pid_enum.append(' {')

1156

pid_enum.append(' pNames[i] = (const XGL_CHAR*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)(pXGL_DEVICE_CREATE_INFO->ppEnabledExtensionNames[i]));')

1157

pid_enum.append(' }')

1158

pid_enum.append(' }')

Jon Ashburn

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

[diff] [blame^]

1159

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

1160

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

1161

pid_enum.append(' {')

1162

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

1163

pid_enum.append(' {')

1164

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

1165

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

1166

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

1167

pid_enum.append(' {')

1168

pid_enum.append(' pNames[i] = (const XGL_CHAR*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)(pNext->ppActiveLayerNames[i]));')

1169

pid_enum.append(' }')

1170

pid_enum.append(' }')

1171

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

1172

pid_enum.append(' }')

Tobin Ehlis

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

[diff] [blame]

1173

pid_enum.append(' }\n')

1174

pid_enum.append(' return pXGL_DEVICE_CREATE_INFO;')

1175

pid_enum.append('}\n')

1176

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

1177

pid_enum.append('{')

1178

pid_enum.append(' XGL_UINT i, j;')

1179

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

1180

pid_enum.append(' {')

1181

pid_enum.append(' // descriptor sets')

1182

pid_enum.append(' // TODO: need to ensure XGL_MAX_DESCRIPTOR_SETS is equal in replay as it was at trace time - meta data')

1183

pid_enum.append(' for (i = 0; i < XGL_MAX_DESCRIPTOR_SETS; i++)')

1184

pid_enum.append(' {')

1185

pid_enum.append(' pShader->descriptorSetMapping[i].pDescriptorInfo = (const XGL_DESCRIPTOR_SLOT_INFO*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pShader->descriptorSetMapping[i].pDescriptorInfo);')

1186

pid_enum.append(' for (j = 0; j < pShader->descriptorSetMapping[i].descriptorCount; j++)')

1187

pid_enum.append(' {')

1188

pid_enum.append(' if (pShader->descriptorSetMapping[i].pDescriptorInfo[j].slotObjectType == XGL_SLOT_NEXT_DESCRIPTOR_SET)')

1189

pid_enum.append(' {')

1190

pid_enum.append(' XGL_DESCRIPTOR_SLOT_INFO* pInfo = (XGL_DESCRIPTOR_SLOT_INFO*)pShader->descriptorSetMapping[i].pDescriptorInfo;')

1191

pid_enum.append(' pInfo[j].pNextLevelSet = (const XGL_DESCRIPTOR_SET_MAPPING*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pShader->descriptorSetMapping[i].pDescriptorInfo[j].pNextLevelSet);')

1192

pid_enum.append(' }')

1193

pid_enum.append(' }')

1194

pid_enum.append(' }\n')

1195

pid_enum.append(' // constant buffers')

1196

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

1197

pid_enum.append(' {')

1198

pid_enum.append(' XGL_UINT i;')

1199

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

1200

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

1201

pid_enum.append(' {')

1202

pid_enum.append(' XGL_LINK_CONST_BUFFER* pBuffer = (XGL_LINK_CONST_BUFFER*)pShader->pLinkConstBufferInfo;')

1203

pid_enum.append(' pBuffer[i].pBufferData = (const XGL_VOID*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pShader->pLinkConstBufferInfo[i].pBufferData);')

1204

pid_enum.append(' }')

1205

pid_enum.append(' }')

1206

pid_enum.append(' }')

1207

pid_enum.append('}\n')

1208

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

1209

return "\n".join(pid_enum)

1210

1211

def _generate_interp_funcs(self):

1212

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

1213

custom_case_dict = { 'InitAndEnumerateGpus' : {'param': 'pAppInfo', 'txt': ['XGL_APPLICATION_INFO* pInfo = (XGL_APPLICATION_INFO*)pPacket->pAppInfo;\n', 'pInfo->pAppName = (const XGL_CHAR*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pAppInfo->pAppName);\n', 'pInfo->pEngineName = (const XGL_CHAR*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pAppInfo->pEngineName);']},

1214

'CreateShader' : {'param': 'pCreateInfo', 'txt': ['XGL_SHADER_CREATE_INFO* pInfo = (XGL_SHADER_CREATE_INFO*)pPacket->pCreateInfo;\n', 'pInfo->pCode = glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pCode);']},

1215

'CreateGraphicsPipeline' : {'param': 'pCreateInfo', 'txt': ['assert(pPacket->pCreateInfo->sType == XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO);\n', '// need to make a non-const pointer to the pointer so that we can properly change the original pointer to the interpretted one\n','XGL_VOID** ppNextVoidPtr = (XGL_VOID**)&pPacket->pCreateInfo->pNext;\n','*ppNextVoidPtr = (XGL_VOID*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pNext);\n',

1216

'XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pPacket->pCreateInfo->pNext;\n', 'while ((NULL != pNext) && (XGL_NULL_HANDLE != pNext))\n', '{\n',

1217

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

1218

' case XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO:\n',

1219

' case XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO:\n',

1220

' case XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO:\n',

1221

' case XGL_STRUCTURE_TYPE_PIPELINE_DB_STATE_CREATE_INFO:\n',

1222

' case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:\n',

1223

' {\n',

1224

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

1225

' *ppNextVoidPtr = (XGL_VOID*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',

1226

' break;\n',

1227

' }\n',

1228

' case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:\n',

1229

' {\n',

1230

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

1231

' *ppNextVoidPtr = (XGL_VOID*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',

1232

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

1233

' break;\n',

1234

' }\n',

1235

' case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:\n',

1236

' {\n',

1237

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

1238

' XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO *pVi = (XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO *) pNext;\n',

1239

' *ppNextVoidPtr = (XGL_VOID*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',

1240

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

1241

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

1246

' }\n',

1247

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

1248

'}']},

1249

'CreateComputePipeline' : {'param': 'pCreateInfo', 'txt': ['interpret_pipeline_shader(pHeader, (XGL_PIPELINE_SHADER*)(&pPacket->pCreateInfo->cs));']}}

1250

if_body = []

Jon Ashburn

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

[diff] [blame]

1251

if_body.append('typedef struct struct_xglApiVersion {')

1252

if_body.append(' glv_trace_packet_header* header;')

1253

if_body.append(' uint32_t version;')

1254

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

1255

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

1256

if_body.append('{')

1257

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

1258

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

1259

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

1260

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

1261

if_body.append(' return pPacket;')

1262

if_body.append('}\n')

Tobin Ehlis

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

[diff] [blame]

1263

for proto in self.protos:

1264

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

1265

if 'UnmapMemory' == proto.name:

Chia-I Wu

82d0c6e

2015-01-01 09:31:15 +0800

[diff] [blame]

1266

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

Tobin Ehlis

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

[diff] [blame]

1267

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

1268

if_body.append(' glv_trace_packet_header* header;')

1269

for p in proto.params:

1270

if '[4]' in p.ty:

1271

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

1272

else:

1273

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

1274

if 'XGL_VOID' != proto.ret:

1275

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

1276

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

1277

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

1278

if_body.append('{')

1279

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

1280

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

1281

for p in proto.params:

1282

if '*' in p.ty:

1283

if 'DEVICE_CREATE_INFO' in p.ty:

1284

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

1285

else:

1286

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

1287

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

1288

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

1289

if_body.append(' {')

1290

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

1291

if_body.append(' }')

1292

if_body.append(' return pPacket;')

1293

if_body.append('}\n')

1294

return "\n".join(if_body)

1295

1296

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

1297

if_body = []

1298

for proto in self.protos:

1299

if func_class in proto.name:

1300

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

1301

if_body.append(' glv_trace_packet_header* pHeader;')

1302

for p in proto.params:

1303

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

1304

if 'XGL_VOID' != proto.ret:

1305

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

1306

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

1307

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

1308

if_body.append('{')

1309

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

1310

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

1311

for p in proto.params:

1312

if '*' in p.ty:

1313

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

1314

if_body.append(' return pPacket;')

1315

if_body.append('}\n')

1316

return "\n".join(if_body)

1317

1318

def _generate_replay_class_decls(self):

1319

cd_body = []

1320

cd_body.append('class ApiReplay {')

1321

cd_body.append('public:')

1322

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

1323

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

1324

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

1325

cd_body.append('};\n')

1326

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

1327

cd_body.append('friend class xglReplay;')

1328

cd_body.append('public:')

1329

cd_body.append(' xglDisplay();')

1330

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

1331

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

1332

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

1333

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

1334

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

1335

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

1336

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

1337

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

1338

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

1339

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

1340

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

1341

cd_body.append('#endif')

1342

cd_body.append('private:')

1343

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

1344

cd_body.append(' bool m_initedXGL;')

1345

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

1346

cd_body.append(' HWND m_windowHandle;')

1347

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

1348

cd_body.append(' XGL_WSI_X11_CONNECTION_INFO m_WsiConnection;')

1349

cd_body.append(' xcb_screen_t *m_pXcbScreen;')

1350

cd_body.append(' xcb_window_t m_XcbWindow;')

1351

cd_body.append('#endif')

1352

cd_body.append(' unsigned int m_windowWidth;')

1353

cd_body.append(' unsigned int m_windowHeight;')

1354

cd_body.append('#if 0')

1355

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

1356

cd_body.append(' XGL_UINT32 m_gpuCount;')

1357

cd_body.append(' unsigned int m_gpuIdx;')

1358

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

1359

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

1360

cd_body.append('#endif')

1361

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

1362

cd_body.append('};\n')

1363

cd_body.append('typedef struct _XGLAllocInfo {')

1364

cd_body.append(' XGL_GPU_SIZE size;')

1365

cd_body.append(' XGL_VOID *pData;')

1366

cd_body.append('} XGLAllocInfo;')

1367

return "\n".join(cd_body)

1368

1369

def _generate_replay_func_ptrs(self):

1370

xf_body = []

1371

xf_body.append('struct xglFuncs {')

1372

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

1373

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

1374

for proto in self.protos:

1375

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

1376

for p in proto.params:

1377

if '[4]' in p.ty:

1378

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

1379

else:

1380

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

1381

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

1382

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

1383

xf_body.append('};')

1384

return "\n".join(xf_body)

1385

1386

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

1387

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

1388

1389

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

1390

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

1391

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

1392

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

1393

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

1394

return txt

1395

1396

def _rm_from_map_decl(self, ty, name):

1397

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

1398

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

1399

return txt

1400

1401

def _remap_decl(self, ty, name):

1402

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

1403

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

1404

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

1405

return txt

1406

1407

def _generate_replay_class(self):

1408

obj_map_dict = {'m_gpus': 'XGL_PHYSICAL_GPU',

1409

'm_devices': 'XGL_DEVICE',

1410

'm_queues': 'XGL_QUEUE',

1411

'm_memories': 'XGL_GPU_MEMORY',

1412

'm_images': 'XGL_IMAGE',

1413

'm_imageViews': 'XGL_IMAGE_VIEW',

1414

'm_colorTargetViews': 'XGL_COLOR_ATTACHMENT_VIEW',

1415

'm_depthStencilViews': 'XGL_DEPTH_STENCIL_VIEW',

1416

'm_shader': 'XGL_SHADER',

1417

'm_pipeline': 'XGL_PIPELINE',

1418

'm_pipelineDelta': 'XGL_PIPELINE_DELTA',

1419

'm_sampler': 'XGL_SAMPLER',

1420

'm_descriptorSets': 'XGL_DESCRIPTOR_SET',

1421

'm_viewportStates': 'XGL_VIEWPORT_STATE_OBJECT',

1422

'm_rasterStates': 'XGL_RASTER_STATE_OBJECT',

1423

'm_msaaStates': 'XGL_MSAA_STATE_OBJECT',

1424

'm_colorBlendStates': 'XGL_COLOR_BLEND_STATE_OBJECT',

1425

'm_depthStencilStates': 'XGL_DEPTH_STENCIL_STATE_OBJECT',

1426

'm_cmdBuffers': 'XGL_CMD_BUFFER',

1427

'm_fences': 'XGL_FENCE',

1428

'm_queue_semaphores': 'XGL_QUEUE_SEMAPHORE',

1429

'm_events': 'XGL_EVENT',

1430

'm_queryPools': 'XGL_QUERY_POOL',

1431

}

1432

rc_body = []

1433

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

1434

rc_body.append('public:')

1435

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

1436

rc_body.append(' xglReplay(unsigned int debugLevel);\n')

1437

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

1438

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

1439

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

1440

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

1441

rc_body.append('private:')

1442

rc_body.append(' struct xglFuncs m_xglFuncs;')

1443

rc_body.append(' void copy_mem_remap_range_struct(XGL_VIRTUAL_MEMORY_REMAP_RANGE *outRange, const XGL_VIRTUAL_MEMORY_REMAP_RANGE *inRange);')

1444

rc_body.append(' unsigned int m_debugLevel;')

1445

rc_body.append(' xglDisplay *m_display;')

1446

rc_body.append(' XGL_MEMORY_HEAP_PROPERTIES m_heapProps[XGL_MAX_MEMORY_HEAPS];')

1447

rc_body.append(' struct shaderPair {')

1448

rc_body.append(' XGL_SHADER *addr;')

1449

rc_body.append(' XGL_SHADER val;')

1450

rc_body.append(' };')

1451

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

1452

# Custom code for 1-off memory mapping functions

1453

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

1454

rc_body.append(' {')

1455

rc_body.append(' XGLAllocInfo info;')

1456

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

1457

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

1458

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

1459

rc_body.append(' }')

1460

rc_body.append(' void add_mapping_to_mapData(XGL_GPU_MEMORY handle, XGL_VOID *pData)')

1461

rc_body.append(' {')

1462

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

1463

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

1464

rc_body.append(' {')

1465

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

1466

rc_body.append(' return;')

1467

rc_body.append(' }')

1468

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

1469

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

1470

rc_body.append(' {')

1471

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

1472

rc_body.append(' }')

1473

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

1474

rc_body.append(' }')

1475

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

1476

rc_body.append(' {')

1477

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

1478

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

1479

rc_body.append(' return;')

1480

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

1481

rc_body.append(' }')

1482

rc_body.append(' void rm_mapping_from_mapData(XGL_GPU_MEMORY handle, XGL_VOID* pData)')

1483

rc_body.append(' {')

1484

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

1485

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

1486

rc_body.append(' return;\n')

1487

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

1488

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

1489

rc_body.append(' {')

1490

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

1491

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

1492

rc_body.append(' return;')

1493

rc_body.append(' }')

1494

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

1495

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

1496

rc_body.append(' }\n')

1497

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

1498

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

1499

rc_body.append(' {')

1500

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

1501

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

1502

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

1503

rc_body.append(' }\n')

1504

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

1505

rc_body.append(' {')

1506

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

1507

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

1508

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

1509

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

1510

for var in sorted(obj_map_dict):

1511

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

1512

rc_body.append(' }')

1513

for var in sorted(obj_map_dict):

1514

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

1515

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

1516

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

1517

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

1518

# XGL_STATE_OBJECT code

Chia-I Wu

a89167c

2015-01-05 16:37:09 +0800

[diff] [blame]

1519

state_obj_remap_types = [

1520

'XGL_VIEWPORT_STATE_OBJECT',

1521

'XGL_RASTER_STATE_OBJECT',

1522

'XGL_MSAA_STATE_OBJECT',

1523

'XGL_COLOR_BLEND_STATE_OBJECT',

1524

'XGL_DEPTH_STENCIL_STATE_OBJECT',

1525

]

Tobin Ehlis

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

[diff] [blame]

1526

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

1527

rc_body.append(' XGL_STATE_OBJECT obj;')

1528

for t in state_obj_remap_types:

1529

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

1530

rc_body.append(' return obj;')

1531

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

1532

rc_body.append(' void rm_from_map(const XGL_STATE_OBJECT& state)\n {')

1533

for t in state_obj_remap_types:

1534

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

1535

rc_body.append(' }')

1536

# OBJECT code

1537

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

1538

rc_body.append(' XGL_OBJECT obj;')

Chia-I Wu

a89167c

2015-01-05 16:37:09 +0800

[diff] [blame]

obj_remap_types = [

'XGL_CMD_BUFFER',

'XGL_IMAGE',

'XGL_IMAGE_VIEW',

'XGL_COLOR_ATTACHMENT_VIEW',

1544

'XGL_DEPTH_STENCIL_VIEW',

1545

'XGL_SHADER',

1546

'XGL_PIPELINE',

1547

'XGL_PIPELINE_DELTA',

1548

'XGL_SAMPLER',

1549

'XGL_DESCRIPTOR_SET',

1550

'XGL_STATE_OBJECT',

1551

'XGL_FENCE',

1552

'XGL_QUEUE_SEMAPHORE',

1553

'XGL_EVENT',

1554

'XGL_QUERY_POOL',

1555

]

Tobin Ehlis

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

[diff] [blame]

1556

for var in obj_remap_types:

1557

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

1558

rc_body.append(' return obj;')

1559

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

1560

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

1561

for var in obj_remap_types:

1562

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

1563

rc_body.append(' }')

1564

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

1565

rc_body.append(' XGL_BASE_OBJECT obj;')

1566

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

1567

for t in base_obj_remap_types:

1568

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

1569

rc_body.append(' return obj;')

1570

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

1571

rc_body.append('};')

1572

return "\n".join(rc_body)

1573

1574

def _generate_replay_display_init_xgl(self):

1575

dix_body = []

1576

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

1577

dix_body.append('{')

1578

dix_body.append('#if 0')

1579

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

1580

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

1581

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

1582

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

1583

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

1584

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

1585

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

1586

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

1587

dix_body.append(' {')

1588

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

1589

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

1590

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

1591

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

1592

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

1593

dix_body.append(' }')

1594

dix_body.append(' res = XGL_SUCCESS;')

1595

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

1596

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

1597

dix_body.append(' return -1;')

1598

dix_body.append(' } else {')

1599

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

1600

dix_body.append(' return res;')

1601

dix_body.append(' }')

1602

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

1603

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

1604

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

1605

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

1606

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

1607

dix_body.append(' {')

1608

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

1609

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

1610

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

1611

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

1612

dix_body.append(' foundWSIExt = true;')

1613

dix_body.append(' }')

1614

dix_body.append(' }')

1615

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

1616

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

1617

dix_body.append(' return XGL_ERROR_INCOMPATIBLE_DEVICE;')

1618

dix_body.append(' }')

1619

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

1620

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

1621

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

1622

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

1623

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

1624

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

1625

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

1626

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

1627

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

1628

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

1629

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

1630

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

1631

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

1632

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

1633

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

1634

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

1635

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

1636

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

1637

dix_body.append(' return res;')

1638

dix_body.append('#else')

1639

dix_body.append(' return XGL_ERROR_INITIALIZATION_FAILED;')

1640

dix_body.append('#endif')

1641

dix_body.append('}')

1642

return "\n".join(dix_body)

1643

1644

def _generate_replay_display_init(self):

1645

di_body = []

1646

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

1647

di_body.append('{')

1648

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

1649

di_body.append('#if 0')

1650

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

1651

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

1652

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

1653

di_body.append(' return -1;')

1654

di_body.append(' } else {')

1655

di_body.append(' m_initedXGL = true;')

1656

di_body.append(' }')

1657

di_body.append('#endif')

1658

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

1659

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

1660

di_body.append(' xcb_screen_iterator_t iter;')

1661

di_body.append(' int scr;')

1662

di_body.append(' xcb_connection_t *pConnection;')

1663

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

1664

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

1665

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

1666

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

1667

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

1668

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

1669

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

1670

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

1671

di_body.append('#endif')

1672

di_body.append(' return 0;')

1673

di_body.append('}')

1674

return "\n".join(di_body)

1675

1676

def _generate_replay_display_structors(self):

1677

ds_body = []

1678

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

1679

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

1680

ds_body.append(' m_windowWidth(0),')

1681

ds_body.append(' m_windowHeight(0)')

1682

ds_body.append('{')

1683

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

1684

ds_body.append(' m_windowHandle = NULL;')

1685

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

1686

ds_body.append(' m_WsiConnection.pConnection = NULL;')

1687

ds_body.append(' m_WsiConnection.root = 0;')

1688

ds_body.append(' m_WsiConnection.provider = 0;')

1689

ds_body.append(' m_pXcbScreen = NULL;')

1690

ds_body.append(' m_XcbWindow = 0;')

1691

ds_body.append('#endif')

1692

ds_body.append('}')

1693

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

1694

ds_body.append('{')

1695

ds_body.append('#ifdef PLATFORM_LINUX')

1696

ds_body.append(' if (m_XcbWindow != 0)')

1697

ds_body.append(' {')

1698

ds_body.append(' xcb_destroy_window(m_WsiConnection.pConnection, m_XcbWindow);')

1699

ds_body.append(' }')

1700

ds_body.append(' if (m_WsiConnection.pConnection != NULL)')

1701

ds_body.append(' {')

1702

ds_body.append(' xcb_disconnect(m_WsiConnection.pConnection);')

1703

ds_body.append(' }')

1704

ds_body.append('#endif')

1705

ds_body.append('}')

1706

return "\n".join(ds_body)

1707

1708

def _generate_replay_display_window(self):

1709

dw_body = []

1710

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

1711

dw_body.append('LRESULT WINAPI WindowProcXgl( HWND window, unsigned int msg, WPARAM wp, LPARAM lp)')

1712

dw_body.append('{')

1713

dw_body.append(' switch(msg)')

1714

dw_body.append(' {')

1715

dw_body.append(' case WM_CLOSE:')

1716

dw_body.append(' DestroyWindow( window);')

1717

dw_body.append(' // fall-thru')

1718

dw_body.append(' case WM_DESTROY:')

1719

dw_body.append(' PostQuitMessage(0) ;')

1720

dw_body.append(' return 0L ;')

1721

dw_body.append(' default:')

1722

dw_body.append(' return DefWindowProc( window, msg, wp, lp ) ;')

1723

dw_body.append(' }')

1724

dw_body.append('}')

1725

dw_body.append('#endif')

1726

dw_body.append('int xglDisplay::set_window(glv_window_handle hWindow, unsigned int width, unsigned int height)')

1727

dw_body.append('{')

1728

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

1729

dw_body.append(' m_windowHandle = hWindow;')

1730

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

1731

dw_body.append(' m_XcbWindow = hWindow;')

1732

dw_body.append('#endif')

1733

dw_body.append(' m_windowWidth = width;')

1734

dw_body.append(' m_windowHeight = height;')

1735

dw_body.append(' return 0;')

1736

dw_body.append('}\n')

1737

dw_body.append('int xglDisplay::create_window(const unsigned int width, const unsigned int height)')

1738

dw_body.append('{')

1739

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

1740

dw_body.append(' // Register Window class')

1741

dw_body.append(' WNDCLASSEX wcex = {};')

1742

dw_body.append(' wcex.cbSize = sizeof( WNDCLASSEX);')

1743

dw_body.append(' wcex.style = CS_HREDRAW | CS_VREDRAW;')

1744

dw_body.append(' wcex.lpfnWndProc = WindowProcXgl;')

1745

dw_body.append(' wcex.cbClsExtra = 0;')

1746

dw_body.append(' wcex.cbWndExtra = 0;')

1747

dw_body.append(' wcex.hInstance = GetModuleHandle(0);')

1748

dw_body.append(' wcex.hIcon = LoadIcon(wcex.hInstance, MAKEINTRESOURCE( IDI_ICON));')

1749

dw_body.append(' wcex.hCursor = LoadCursor( NULL, IDC_ARROW);')

1750

dw_body.append(' wcex.hbrBackground = ( HBRUSH )( COLOR_WINDOW + 1);')

1751

dw_body.append(' wcex.lpszMenuName = NULL;')

1752

dw_body.append(' wcex.lpszClassName = APP_NAME;')

1753

dw_body.append(' wcex.hIconSm = LoadIcon( wcex.hInstance, MAKEINTRESOURCE( IDI_ICON));')

1754

dw_body.append(' if( !RegisterClassEx( &wcex))')

1755

dw_body.append(' {')

1756

dw_body.append(' glv_LogError("Failed to register windows class\\n");')

1757

dw_body.append(' return -1;')

1758

dw_body.append(' }\n')

1759

dw_body.append(' // create the window')

1760

dw_body.append(' m_windowHandle = CreateWindow(APP_NAME, APP_NAME, WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU, 0, 0,')

1761

dw_body.append(' width, height, NULL, NULL, wcex.hInstance, NULL);\n')

1762

dw_body.append(' if (m_windowHandle)')

1763

dw_body.append(' {')

1764

dw_body.append(' ShowWindow( m_windowHandle, SW_SHOWDEFAULT);')

1765

dw_body.append(' m_windowWidth = width;')

1766

dw_body.append(' m_windowHeight = height;')

1767

dw_body.append(' } else {')

1768

dw_body.append(' glv_LogError("Failed to create window\\n");')

1769

dw_body.append(' return -1;')

1770

dw_body.append(' }')

1771

dw_body.append(' return 0;')

1772

dw_body.append('#elif defined(PLATFORM_LINUX)\n')

1773

dw_body.append(' uint32_t value_mask, value_list[32];')

1774

dw_body.append(' m_XcbWindow = xcb_generate_id(m_WsiConnection.pConnection);\n')

1775

dw_body.append(' value_mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;')

1776

dw_body.append(' value_list[0] = m_pXcbScreen->black_pixel;')

1777

dw_body.append(' value_list[1] = XCB_EVENT_MASK_KEY_RELEASE |')

1778

dw_body.append(' XCB_EVENT_MASK_EXPOSURE;\n')

1779

dw_body.append(' xcb_create_window(m_WsiConnection.pConnection,')

1780

dw_body.append(' XCB_COPY_FROM_PARENT,')

1781

dw_body.append(' m_XcbWindow, m_WsiConnection.root,')

1782

dw_body.append(' 0, 0, width, height, 0,')

1783

dw_body.append(' XCB_WINDOW_CLASS_INPUT_OUTPUT,')

1784

dw_body.append(' m_pXcbScreen->root_visual,')

1785

dw_body.append(' value_mask, value_list);\n')

1786

dw_body.append(' xcb_map_window(m_WsiConnection.pConnection, m_XcbWindow);')

1787

dw_body.append(' xcb_flush(m_WsiConnection.pConnection);')

1788

dw_body.append(' return 0;')

1789

dw_body.append('#endif')

1790

dw_body.append('}\n')

1791

dw_body.append('void xglDisplay::resize_window(const unsigned int width, const unsigned int height)')

1792

dw_body.append('{')

1793

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

1794

dw_body.append(' if (width != m_windowWidth || height != m_windowHeight)')

1795

dw_body.append(' {')

1796

dw_body.append(' SetWindowPos(get_window_handle(), HWND_TOP, 0, 0, width, height, SWP_NOMOVE);')

1797

dw_body.append(' m_windowWidth = width;')

1798

dw_body.append(' m_windowHeight = height;')

1799

dw_body.append(' }')

1800

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

1801

dw_body.append(' if (width != m_windowWidth || height != m_windowHeight)')

1802

dw_body.append(' {')

1803

dw_body.append(' uint32_t values[2];')

1804

dw_body.append(' values[0] = width;')

1805

dw_body.append(' values[1] = height;')

1806

dw_body.append(' xcb_configure_window(m_WsiConnection.pConnection, m_XcbWindow, XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT, values);')

1807

dw_body.append(' m_windowWidth = width;')

1808

dw_body.append(' m_windowHeight = height;')

1809

dw_body.append(' }')

1810

dw_body.append('#endif')

1811

dw_body.append('}\n')

1812

dw_body.append('void xglDisplay::process_event()')

1813

dw_body.append('{')

1814

dw_body.append('}')

1815

return "\n".join(dw_body)

1816

1817

def _generate_replay_structors(self):

1818

rs_body = []

1819

rs_body.append('xglReplay::xglReplay(unsigned int debugLevel)')

1820

rs_body.append('{')

1821

rs_body.append(' m_display = new xglDisplay();')

1822

rs_body.append(' m_debugLevel = debugLevel;')

1823

rs_body.append('}\n')

1824

rs_body.append('xglReplay::~xglReplay()')

1825

rs_body.append('{')

1826

rs_body.append(' delete m_display;')

1827

rs_body.append(' glv_platform_close_library(m_xglFuncs.m_libHandle);')

1828

rs_body.append('}')

1829

return "\n".join(rs_body)

1830

1831

def _generate_replay_init(self):

1832

ri_body = []

1833

ri_body.append('int xglReplay::init(glv_replay::Display & disp)')

1834

ri_body.append('{')

1835

ri_body.append(' int err;')

1836

ri_body.append('#if defined _WIN64')

1837

ri_body.append(' HMODULE handle = LoadLibrary("xgl64.dll" );')

1838

ri_body.append('#elif defined _WIN32')

1839

ri_body.append(' HMODULE handle = LoadLibrary("xgl32.dll" );')

1840

ri_body.append('#elif defined PLATFORM_LINUX')

1841

ri_body.append(' void * handle = dlopen("libXGL.so", RTLD_LAZY);')

1842

ri_body.append('#endif\n')

1843

ri_body.append(' if (handle == NULL) {')

1844

ri_body.append(' glv_LogError("Failed to open xgl library.\\n");')

1845

ri_body.append(' return -1;')

1846

ri_body.append(' }')

1847

ri_body.append(' m_xglFuncs.init_funcs(handle);')

1848

ri_body.append(' disp.set_implementation(m_display);')

1849

ri_body.append(' if ((err = m_display->init(disp.get_gpu())) != 0) {')

1850

ri_body.append(' glv_LogError("Failed to init XGL display.\\n");')

1851

ri_body.append(' return err;')

1852

ri_body.append(' }')

1853

ri_body.append(' if (disp.get_window_handle() == 0)')

1854

ri_body.append(' {')

1855

ri_body.append(' if ((err = m_display->create_window(disp.get_width(), disp.get_height())) != 0) {')

1856

ri_body.append(' glv_LogError("Failed to create Window\\n");')

1857

ri_body.append(' return err;')

1858

ri_body.append(' }')

1859

ri_body.append(' }')

1860

ri_body.append(' else')

1861

ri_body.append(' {')

1862

ri_body.append(' if ((err = m_display->set_window(disp.get_window_handle(), disp.get_width(), disp.get_height())) != 0)')

1863

ri_body.append(' {')

1864

ri_body.append(' glv_LogError("Failed to set Window\\n");')

1865

ri_body.append(' return err;')

1866

ri_body.append(' }')

1867

ri_body.append(' }')

1868

ri_body.append(' return 0;')

1869

ri_body.append('}')

1870

return "\n".join(ri_body)

1871

1872

def _generate_replay_remap(self):

1873

# values to map and bool indicates if remap required for source

1874

rr_dict = {'pageCount': False, 'realStartPage': False, 'realMem': True, 'virtualStartPage': False, 'virtualMem': True}

1875

rr_body = []

1876

rr_body.append('void xglReplay::copy_mem_remap_range_struct(XGL_VIRTUAL_MEMORY_REMAP_RANGE *outRange, const XGL_VIRTUAL_MEMORY_REMAP_RANGE *inRange)\n{')

1877

for k in rr_dict:

1878

if rr_dict[k]:

1879

rr_body.append(' outRange->%s = remap(inRange->%s);' % (k, k))

1880

else:

1881

rr_body.append(' outRange->%s = inRange->%s;' % (k, k))

1882

rr_body.append('}')

1883

return "\n".join(rr_body)

1884

1885

def _generate_replay_errors(self):

1886

re_body = []

1887

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

1888

re_body.append('{')

1889

re_body.append(' glv_replay::GLV_REPLAY_RESULT res = resIn;')

1890

re_body.append(' if (resCall != resTrace) {')

1891

re_body.append(' glv_LogWarn("Mismatched return from API call (%s) traced result %s, replay result %s\\n", entrypointName,')

1892

re_body.append(' string_XGL_RESULT(resTrace), string_XGL_RESULT(resCall));')

1893

re_body.append(' res = glv_replay::GLV_REPLAY_BAD_RETURN;')

1894

re_body.append(' }')

1895

re_body.append('#if 0')

1896

re_body.append(' if (resCall != XGL_SUCCESS) {')

1897

re_body.append(' glv_LogWarn("API call (%s) returned failed result %s\\n", entrypointName, string_XGL_RESULT(resCall));')

1898

re_body.append(' }')

1899

re_body.append('#endif')

1900

re_body.append(' return res;')

1901

re_body.append('}')

1902

return "\n".join(re_body)

1903

1904

def _generate_replay_init_funcs(self):

1905

rif_body = []

1906

rif_body.append('void xglFuncs::init_funcs(void * handle)\n{\n m_libHandle = handle;')

1907

for proto in self.protos:

1908

rif_body.append(' real_xgl%s = (type_xgl%s)(glv_platform_get_library_entrypoint(handle, "xgl%s"));' % (proto.name, proto.name, proto.name))

1909

rif_body.append('}')

1910

return "\n".join(rif_body)

1911

1912

def _get_packet_param(self, t, n):

1913

# list of types that require remapping

Chia-I Wu

a89167c

2015-01-05 16:37:09 +0800

[diff] [blame]

remap_list = [

'XGL_PHYSICAL_GPU',

'XGL_DEVICE',

'XGL_QUEUE',

'XGL_GPU_MEMORY',

'XGL_IMAGE',

'XGL_IMAGE_VIEW',

'XGL_COLOR_ATTACHMENT_VIEW',

1922

'XGL_DEPTH_STENCIL_VIEW',

1923

'XGL_SHADER',

1924

'XGL_PIPELINE',

1925

'XGL_PIPELINE_DELTA',

1926

'XGL_SAMPLER',

1927

'XGL_DESCRIPTOR_SET',

1928

'XGL_VIEWPORT_STATE_OBJECT',

1929

'XGL_RASTER_STATE_OBJECT',

1930

'XGL_MSAA_STATE_OBJECT',

1931

'XGL_COLOR_BLEND_STATE_OBJECT',

1932

'XGL_DEPTH_STENCIL_STATE_OBJECT',

1933

'XGL_CMD_BUFFER',

1934

'XGL_FENCE',

1935

'XGL_QUEUE_SEMAPHORE',

'XGL_EVENT',

'XGL_QUERY_POOL',

'XGL_STATE_OBJECT',

'XGL_BASE_OBJECT',

'XGL_OBJECT',

]

Tobin Ehlis

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

[diff] [blame]

1942

param_exclude_list = ['p1', 'p2']

1943

if t.strip('*').strip('const ') in remap_list and n not in param_exclude_list:

1944

return 'remap(pPacket->%s)' % (n)

1945

return 'pPacket->%s' % (n)

1946

1947

def _gen_replay_init_and_enum_gpus(self):

1948

ieg_body = []

1949

ieg_body.append(' if (!m_display->m_initedXGL)')

1950

ieg_body.append(' {')

1951

ieg_body.append(' XGL_UINT gpuCount;')

1952

ieg_body.append(' XGL_PHYSICAL_GPU gpus[XGL_MAX_PHYSICAL_GPUS];')

1953

ieg_body.append(' XGL_UINT maxGpus = (pPacket->maxGpus < XGL_MAX_PHYSICAL_GPUS) ? pPacket->maxGpus : XGL_MAX_PHYSICAL_GPUS;')

1954

ieg_body.append(' replayResult = m_xglFuncs.real_xglInitAndEnumerateGpus(pPacket->pAppInfo, pPacket->pAllocCb, maxGpus, &gpuCount, &gpus[0]);')

1955

ieg_body.append(' CHECK_RETURN_VALUE(xglInitAndEnumerateGpus);')

1956

ieg_body.append(' //TODO handle different number of gpus in trace versus replay')

1957

ieg_body.append(' if (gpuCount != *(pPacket->pGpuCount))')

1958

ieg_body.append(' {')

1959

ieg_body.append(' glv_LogWarn("number of gpus mismatched in replay %u versus trace %u\\n", gpuCount, *(pPacket->pGpuCount));')

1960

ieg_body.append(' }')

1961

ieg_body.append(' else if (gpuCount == 0)')

1962

ieg_body.append(' {')

1963

ieg_body.append(' glv_LogError("xglInitAndEnumerateGpus number of gpus is zero\\n");')

1964

ieg_body.append(' }')

1965

ieg_body.append(' else')

1966

ieg_body.append(' {')

1967

ieg_body.append(' glv_LogInfo("Enumerated %d GPUs in the system\\n", gpuCount);')

1968

ieg_body.append(' }')

1969

ieg_body.append(' clear_all_map_handles();')

1970

ieg_body.append(' // TODO handle enumeration results in a different order from trace to replay')

1971

ieg_body.append(' for (XGL_UINT i = 0; i < gpuCount; i++)')

1972

ieg_body.append(' {')

1973

ieg_body.append(' if (pPacket->pGpus)')

1974

ieg_body.append(' add_to_map(&(pPacket->pGpus[i]), &(gpus[i]));')

1975

ieg_body.append(' }')

1976

ieg_body.append(' }')

1977

return "\n".join(ieg_body)

1978

1979

def _gen_replay_get_gpu_info(self):

1980

ggi_body = []

1981

ggi_body.append(' if (!m_display->m_initedXGL)')

1982

ggi_body.append(' {')

1983

ggi_body.append(' switch (pPacket->infoType) {')

1984

ggi_body.append(' case XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES:')

1985

ggi_body.append(' {')

1986

ggi_body.append(' XGL_PHYSICAL_GPU_PROPERTIES gpuProps;')

1987

ggi_body.append(' XGL_SIZE dataSize = sizeof(XGL_PHYSICAL_GPU_PROPERTIES);')

1988

ggi_body.append(' replayResult = m_xglFuncs.real_xglGetGpuInfo(remap(pPacket->gpu), pPacket->infoType, &dataSize,')

1989

ggi_body.append(' (pPacket->pData == NULL) ? NULL : &gpuProps);')

1990

ggi_body.append(' if (pPacket->pData != NULL)')

1991

ggi_body.append(' {')

1992

ggi_body.append(' glv_LogInfo("Replay Gpu Properties\\n");')

1993

ggi_body.append(' glv_LogInfo("Vendor ID %x, Device ID %x, name %s\\n",gpuProps.vendorId, gpuProps.deviceId, gpuProps.gpuName);')

1994

ggi_body.append(' glv_LogInfo("API version %u, Driver version %u, gpu Type %u\\n",gpuProps.apiVersion, gpuProps.driverVersion, gpuProps.gpuType);')

1995

ggi_body.append(' }')

1996

ggi_body.append(' break;')

1997

ggi_body.append(' }')

1998

ggi_body.append(' case XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE:')

1999

ggi_body.append(' {')

2000

ggi_body.append(' XGL_PHYSICAL_GPU_PERFORMANCE gpuPerfs;')

2001

ggi_body.append(' XGL_SIZE dataSize = sizeof(XGL_PHYSICAL_GPU_PERFORMANCE);')

2002

ggi_body.append(' replayResult = m_xglFuncs.real_xglGetGpuInfo(remap(pPacket->gpu), pPacket->infoType, &dataSize,')

2003

ggi_body.append(' (pPacket->pData == NULL) ? NULL : &gpuPerfs);')

2004

ggi_body.append(' if (pPacket->pData != NULL)')

2005

ggi_body.append(' {')

2006

ggi_body.append(' glv_LogInfo("Replay Gpu Performance\\n");')

2007

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

2008

ggi_body.append(' glv_LogInfo("Max primitives/clock %f, Max pixels/clock %f\\n",gpuPerfs.primsPerClock, gpuPerfs.pixelsPerClock);')

2009

ggi_body.append(' }')

2010

ggi_body.append(' break;')

2011

ggi_body.append(' }')

2012

ggi_body.append(' case XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES:')

2013

ggi_body.append(' {')

2014

ggi_body.append(' XGL_PHYSICAL_GPU_QUEUE_PROPERTIES *pGpuQueue, *pQ;')

2015

ggi_body.append(' XGL_SIZE dataSize = sizeof(XGL_PHYSICAL_GPU_QUEUE_PROPERTIES);')

2016

ggi_body.append(' XGL_SIZE numQueues = 1;')

2017

ggi_body.append(' assert(pPacket->pDataSize);')

2018

ggi_body.append(' if ((*(pPacket->pDataSize) % dataSize) != 0)')

2019

ggi_body.append(' glv_LogWarn("xglGetGpuInfo() for GPU_QUEUE_PROPERTIES not an integral data size assuming 1\\n");')

2020

ggi_body.append(' else')

2021

ggi_body.append(' numQueues = *(pPacket->pDataSize) / dataSize;')

2022

ggi_body.append(' dataSize = numQueues * dataSize;')

2023

ggi_body.append(' pQ = static_cast < XGL_PHYSICAL_GPU_QUEUE_PROPERTIES *> (glv_malloc(dataSize));')

2024

ggi_body.append(' pGpuQueue = pQ;')

2025

ggi_body.append(' replayResult = m_xglFuncs.real_xglGetGpuInfo(remap(pPacket->gpu), pPacket->infoType, &dataSize,')

2026

ggi_body.append(' (pPacket->pData == NULL) ? NULL : pGpuQueue);')

2027

ggi_body.append(' if (pPacket->pData != NULL)')

2028

ggi_body.append(' {')

2029

ggi_body.append(' for (unsigned int i = 0; i < numQueues; i++)')

2030

ggi_body.append(' {')

2031

ggi_body.append(' glv_LogInfo("Replay Gpu Queue Property for index %d, flags %u\\n", i, pGpuQueue->queueFlags);')

2032

ggi_body.append(' glv_LogInfo("Max available count %u, max atomic counters %u, supports timestamps %u\\n",pGpuQueue->queueCount, pGpuQueue->maxAtomicCounters, pGpuQueue->supportsTimestamps);')

2033

ggi_body.append(' pGpuQueue++;')

2034

ggi_body.append(' }')

2035

ggi_body.append(' }')

2036

ggi_body.append(' glv_free(pQ);')

2037

ggi_body.append(' break;')

2038

ggi_body.append(' }')

2039

ggi_body.append(' default:')

2040

ggi_body.append(' {')

2041

ggi_body.append(' XGL_SIZE size = 0;')

2042

ggi_body.append(' void* pData = NULL;')

2043

ggi_body.append(' if (pPacket->pData != NULL && pPacket->pDataSize != NULL)')

2044

ggi_body.append(' {')

2045

ggi_body.append(' size = *pPacket->pDataSize;')

2046

ggi_body.append(' pData = glv_malloc(*pPacket->pDataSize);')

2047

ggi_body.append(' }')

2048

ggi_body.append(' replayResult = m_xglFuncs.real_xglGetGpuInfo(remap(pPacket->gpu), pPacket->infoType, &size, pData);')

2049

ggi_body.append(' if (replayResult == XGL_SUCCESS)')

2050

ggi_body.append(' {')

2051

ggi_body.append(' if (size != *pPacket->pDataSize && pData == NULL)')

2052

ggi_body.append(' {')

2053

ggi_body.append(' glv_LogWarn("xglGetGpuInfo returned a differing data size: replay (%d bytes) vs trace (%d bytes)\\n", size, *pPacket->pDataSize);')

2054

ggi_body.append(' }')

2055

ggi_body.append(' else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0)')

2056

ggi_body.append(' {')

2057

ggi_body.append(' glv_LogWarn("xglGetGpuInfo returned differing data contents than the trace file contained.\\n");')

2058

ggi_body.append(' }')

2059

ggi_body.append(' }')

2060

ggi_body.append(' glv_free(pData);')

2061

ggi_body.append(' break;')

2062

ggi_body.append(' }')

2063

ggi_body.append(' };')

2064

ggi_body.append(' CHECK_RETURN_VALUE(xglGetGpuInfo);')

2065

ggi_body.append(' }')

2066

return "\n".join(ggi_body)

2067

2068

def _gen_replay_create_device(self):

2069

cd_body = []

2070

cd_body.append(' if (!m_display->m_initedXGL)')

2071

cd_body.append(' {')

2072

cd_body.append(' XGL_DEVICE device;')

2073

cd_body.append(' XGL_DEVICE_CREATE_INFO cInfo;')

2074

cd_body.append(' if (m_debugLevel > 0)')

2075

cd_body.append(' {')

2076

cd_body.append(' memcpy(&cInfo, pPacket->pCreateInfo, sizeof(XGL_DEVICE_CREATE_INFO));')

2077

cd_body.append(' cInfo.flags = pPacket->pCreateInfo->flags | XGL_DEVICE_CREATE_VALIDATION_BIT;')

2078

cd_body.append(' cInfo.maxValidationLevel = (XGL_VALIDATION_LEVEL)((m_debugLevel <= 4) ? XGL_VALIDATION_LEVEL_0 + m_debugLevel : XGL_VALIDATION_LEVEL_0);')

2079

cd_body.append(' pPacket->pCreateInfo = &cInfo;')

2080

cd_body.append(' }')

2081

cd_body.append(' replayResult = m_xglFuncs.real_xglCreateDevice(remap(pPacket->gpu), pPacket->pCreateInfo, &device);')

2082

cd_body.append(' CHECK_RETURN_VALUE(xglCreateDevice);')

2083

cd_body.append(' if (replayResult == XGL_SUCCESS)')

2084

cd_body.append(' {')

2085

cd_body.append(' add_to_map(pPacket->pDevice, &device);')

2086

cd_body.append(' }')

2087

cd_body.append(' }')

2088

return "\n".join(cd_body)

2089

2090

def _gen_replay_get_extension_support(self):

2091

ges_body = []

2092

ges_body.append(' if (!m_display->m_initedXGL) {')

2093

ges_body.append(' replayResult = m_xglFuncs.real_xglGetExtensionSupport(remap(pPacket->gpu), pPacket->pExtName);')

2094

ges_body.append(' CHECK_RETURN_VALUE(xglGetExtensionSupport);')

2095

ges_body.append(' if (replayResult == XGL_SUCCESS) {')

2096

ges_body.append(' for (unsigned int ext = 0; ext < sizeof(g_extensions) / sizeof(g_extensions[0]); ext++)')

2097

ges_body.append(' {')

Chia-I Wu

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

[diff] [blame]

2098

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]

2099

ges_body.append(' bool extInList = false;')

2100

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]

2101

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]

2102

ges_body.append(' extInList = true;')

2103

ges_body.append(' break;')

2104

ges_body.append(' }')

2105

ges_body.append(' if (!extInList)')

2106

ges_body.append(' m_display->m_extensions.push_back((XGL_CHAR *) g_extensions[ext]);')

2107

ges_body.append(' break;')

2108

ges_body.append(' }')

2109

ges_body.append(' }')

2110

ges_body.append(' }')

2111

ges_body.append(' }')

2112

return "\n".join(ges_body)

2113

2114

def _gen_replay_queue_submit(self):

2115

qs_body = []

2116

qs_body.append(' XGL_CMD_BUFFER *remappedBuffers = NULL;')

2117

qs_body.append(' if (pPacket->pCmdBuffers != NULL)')

2118

qs_body.append(' {')

2119

qs_body.append(' remappedBuffers = GLV_NEW_ARRAY( XGL_CMD_BUFFER, pPacket->cmdBufferCount);')

2120

qs_body.append(' for (XGL_UINT i = 0; i < pPacket->cmdBufferCount; i++)')

2121

qs_body.append(' {')

2122

qs_body.append(' *(remappedBuffers + i) = remap(*(pPacket->pCmdBuffers + i));')

2123

qs_body.append(' }')

2124

qs_body.append(' }')

2125

qs_body.append(' XGL_MEMORY_REF* memRefs = NULL;')

2126

qs_body.append(' if (pPacket->pMemRefs != NULL)')

2127

qs_body.append(' {')

2128

qs_body.append(' memRefs = GLV_NEW_ARRAY(XGL_MEMORY_REF, pPacket->memRefCount);')

2129

qs_body.append(' memcpy(memRefs, pPacket->pMemRefs, sizeof(XGL_MEMORY_REF) * pPacket->memRefCount);')

2130

qs_body.append(' for (XGL_UINT i = 0; i < pPacket->memRefCount; i++)')

2131

qs_body.append(' {')

2132

qs_body.append(' memRefs[i].mem = remap(pPacket->pMemRefs[i].mem);')

2133

qs_body.append(' }')

2134

qs_body.append(' }')

2135

qs_body.append(' replayResult = m_xglFuncs.real_xglQueueSubmit(remap(pPacket->queue), pPacket->cmdBufferCount, remappedBuffers, pPacket->memRefCount,')

2136

qs_body.append(' memRefs, remap(pPacket->fence));')

2137

qs_body.append(' GLV_DELETE(remappedBuffers);')

2138

qs_body.append(' GLV_DELETE(memRefs);')

2139

return "\n".join(qs_body)

2140

2141

def _gen_replay_get_memory_heap_count(self):

2142

mhc_body = []

2143

mhc_body.append(' XGL_UINT count;')

2144

mhc_body.append(' replayResult = m_xglFuncs.real_xglGetMemoryHeapCount(remap(pPacket->device), &count);')

2145

mhc_body.append(' if (count < 1 || count >= XGL_MAX_MEMORY_HEAPS)')

2146

mhc_body.append(' glv_LogError("xglGetMemoryHeapCount returned bad value count = %u\\n", count);')

2147

return "\n".join(mhc_body)

2148

2149

def _gen_replay_get_memory_heap_info(self):

2150

mhi_body = []

2151

mhi_body.append(' // TODO handle case where traced heap count, ids and properties do not match replay heaps')

2152

mhi_body.append(' XGL_SIZE dataSize = sizeof(XGL_MEMORY_HEAP_PROPERTIES);')

2153

mhi_body.append(' // TODO check returned properties match queried properties if this makes sense')

2154

mhi_body.append(' if (pPacket->heapId >= XGL_MAX_MEMORY_HEAPS)')

2155

mhi_body.append(' {')

2156

mhi_body.append(' glv_LogError("xglGetMemoryHeapInfo bad heapid (%d) skipping packet\\n");')

2157

mhi_body.append(' break;')

2158

mhi_body.append(' }')

2159

mhi_body.append(' replayResult = m_xglFuncs.real_xglGetMemoryHeapInfo(remap(pPacket->device), pPacket->heapId, pPacket->infoType, &dataSize,')

2160

mhi_body.append(' static_cast <XGL_VOID *> (&(m_heapProps[pPacket->heapId])));')

2161

mhi_body.append(' if (dataSize != sizeof(XGL_MEMORY_HEAP_PROPERTIES))')

2162

mhi_body.append(' glv_LogError("xglGetMemoryHeapInfo returned bad size = %u\\n", dataSize);')

2163

return "\n".join(mhi_body)

2164

2165

def _gen_replay_remap_virtual_memory_pages(self):

2166

rvm_body = []

2167

rvm_body.append(' XGL_VIRTUAL_MEMORY_REMAP_RANGE *pRemappedRanges = GLV_NEW_ARRAY( XGL_VIRTUAL_MEMORY_REMAP_RANGE, pPacket->rangeCount);')

2168

rvm_body.append(' for (XGL_UINT i = 0; i < pPacket->rangeCount; i++)')

2169

rvm_body.append(' {')

2170

rvm_body.append(' copy_mem_remap_range_struct(pRemappedRanges + i, (pPacket->pRanges + i));')

2171

rvm_body.append(' }')

2172

rvm_body.append(' XGL_QUEUE_SEMAPHORE *pRemappedPreSema = GLV_NEW_ARRAY(XGL_QUEUE_SEMAPHORE, pPacket->preWaitSemaphoreCount);')

2173

rvm_body.append(' for (XGL_UINT i = 0; i < pPacket->preWaitSemaphoreCount; i++)')

2174

rvm_body.append(' {')

2175

rvm_body.append(' *(pRemappedPreSema + i) = *(pPacket->pPreWaitSemaphores + i);')

2176

rvm_body.append(' }')

2177

rvm_body.append(' XGL_QUEUE_SEMAPHORE *pRemappedPostSema = GLV_NEW_ARRAY(XGL_QUEUE_SEMAPHORE, pPacket->postSignalSemaphoreCount);')

2178

rvm_body.append(' for (XGL_UINT i = 0; i < pPacket->postSignalSemaphoreCount; i++)')

2179

rvm_body.append(' {')

2180

rvm_body.append(' *(pRemappedPostSema + i) = *(pPacket->pPostSignalSemaphores + i);')

2181

rvm_body.append(' }')

2182

rvm_body.append(' replayResult = m_xglFuncs.real_xglRemapVirtualMemoryPages(remap(pPacket->device), pPacket->rangeCount, pRemappedRanges, pPacket->preWaitSemaphoreCount,')

2183

rvm_body.append(' pPacket->pPreWaitSemaphores, pPacket->postSignalSemaphoreCount, pPacket->pPostSignalSemaphores);')

2184

rvm_body.append(' GLV_DELETE(pRemappedRanges);')

2185

rvm_body.append(' GLV_DELETE(pRemappedPreSema);')

2186

rvm_body.append(' GLV_DELETE(pRemappedPostSema);')

2187

return "\n".join(rvm_body)

2188

2189

def _gen_replay_get_object_info(self):

2190

goi_body = []

2191

goi_body.append(' XGL_SIZE size = 0;')

2192

goi_body.append(' void* pData = NULL;')

2193

goi_body.append(' if (pPacket->pData != NULL && pPacket->pDataSize != NULL)')

2194

goi_body.append(' {')

2195

goi_body.append(' size = *pPacket->pDataSize;')

2196

goi_body.append(' pData = glv_malloc(*pPacket->pDataSize);')

2197

goi_body.append(' memcpy(pData, pPacket->pData, *pPacket->pDataSize);')

2198

goi_body.append(' }')

2199

goi_body.append(' replayResult = m_xglFuncs.real_xglGetObjectInfo(remap(pPacket->object), pPacket->infoType, &size, pData);')

2200

goi_body.append(' if (replayResult == XGL_SUCCESS)')

2201

goi_body.append(' {')

2202

goi_body.append(' if (size != *pPacket->pDataSize && pData == NULL)')

2203

goi_body.append(' {')

2204

goi_body.append(' glv_LogWarn("xglGetObjectInfo returned a differing data size: replay (%d bytes) vs trace (%d bytes)\\n", size, *pPacket->pDataSize);')

2205

goi_body.append(' }')

2206

goi_body.append(' else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0)')

2207

goi_body.append(' {')

2208

goi_body.append(' glv_LogWarn("xglGetObjectInfo returned differing data contents than the trace file contained.\\n");')

2209

goi_body.append(' }')

2210

goi_body.append(' }')

2211

goi_body.append(' glv_free(pData);')

2212

return "\n".join(goi_body)

2213

2214

def _gen_replay_get_format_info(self):

2215

gfi_body = []

2216

gfi_body.append(' XGL_SIZE size = 0;')

2217

gfi_body.append(' void* pData = NULL;')

2218

gfi_body.append(' if (pPacket->pData != NULL && pPacket->pDataSize != NULL)')

2219

gfi_body.append(' {')

2220

gfi_body.append(' size = *pPacket->pDataSize;')

2221

gfi_body.append(' pData = glv_malloc(*pPacket->pDataSize);')

2222

gfi_body.append(' }')

2223

gfi_body.append(' replayResult = m_xglFuncs.real_xglGetFormatInfo(remap(pPacket->device), pPacket->format, pPacket->infoType, &size, pData);')

2224

gfi_body.append(' if (replayResult == XGL_SUCCESS)')

2225

gfi_body.append(' {')

2226

gfi_body.append(' if (size != *pPacket->pDataSize && pData == NULL)')

2227

gfi_body.append(' {')

2228

gfi_body.append(' glv_LogWarn("xglGetFormatInfo returned a differing data size: replay (%d bytes) vs trace (%d bytes)\\n", size, *pPacket->pDataSize);')

2229

gfi_body.append(' }')

2230

gfi_body.append(' else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0)')

2231

gfi_body.append(' {')

2232

gfi_body.append(' glv_LogWarn("xglGetFormatInfo returned differing data contents than the trace file contained.\\n");')

2233

gfi_body.append(' }')

2234

gfi_body.append(' }')

2235

gfi_body.append(' glv_free(pData);')

2236

return "\n".join(gfi_body)

2237

2238

def _gen_replay_get_image_subresource_info(self):

2239

isi_body = []

2240

isi_body.append(' XGL_SIZE size = 0;')

2241

isi_body.append(' void* pData = NULL;')

2242

isi_body.append(' if (pPacket->pData != NULL && pPacket->pDataSize != NULL)')

2243

isi_body.append(' {')

2244

isi_body.append(' size = *pPacket->pDataSize;')

2245

isi_body.append(' pData = glv_malloc(*pPacket->pDataSize);')

2246

isi_body.append(' }')

2247

isi_body.append(' replayResult = m_xglFuncs.real_xglGetImageSubresourceInfo(remap(pPacket->image), pPacket->pSubresource, pPacket->infoType, &size, pData);')

2248

isi_body.append(' if (replayResult == XGL_SUCCESS)')

2249

isi_body.append(' {')

2250

isi_body.append(' if (size != *pPacket->pDataSize && pData == NULL)')

2251

isi_body.append(' {')

2252

isi_body.append(' glv_LogWarn("xglGetImageSubresourceInfo returned a differing data size: replay (%d bytes) vs trace (%d bytes)\\n", size, *pPacket->pDataSize);')

2253

isi_body.append(' }')

2254

isi_body.append(' else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0)')

2255

isi_body.append(' {')

2256

isi_body.append(' glv_LogWarn("xglGetImageSubresourceInfo returned differing data contents than the trace file contained.\\n");')

2257

isi_body.append(' }')

2258

isi_body.append(' }')

2259

isi_body.append(' glv_free(pData);')

2260

return "\n".join(isi_body)

2261

2262

def _gen_replay_create_graphics_pipeline(self):

2263

cgp_body = []

2264

cgp_body.append(' XGL_GRAPHICS_PIPELINE_CREATE_INFO createInfo;')

2265

cgp_body.append(' struct shaderPair saveShader[10];')

2266

cgp_body.append(' unsigned int idx = 0;')

2267

cgp_body.append(' memcpy(&createInfo, pPacket->pCreateInfo, sizeof(XGL_GRAPHICS_PIPELINE_CREATE_INFO));')

2268

cgp_body.append(' // Cast to shader type, as those are of primariy interest and all structs in LL have same header w/ sType & pNext')

2269

cgp_body.append(' XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pPacketNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pPacket->pCreateInfo->pNext;')

2270

cgp_body.append(' XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)createInfo.pNext;')

2271

cgp_body.append(' while (XGL_NULL_HANDLE != pPacketNext)')

2272

cgp_body.append(' {')

2273

cgp_body.append(' if (XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO == pNext->sType)')

2274

cgp_body.append(' {')

2275

cgp_body.append(' saveShader[idx].val = pNext->shader.shader;')

2276

cgp_body.append(' saveShader[idx++].addr = &(pNext->shader.shader);')

2277

cgp_body.append(' pNext->shader.shader = remap(pPacketNext->shader.shader);')

2278

cgp_body.append(' }')

2279

cgp_body.append(' pPacketNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pPacketNext->pNext;')

2280

cgp_body.append(' pNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pNext->pNext;')

2281

cgp_body.append(' }')

2282

cgp_body.append(' XGL_PIPELINE pipeline;')

2283

cgp_body.append(' replayResult = m_xglFuncs.real_xglCreateGraphicsPipeline(remap(pPacket->device), &createInfo, &pipeline);')

2284

cgp_body.append(' if (replayResult == XGL_SUCCESS)')

2285

cgp_body.append(' {')

2286

cgp_body.append(' add_to_map(pPacket->pPipeline, &pipeline);')

2287

cgp_body.append(' }')

2288

cgp_body.append(' for (unsigned int i = 0; i < idx; i++)')

2289

cgp_body.append(' *(saveShader[i].addr) = saveShader[i].val;')

2290

return "\n".join(cgp_body)

2291

2292

def _gen_replay_store_pipeline(self):

2293

sp_body = []

2294

sp_body.append(' XGL_SIZE size = 0;')

2295

sp_body.append(' void* pData = NULL;')

2296

sp_body.append(' if (pPacket->pData != NULL && pPacket->pDataSize != NULL)')

2297

sp_body.append(' {')

2298

sp_body.append(' size = *pPacket->pDataSize;')

2299

sp_body.append(' pData = glv_malloc(*pPacket->pDataSize);')

2300

sp_body.append(' }')

2301

sp_body.append(' replayResult = m_xglFuncs.real_xglStorePipeline(remap(pPacket->pipeline), &size, pData);')

2302

sp_body.append(' if (replayResult == XGL_SUCCESS)')

2303

sp_body.append(' {')

2304

sp_body.append(' if (size != *pPacket->pDataSize && pData == NULL)')

2305

sp_body.append(' {')

2306

sp_body.append(' glv_LogWarn("xglStorePipeline returned a differing data size: replay (%d bytes) vs trace (%d bytes)\\n", size, *pPacket->pDataSize);')

2307

sp_body.append(' }')

2308

sp_body.append(' else if (pData != NULL && memcmp(pData, pPacket->pData, size) != 0)')

2309

sp_body.append(' {')

2310

sp_body.append(' glv_LogWarn("xglStorePipeline returned differing data contents than the trace file contained.\\n");')

2311

sp_body.append(' }')

2312

sp_body.append(' }')

2313

sp_body.append(' glv_free(pData);')

2314

return "\n".join(sp_body)

2315

2316

def _gen_replay_cmd_bind_attachments(self):

2317

cba_body = []

2318

cba_body.append(' // adjust color targets')

2319

cba_body.append(' XGL_COLOR_ATTACHMENT_BIND_INFO* pColorAttachments = (XGL_COLOR_ATTACHMENT_BIND_INFO*)pPacket->pColorAttachments;')

2320

cba_body.append(' bool allocatedColorAttachments = false;')

2321

cba_body.append(' if (pColorAttachments != NULL)')

2322

cba_body.append(' {')

2323

cba_body.append(' allocatedColorAttachments = true;')

2324

cba_body.append(' pColorAttachments = GLV_NEW_ARRAY(XGL_COLOR_ATTACHMENT_BIND_INFO, pPacket->colorAttachmentCount);')

2325

cba_body.append(' memcpy(pColorAttachments, pPacket->pColorAttachments, sizeof(XGL_COLOR_ATTACHMENT_BIND_INFO) * pPacket->colorAttachmentCount);')

2326

cba_body.append(' for (XGL_UINT i = 0; i < pPacket->colorAttachmentCount; i++)')

2327

cba_body.append(' {')

2328

cba_body.append(' pColorAttachments[i].view = remap(pPacket->pColorAttachments[i].view);')

2329

cba_body.append(' }')

2330

cba_body.append(' }')

2331

cba_body.append(' // adjust depth stencil target')

2332

cba_body.append(' const XGL_DEPTH_STENCIL_BIND_INFO* pDepthStencilAttachment = pPacket->pDepthStencilAttachment;')

2333

cba_body.append(' XGL_DEPTH_STENCIL_BIND_INFO depthTarget;')

2334

cba_body.append(' if (pDepthStencilAttachment != NULL)')

2335

cba_body.append(' {')

2336

cba_body.append(' memcpy(&depthTarget, pPacket->pDepthStencilAttachment, sizeof(XGL_DEPTH_STENCIL_BIND_INFO));')

2337

cba_body.append(' depthTarget.view = remap(pPacket->pDepthStencilAttachment->view);')

2338

cba_body.append(' pDepthStencilAttachment = &depthTarget;')

2339

cba_body.append(' }')

2340

cba_body.append(' // make call')

2341

cba_body.append(' m_xglFuncs.real_xglCmdBindAttachments(remap(pPacket->cmdBuffer), pPacket->colorAttachmentCount, pColorAttachments, pDepthStencilAttachment);')

2342

cba_body.append(' // cleanup')

2343

cba_body.append(' if (allocatedColorAttachments)')

2344

cba_body.append(' {')

2345

cba_body.append(' GLV_DELETE((void*)pColorAttachments);')

2346

cba_body.append(' }')

2347

return "\n".join(cba_body)

2348

2349

def _gen_replay_get_multi_gpu_compatibility(self):

2350

gmgc_body = []

2351

gmgc_body.append(' XGL_GPU_COMPATIBILITY_INFO cInfo;')

2352

gmgc_body.append(' XGL_PHYSICAL_GPU handle0, handle1;')

2353

gmgc_body.append(' handle0 = remap(pPacket->gpu0);')

2354

gmgc_body.append(' handle1 = remap(pPacket->gpu1);')

2355

gmgc_body.append(' replayResult = m_xglFuncs.real_xglGetMultiGpuCompatibility(handle0, handle1, &cInfo);')

2356

return "\n".join(gmgc_body)

2357

2358

def _gen_replay_destroy_object(self):

2359

do_body = []

2360

do_body.append(' XGL_OBJECT object = remap(pPacket->object);')

2361

do_body.append(' if (object != XGL_NULL_HANDLE)')

2362

do_body.append(' replayResult = m_xglFuncs.real_xglDestroyObject(object);')

2363

do_body.append(' if (replayResult == XGL_SUCCESS)')

2364

do_body.append(' rm_from_map(pPacket->object);')

2365

return "\n".join(do_body)

2366

2367

def _gen_replay_wait_for_fences(self):

2368

wf_body = []

2369

wf_body.append(' XGL_FENCE *pFence = GLV_NEW_ARRAY(XGL_FENCE, pPacket->fenceCount);')

2370

wf_body.append(' for (XGL_UINT i = 0; i < pPacket->fenceCount; i++)')

2371

wf_body.append(' {')

2372

wf_body.append(' *(pFence + i) = remap(*(pPacket->pFences + i));')

2373

wf_body.append(' }')

2374

wf_body.append(' replayResult = m_xglFuncs.real_xglWaitForFences(remap(pPacket->device), pPacket->fenceCount, pFence, pPacket->waitAll, pPacket->timeout);')

2375

wf_body.append(' GLV_DELETE(pFence);')

2376

return "\n".join(wf_body)

2377

2378

def _gen_replay_wsi_associate_connection(self):

2379

wac_body = []

2380

wac_body.append(' //associate with the replayers Wsi connection rather than tracers')

2381

wac_body.append(' replayResult = m_xglFuncs.real_xglWsiX11AssociateConnection(remap(pPacket->gpu), &(m_display->m_WsiConnection));')

2382

return "\n".join(wac_body)

2383

2384

def _gen_replay_wsi_get_msc(self):

2385

wgm_body = []

2386

wgm_body.append(' xcb_window_t window = m_display->m_XcbWindow;')

2387

wgm_body.append(' replayResult = m_xglFuncs.real_xglWsiX11GetMSC(remap(pPacket->device), window, pPacket->crtc, pPacket->pMsc);')

2388

return "\n".join(wgm_body)

2389

2390

def _gen_replay_wsi_create_presentable_image(self):

2391

cpi_body = []

2392

cpi_body.append(' XGL_IMAGE img;')

2393

cpi_body.append(' XGL_GPU_MEMORY mem;')

2394

cpi_body.append(' replayResult = m_xglFuncs.real_xglWsiX11CreatePresentableImage(remap(pPacket->device), pPacket->pCreateInfo, &img, &mem);')

2395

cpi_body.append(' if (replayResult == XGL_SUCCESS)')

2396

cpi_body.append(' {')

2397

cpi_body.append(' if (pPacket->pImage != NULL)')

2398

cpi_body.append(' add_to_map(pPacket->pImage, &img);')

2399

cpi_body.append(' if(pPacket->pMem != NULL)')

2400

cpi_body.append(' add_to_map(pPacket->pMem, &mem);')

2401

cpi_body.append(' }')

2402

return "\n".join(cpi_body)

2403

2404

def _gen_replay_wsi_queue_present(self):

2405

wqp_body = []

2406

wqp_body.append(' XGL_WSI_X11_PRESENT_INFO pInfo;')

2407

wqp_body.append(' memcpy(&pInfo, pPacket->pPresentInfo, sizeof(XGL_WSI_X11_PRESENT_INFO));')

2408

wqp_body.append(' pInfo.srcImage = remap(pPacket->pPresentInfo->srcImage);')

2409

wqp_body.append(' // use replayers Xcb window')

2410

wqp_body.append(' pInfo.destWindow = m_display->m_XcbWindow;')

2411

wqp_body.append(' replayResult = m_xglFuncs.real_xglWsiX11QueuePresent(remap(pPacket->queue), &pInfo, remap(pPacket->fence));')

2412

return "\n".join(wqp_body)

2413

2414

# I don't like making these 3 mem functions 'fully' custom, but just doing it for now to avoid being too cute

2415

def _gen_replay_free_memory(self):

2416

fm_body = []

2417

fm_body.append(' XGL_GPU_MEMORY handle = remap(pPacket->mem);')

2418

fm_body.append(' replayResult = m_xglFuncs.real_xglFreeMemory(handle);')

2419

fm_body.append(' if (replayResult == XGL_SUCCESS) ')

2420

fm_body.append(' {')

2421

fm_body.append(' rm_entry_from_mapData(handle);')

2422

fm_body.append(' rm_from_map(pPacket->mem);')

2423

fm_body.append(' }')

2424

return "\n".join(fm_body)

2425

2426

def _gen_replay_map_memory(self):

2427

mm_body = []

2428

mm_body.append(' XGL_GPU_MEMORY handle = remap(pPacket->mem);')

2429

mm_body.append(' XGL_VOID* pData;')

2430

mm_body.append(' replayResult = m_xglFuncs.real_xglMapMemory(handle, pPacket->flags, &pData);')

2431

mm_body.append(' if (replayResult == XGL_SUCCESS)')

2432

mm_body.append(' add_mapping_to_mapData(handle, pData);')

2433

return "\n".join(mm_body)

2434

2435

def _gen_replay_unmap_memory(self):

2436

um_body = []

2437

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

2438

um_body.append(' rm_mapping_from_mapData(handle, pPacket->pData); // copies data from packet into memory buffer')

2439

um_body.append(' replayResult = m_xglFuncs.real_xglUnmapMemory(handle);')

2440

return "\n".join(um_body)

2441

2442

def _gen_replay_bind_dynamic_memory_view(self):

2443

bdmv_body = []

2444

bdmv_body.append(' XGL_MEMORY_VIEW_ATTACH_INFO memView;')

2445

bdmv_body.append(' memcpy(&memView, pPacket->pMemView, sizeof(XGL_MEMORY_VIEW_ATTACH_INFO));')

2446

bdmv_body.append(' memView.mem = remap(pPacket->pMemView->mem);')

2447

bdmv_body.append(' m_xglFuncs.real_xglCmdBindDynamicMemoryView(remap(pPacket->cmdBuffer), pPacket->pipelineBindPoint, &memView);')

2448

return "\n".join(bdmv_body)

2449

2450

def _generate_replay(self):

2451

# map protos to custom functions if body is fully custom

2452

custom_body_dict = {'InitAndEnumerateGpus': self._gen_replay_init_and_enum_gpus,

2453

'GetGpuInfo': self._gen_replay_get_gpu_info,

2454

'CreateDevice': self._gen_replay_create_device,

2455

'GetExtensionSupport': self._gen_replay_get_extension_support,

2456

'QueueSubmit': self._gen_replay_queue_submit,

2457

'GetMemoryHeapCount': self._gen_replay_get_memory_heap_count,

2458

'GetMemoryHeapInfo': self._gen_replay_get_memory_heap_info,

2459

'RemapVirtualMemoryPages': self._gen_replay_remap_virtual_memory_pages,

2460

'GetObjectInfo': self._gen_replay_get_object_info,

2461

'GetFormatInfo': self._gen_replay_get_format_info,

2462

'GetImageSubresourceInfo': self._gen_replay_get_image_subresource_info,

2463

'CreateGraphicsPipeline': self._gen_replay_create_graphics_pipeline,

2464

'StorePipeline': self._gen_replay_store_pipeline,

2465

'CmdBindAttachments': self._gen_replay_cmd_bind_attachments,

2466

'GetMultiGpuCompatibility': self._gen_replay_get_multi_gpu_compatibility,

2467

'DestroyObject': self._gen_replay_destroy_object,

2468

'WaitForFences': self._gen_replay_wait_for_fences,

2469

'WsiX11AssociateConnection': self._gen_replay_wsi_associate_connection,

2470

'WsiX11GetMSC': self._gen_replay_wsi_get_msc,

2471

'WsiX11CreatePresentableImage': self._gen_replay_wsi_create_presentable_image,

2472

'WsiX11QueuePresent': self._gen_replay_wsi_queue_present,

2473

'FreeMemory': self._gen_replay_free_memory,

2474

'MapMemory': self._gen_replay_map_memory,

2475

'UnmapMemory': self._gen_replay_unmap_memory,

2476

'CmdBindDynamicMemoryView': self._gen_replay_bind_dynamic_memory_view}

2477

# Despite returning a value, don't check these funcs b/c custom code includes check already

2478

custom_check_ret_val = ['InitAndEnumerateGpus', 'GetGpuInfo', 'CreateDevice', 'GetExtensionSupport']

2479

# multi-gpu Open funcs w/ list of local params to create

2480

custom_open_params = {'OpenSharedMemory': (-1,),

2481

'OpenSharedQueueSemaphore': (-1,),

2482

'OpenPeerMemory': (-1,),

2483

'OpenPeerImage': (-1, -2,)}

2484

# Functions that create views are unique from other create functions

2485

create_view_list = ['CreateImageView', 'CreateColorAttachmentView', 'CreateDepthStencilView', 'CreateComputePipeline']

2486

# Functions to treat as "Create' that don't have 'Create' in the name

2487

special_create_list = ['LoadPipeline', 'AllocMemory', 'GetDeviceQueue', 'PinSystemMemory']

2488

# A couple funcs use do while loops

2489

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

2490

rbody = []

2491

rbody.append('#define CHECK_RETURN_VALUE(entrypoint) returnValue = handle_replay_errors(#entrypoint, replayResult, pPacket->result, returnValue);\n')

2492

rbody.append('glv_replay::GLV_REPLAY_RESULT xglReplay::replay(glv_trace_packet_header *packet)')

2493

rbody.append('{')

2494

rbody.append(' glv_replay::GLV_REPLAY_RESULT returnValue = glv_replay::GLV_REPLAY_SUCCESS;')

2495

rbody.append(' XGL_RESULT replayResult = XGL_ERROR_UNKNOWN;')

2496

rbody.append(' switch (packet->packet_id)')

2497

rbody.append(' {')

Jon Ashburn

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

[diff] [blame]

2498

rbody.append(' case GLV_TPI_XGL_xglApiVersion:')

2499

rbody.append(' break; // nothing to replay on the version packet')

Tobin Ehlis

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

[diff] [blame]

2500

for proto in self.protos:

ret_value = False

create_view = False

create_func = False

transitions = False

ds_attach = False

# TODO : How to handle VOID* return of GetProcAddr?

2507

if ('VOID' not in proto.ret) and (proto.name not in custom_check_ret_val):

2508

ret_value = True

2509

if proto.name in create_view_list:

2510

create_view = True

2511

elif 'Create' in proto.name or proto.name in special_create_list:

2512

create_func = True

2513

elif 'pStateTransitions' in [p.name for p in proto.params]:

2514

transitions = True

2515

elif proto.name.startswith('Attach'):

2516

ds_attach = True

2517

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

2518

rbody.append(' {')

2519

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

2520

if proto.name in custom_body_dict:

2521

rbody.append(custom_body_dict[proto.name]())

2522

else:

2523

if proto.name in custom_open_params:

2524

rbody.append(' XGL_DEVICE handle;')

2525

for pidx in custom_open_params[proto.name]:

2526

rbody.append(' %s local_%s;' % (proto.params[pidx].ty.strip('const ').strip('*'), proto.params[pidx].name))

2527

rbody.append(' handle = remap(pPacket->device);')

2528

elif create_view:

2529

rbody.append(' %s createInfo;' % (proto.params[1].ty.strip('*').strip('const ')))

2530

rbody.append(' memcpy(&createInfo, pPacket->pCreateInfo, sizeof(%s));' % (proto.params[1].ty.strip('*').strip('const ')))

2531

if 'CreateComputePipeline' == proto.name:

2532

rbody.append(' createInfo.cs.shader = remap(pPacket->pCreateInfo->cs.shader);')

2533

else:

2534

rbody.append(' createInfo.image = remap(pPacket->pCreateInfo->image);')

2535

rbody.append(' %s local_%s;' % (proto.params[-1].ty.strip('*').strip('const '), proto.params[-1].name))

2536

elif create_func: # Declare local var to store created handle into

2537

rbody.append(' %s local_%s;' % (proto.params[-1].ty.strip('*').strip('const '), proto.params[-1].name))

2538

elif transitions:

2539

rbody.append(' %s pStateTransitions = (%s)pPacket->pStateTransitions;' % (proto.params[-1].ty.strip('const '), proto.params[-1].ty.strip('const ')))

2540

rbody.append(' bool allocatedMem = false;')

2541

rbody.append(' if (pStateTransitions != NULL)')

2542

rbody.append(' {')

2543

rbody.append(' allocatedMem = true;')

2544

rbody.append(' pStateTransitions = GLV_NEW_ARRAY(%s, pPacket->transitionCount);' % (proto.params[-1].ty.strip('*').strip('const ')))

2545

rbody.append(' memcpy(pStateTransitions, pPacket->pStateTransitions, sizeof(%s) * pPacket->transitionCount);' % (proto.params[-1].ty.strip('*').strip('const ')))

2546

rbody.append(' for (XGL_UINT i = 0; i < pPacket->transitionCount; i++)')

2547

rbody.append(' {')

2548

if 'Memory' in proto.name:

2549

rbody.append(' pStateTransitions[i].mem = remap(pPacket->pStateTransitions[i].mem);')

2550

else:

2551

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

2556

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

2557

rbody.append(' for (XGL_UINT i = 0; i < pPacket->slotCount; i++)')

2558

rbody.append(' {')

2559

if 'Sampler' in proto.name:

2560

rbody.append(' %s[i] = remap(pPacket->%s[i]);' % (proto.params[-1].name, proto.params[-1].name))

2561

elif 'Image' in proto.name:

2562

rbody.append(' %s[i].view = remap(pPacket->%s[i].view);' % (proto.params[-1].name, proto.params[-1].name))

2563

elif 'Memory' in proto.name:

2564

rbody.append(' %s[i].mem = remap(pPacket->%s[i].mem);' % (proto.params[-1].name, proto.params[-1].name))

2565

else:

2566

rbody.append(' %s[i].descriptorSet = remap(pPacket->%s[i].descriptorSet);' % (proto.params[-1].name, proto.params[-1].name))

2567

rbody.append(' }')

2568

elif proto.name in do_while_dict:

2569

rbody.append(' do {')

2570

rr_string = ' '

2571

if ret_value:

2572

rr_string = ' replayResult = '

2573

rr_string += 'm_xglFuncs.real_xgl%s(' % proto.name

2574

for p in proto.params:

2575

# For last param of Create funcs, pass address of param

2576

if create_func and p.name == proto.params[-1].name:

2577

rr_string += '&local_%s, ' % p.name

2578

else:

2579

rr_string += '%s, ' % self._get_packet_param(p.ty, p.name)

2580

rr_string = '%s);' % rr_string[:-2]

2581

if transitions:

2582

rr_string = rr_string.replace('pPacket->pState', 'pState')

2583

elif ds_attach:

2584

rr_list = rr_string.split(', ')

2585

rr_list[-1] = '%s);' % proto.params[-1].name

2586

rr_string = ', '.join(rr_list)

2587

elif proto.name in custom_open_params:

2588

rr_list = rr_string.split(', ')

2589

rr_list[0] = rr_list[0].replace('remap(pPacket->device)', 'handle')

2590

for pidx in custom_open_params[proto.name]:

2591

rr_list[pidx] = '&local_%s' % proto.params[pidx].name

2592

rr_string = ', '.join(rr_list)

2593

rr_string += ');'

2594

elif create_view:

2595

rr_list = rr_string.split(', ')

2596

rr_list[-2] = '&createInfo'

2597

rr_list[-1] = '&local_%s);' % proto.params[-1].name

2598

rr_string = ', '.join(rr_list)

2599

# this is a sneaky shortcut to use generic create code below to add_to_map

2600

create_func = True

2601

rbody.append(rr_string)

2602

if 'DestroyDevice' in proto.name:

2603

rbody.append(' if (replayResult == XGL_SUCCESS)')

2604

rbody.append(' {')

2605

rbody.append(' rm_from_map(pPacket->device);')

2606

rbody.append(' m_display->m_initedXGL = false;')

2607

rbody.append(' }')

2608

elif create_func: # save handle mapping if create successful

2609

rbody.append(' if (replayResult == XGL_SUCCESS)')

2610

rbody.append(' {')

2611

rbody.append(' add_to_map(pPacket->%s, &local_%s);' % (proto.params[-1].name, proto.params[-1].name))

2612

if 'AllocMemory' == proto.name:

2613

rbody.append(' add_entry_to_mapData(local_%s, pPacket->pAllocInfo->allocationSize);' % (proto.params[-1].name))

2614

rbody.append(' }')

2615

elif transitions:

2616

rbody.append(' if (allocatedMem)')

2617

rbody.append(' {')

2618

rbody.append(' GLV_DELETE((void*)pStateTransitions);')

2619

rbody.append(' }')

2620

elif ds_attach:

2621

rbody.append(' GLV_DELETE(%s);' % proto.params[-1].name)

2622

elif proto.name in do_while_dict:

2623

rbody[-1] = ' %s' % rbody[-1]

2624

rbody.append(' } while (%s);' % do_while_dict[proto.name])

2625

if ret_value:

2626

rbody.append(' CHECK_RETURN_VALUE(xgl%s);' % proto.name)

2627

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

2632

rbody.append(' break;')

2633

rbody.append(' }')

2634

rbody.append(' default:')

2635

rbody.append(' glv_LogWarn("Unrecognized packet_id %u, skipping\\n", packet->packet_id);')

2636

rbody.append(' returnValue = glv_replay::GLV_REPLAY_INVALID_ID;')

2637

rbody.append(' break;')

2638

rbody.append(' }')

2639

rbody.append(' return returnValue;')

2640

rbody.append('}')

2641

return "\n".join(rbody)

2642

2643

class GlaveTraceHeader(Subcommand):

2644

def generate_header(self):

2645

header_txt = []

2646

header_txt.append('#include "glvtrace_xgl_xgl_structs.h"')

2647

header_txt.append('#include "glvtrace_xgl_packet_id.h"\n')

2648

header_txt.append('void AttachHooks();')

2649

header_txt.append('void DetachHooks();')

2650

header_txt.append('void InitTracer();\n')

2651

return "\n".join(header_txt)

2652

2653

def generate_body(self):

2654

body = [self._generate_trace_func_ptrs(),

2655

self._generate_trace_func_protos()]

2656

2657

return "\n".join(body)

2658

2659

class GlaveTraceC(Subcommand):

2660

def generate_header(self):

2661

header_txt = []

2662

header_txt.append('#include "glv_platform.h"')

2663

header_txt.append('#include "glv_common.h"')

2664

header_txt.append('#include "glvtrace_xgl_xgl.h"')

2665

header_txt.append('#include "glvtrace_xgl_xgldbg.h"')

2666

header_txt.append('#include "glvtrace_xgl_xglwsix11ext.h"')

2667

header_txt.append('#include "glv_interconnect.h"')

2668

header_txt.append('#include "glv_filelike.h"')

2669

header_txt.append('#ifdef WIN32')

2670

header_txt.append('#include "mhook/mhook-lib/mhook.h"')

2671

header_txt.append('#endif')

2672

header_txt.append('#include "glv_trace_packet_utils.h"')

2673

header_txt.append('#include <stdio.h>\n')

2674

return "\n".join(header_txt)

2675

2676

def generate_body(self):

2677

body = [self._generate_func_ptr_assignments(),

2678

self._generate_attach_hooks(),

2679

self._generate_detach_hooks(),

Jon Ashburn

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

[diff] [blame]

2680

self._generate_init_funcs(),

Tobin Ehlis