/*******************************************************************************
**
** gcoBUFFER_Write
**
** Copy a number of bytes into the buffer.
**
** INPUT:
**
** gcoBUFFER Buffer
** Pointer to an gcoBUFFER object.
**
** gctCONST_POINTER Data
** Pointer to a buffer that contains the data to be copied.
**
** IN gctSIZE_T Bytes
** Number of bytes to copy.
**
** IN gctBOOL Aligned
** gcvTRUE if the data needs to be aligned to 64-bit.
**
** OUTPUT:
**
** Nothing.
*/
gceSTATUS
gcoBUFFER_Write(
IN gcoBUFFER Buffer,
IN gctCONST_POINTER Data,
IN gctSIZE_T Bytes,
IN gctBOOL Aligned
)
{
gceSTATUS status;
gcoCMDBUF reserve;
gcmHEADER_ARG("Buffer=0x%x Data=0x%x Bytes=%lu Aligned=%d",
Buffer, Data, Bytes, Aligned);
/* Verify the arguments. */
gcmVERIFY_OBJECT(Buffer, gcvOBJ_BUFFER);
gcmDEBUG_VERIFY_ARGUMENT(Data != gcvNULL);
gcmDEBUG_VERIFY_ARGUMENT(Bytes > 0);
/* Reserve data in the buffer. */
gcmONERROR(gcoBUFFER_Reserve(Buffer, Bytes, Aligned, &reserve));
/* Write data into the buffer. */
gcmONERROR(gcoOS_MemCopy(reserve->lastReserve, Data, Bytes));
/* Success. */
gcmFOOTER_NO();
return gcvSTATUS_OK;
OnError:
/* Return status. */
gcmFOOTER();
return status;
}
VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguComputeWarpQuadToQuad(
VGfloat DestinationX0,
VGfloat DestinationY0,
VGfloat DestinationX1,
VGfloat DestinationY1,
VGfloat DestinationX2,
VGfloat DestinationY2,
VGfloat DestinationX3,
VGfloat DestinationY3,
VGfloat SourceX0,
VGfloat SourceY0,
VGfloat SourceX1,
VGfloat SourceY1,
VGfloat SourceX2,
VGfloat SourceY2,
VGfloat SourceX3,
VGfloat SourceY3,
VGfloat * Matrix
)
{
VGUErrorCode result = VGU_BAD_HANDLE_ERROR;
vgmENTERAPI(vguComputeWarpQuadToQuad)
{
vgsMATRIX q2s;
vgsMATRIX s2q;
vgsMATRIX product;
#if gcdENABLE_PERFORMANCE_PRIOR
gctFLOAT m1[9], m2[9];
#endif
/* Validate the input matrix. */
if (vgmIS_INVALID_PTR(Matrix, 4))
{
result = VGU_ILLEGAL_ARGUMENT_ERROR;
break;
}
/* Reset matrices. */
vgfInvalidateMatrix(&q2s);
vgfInvalidateMatrix(&s2q);
#if gcdENABLE_PERFORMANCE_PRIOR
result = vguComputeWarpQuadToSquare(
SourceX0, SourceY0,
SourceX1, SourceY1,
SourceX2, SourceY2,
SourceX3, SourceY3,
m1
);
/* Error? */
if (result != VGU_NO_ERROR)
{
break;
}
vgmCONVERTMAT(gctFIXED, gctFLOAT, vgmFLOAT_TO_FIXED_SPECIAL, &q2s, m1);
result = vguComputeWarpSquareToQuad(
DestinationX0, DestinationY0,
DestinationX1, DestinationY1,
DestinationX2, DestinationY2,
DestinationX3, DestinationY3,
m2
);
/* Error? */
if (result != VGU_NO_ERROR)
{
break;
}
vgmCONVERTMAT(gctFIXED, gctFLOAT, vgmFLOAT_TO_FIXED_SPECIAL, &s2q, m2);
/* Find the product. */
vgfMultiplyMatrix3x3(&s2q, &q2s, &product);
/* Set the result. */
vgmCONVERTMAT(gctFLOAT, gctFIXED, vgmFIXED_TO_FLOAT_SPECIAL, Matrix, &product);
#else
result = vguComputeWarpQuadToSquare(
SourceX0, SourceY0,
SourceX1, SourceY1,
SourceX2, SourceY2,
SourceX3, SourceY3,
vgmGETMATRIXVALUES(&q2s)
);
/* Error? */
if (result != VGU_NO_ERROR)
{
break;
}
result = vguComputeWarpSquareToQuad(
DestinationX0, DestinationY0,
DestinationX1, DestinationY1,
DestinationX2, DestinationY2,
DestinationX3, DestinationY3,
vgmGETMATRIXVALUES(&s2q)
);
/* Error? */
if (result != VGU_NO_ERROR)
{
break;
}
/* Find the product. */
vgfMultiplyMatrix3x3(&s2q, &q2s, &product);
/* Set the result. */
gcoOS_MemCopy(
Matrix,
vgmGETMATRIXVALUES(&product),
sizeof(vgtMATRIXVALUES)
);
#endif
}
vgmLEAVEAPI(vguComputeWarpQuadToQuad);
/* Return result. */
return result;
}
VGU_API_CALL VGUErrorCode VGU_API_ENTRY vguComputeWarpQuadToSquare(
VGfloat SourceX0,
VGfloat SourceY0,
VGfloat SourceX1,
VGfloat SourceY1,
VGfloat SourceX2,
VGfloat SourceY2,
VGfloat SourceX3,
VGfloat SourceY3,
VGfloat * Matrix
)
{
VGUErrorCode result = VGU_BAD_HANDLE_ERROR;
vgmENTERAPI(vguComputeWarpQuadToSquare)
{
vgsMATRIX projective;
vgsMATRIX warped;
/* Validate the input matrix. */
if (vgmIS_INVALID_PTR(Matrix, 4))
{
result = VGU_ILLEGAL_ARGUMENT_ERROR;
break;
}
/* Reset the projective matrix. */
vgfInvalidateMatrix(&projective);
#if gcdENABLE_PERFORMANCE_PRIOR
/* Get projective transformation matrix. */
result = vguComputeWarpSquareToQuad(
SourceX0, SourceY0,
SourceX1, SourceY1,
SourceX2, SourceY2,
SourceX3, SourceY3,
Matrix
);
/* Error? */
if (result != VGU_NO_ERROR)
{
break;
}
/*convert to fixed-point*/
vgmCONVERTMAT(gctFIXED, gctFLOAT, vgmFLOAT_TO_FIXED_SPECIAL, &projective, Matrix);
/* Invert the matrix. */
if (!vgfInvertMatrix(&projective, &warped))
{
result = VGU_BAD_WARP_ERROR;
break;
}
/* Set the result matrix. */
vgmCONVERTMAT(gctFLOAT, gctFIXED, vgmFIXED_TO_FLOAT_SPECIAL, Matrix, &warped);
#else
/* Get projective transformation matrix. */
result = vguComputeWarpSquareToQuad(
SourceX0, SourceY0,
SourceX1, SourceY1,
SourceX2, SourceY2,
SourceX3, SourceY3,
vgmGETMATRIXVALUES(&projective)
);
/* Error? */
if (result != VGU_NO_ERROR)
{
break;
}
/* Invert the matrix. */
if (!vgfInvertMatrix(&projective, &warped))
{
result = VGU_BAD_WARP_ERROR;
break;
}
/* Set the result matrix. */
gcoOS_MemCopy(
Matrix,
vgmGETMATRIXVALUES(&warped),
sizeof(vgtMATRIXVALUES)
);
#endif
}
vgmLEAVEAPI(vguComputeWarpQuadToSquare);
/* Return result. */
return result;
}
gceSTATUS
gcoQUEUE_AppendEvent(
IN gcoQUEUE Queue,
IN gcsHAL_INTERFACE * Interface
)
{
gceSTATUS status;
gcsQUEUE_PTR record = gcvNULL;
#ifdef __QNXNTO__
gctSIZE_T allocationSize;
gctPHYS_ADDR physAddr;
#else
gctPOINTER pointer = gcvNULL;
#endif
gcmHEADER_ARG("Queue=0x%x Interface=0x%x", Queue, Interface);
/* Verify the arguments. */
gcmVERIFY_OBJECT(Queue, gcvOBJ_QUEUE);
gcmVERIFY_ARGUMENT(Interface != gcvNULL);
/* Allocate record. */
#ifdef __QNXNTO__
allocationSize = gcmSIZEOF(gcsQUEUE);
if (Queue->freeBytes < allocationSize)
{
gctSIZE_T recordsSize = BUFFER_SIZE;
gcsQUEUE_PTR prevRecords = Queue->records;
gcsHAL_INTERFACE iface;
/* Allocate new set of records. */
gcmONERROR(
gcoOS_AllocateNonPagedMemory(gcvNULL,
gcvTRUE,
&recordsSize,
&physAddr,
(gctPOINTER *) &Queue->records));
Queue->freeBytes = recordsSize;
Queue->offset = 0;
if ( Queue->freeBytes < allocationSize )
{
gcmFOOTER_ARG("status=%d", gcvSTATUS_DATA_TOO_LARGE);
return gcvSTATUS_DATA_TOO_LARGE;
}
/* Schedule to free Queue->records,
* hence not unmapping currently scheduled events immediately. */
iface.command = gcvHAL_FREE_NON_PAGED_MEMORY;
iface.u.FreeNonPagedMemory.bytes = BUFFER_SIZE;
iface.u.FreeNonPagedMemory.physical = 0;
iface.u.FreeNonPagedMemory.logical = prevRecords;
gcmONERROR(
gcoQUEUE_AppendEvent(Queue, &iface));
}
record = (gcsQUEUE_PTR)((gctUINT32)Queue->records + Queue->offset);
Queue->offset += allocationSize;
Queue->freeBytes -= allocationSize;
#else
/* Check if we have records on the free list. */
if (Queue->freeList != gcvNULL)
{
/* Allocate from hte free list. */
record = Queue->freeList;
Queue->freeList = record->next;
}
else
{
gcmONERROR(gcoOS_Allocate(gcvNULL,
gcmSIZEOF(gcsQUEUE),
&pointer));
record = pointer;
}
#endif
/* Initialize record. */
record->next = gcvNULL;
gcoOS_MemCopy(&record->iface, Interface, gcmSIZEOF(record->iface));
if (Queue->head == gcvNULL)
{
/* Initialize queue. */
Queue->head = record;
}
else
{
/* Append record to end of queue. */
Queue->tail->next = record;
}
/* Mark end of queue. */
Queue->tail = record;
/* update count */
Queue->recordCount++;
/* Success. */
gcmFOOTER_NO();
return gcvSTATUS_OK;
OnError:
#ifndef __QNXNTO__
if (pointer != gcvNULL)
{
/* Put record on free list. */
record->next = Queue->freeList;
Queue->freeList = record;
}
#endif
/* Return the status. */
gcmFOOTER();
return status;
}
gceSTATUS
gcoPROFILER_EndDraw(
IN gcoHAL Hal,
IN gctBOOL FirstDraw
)
{
/*#if (PROFILE_HAL_COUNTERS || PROFILE_HW_COUNTERS)*/
gcsHAL_INTERFACE iface;
gceSTATUS status;
static gcsPROFILER previous;
static gcsPROFILER_COUNTERS precounters;
/*#endif*/
gcmHEADER();
if (!gcPLS.hal->profiler.enable)
{
gcmFOOTER_NO();
return gcvSTATUS_OK;
}
/*#if PROFILE_HAL_COUNTERS*/
if (gcPLS.hal->profiler.enableHal)
{
#if gcdNEW_PROFILER_FILE
if(FirstDraw == gcvTRUE)
{
gcoOS_ZeroMemory(&previous, gcmSIZEOF(previous));
}
gcmWRITE_CONST(VPG_HAL);
gcmWRITE_COUNTER(VPC_HALVERTBUFNEWBYTEALLOC, gcPLS.hal->profiler.vertexBufferNewBytesAlloc-previous.vertexBufferNewBytesAlloc);
gcmWRITE_COUNTER(VPC_HALVERTBUFTOTALBYTEALLOC, gcPLS.hal->profiler.vertexBufferTotalBytesAlloc-previous.vertexBufferTotalBytesAlloc);
gcmWRITE_COUNTER(VPC_HALVERTBUFNEWOBJALLOC, gcPLS.hal->profiler.vertexBufferNewObjectsAlloc-previous.vertexBufferNewObjectsAlloc);
gcmWRITE_COUNTER(VPC_HALVERTBUFTOTALOBJALLOC, gcPLS.hal->profiler.vertexBufferTotalObjectsAlloc-previous.vertexBufferTotalObjectsAlloc);
gcmWRITE_COUNTER(VPC_HALINDBUFNEWBYTEALLOC, gcPLS.hal->profiler.indexBufferNewBytesAlloc-previous.indexBufferNewBytesAlloc);
gcmWRITE_COUNTER(VPC_HALINDBUFTOTALBYTEALLOC, gcPLS.hal->profiler.indexBufferTotalBytesAlloc-previous.indexBufferTotalBytesAlloc);
gcmWRITE_COUNTER(VPC_HALINDBUFNEWOBJALLOC, gcPLS.hal->profiler.indexBufferNewObjectsAlloc-previous.indexBufferNewObjectsAlloc);
gcmWRITE_COUNTER(VPC_HALINDBUFTOTALOBJALLOC, gcPLS.hal->profiler.indexBufferTotalObjectsAlloc-previous.indexBufferTotalObjectsAlloc);
gcmWRITE_COUNTER(VPC_HALTEXBUFNEWBYTEALLOC, gcPLS.hal->profiler.textureBufferNewBytesAlloc-previous.textureBufferNewBytesAlloc);
gcmWRITE_COUNTER(VPC_HALTEXBUFTOTALBYTEALLOC, gcPLS.hal->profiler.textureBufferTotalBytesAlloc-previous.textureBufferTotalBytesAlloc);
gcmWRITE_COUNTER(VPC_HALTEXBUFNEWOBJALLOC, gcPLS.hal->profiler.textureBufferNewObjectsAlloc-previous.textureBufferNewObjectsAlloc);
gcmWRITE_COUNTER(VPC_HALTEXBUFTOTALOBJALLOC, gcPLS.hal->profiler.textureBufferTotalObjectsAlloc-previous.textureBufferTotalObjectsAlloc);
gcmWRITE_CONST(VPG_END);
gcoOS_MemCopy(&previous,&gcPLS.hal->profiler,gcmSIZEOF(gcsPROFILER));
#else
gcmWRITE_STRING("<HALCounters>\n");
gcmPRINT_XML_COUNTER(vertexBufferNewBytesAlloc);
gcmPRINT_XML_COUNTER(vertexBufferTotalBytesAlloc);
gcmPRINT_XML_COUNTER(vertexBufferNewObjectsAlloc);
gcmPRINT_XML_COUNTER(vertexBufferTotalObjectsAlloc);
gcmPRINT_XML_COUNTER(indexBufferNewBytesAlloc);
gcmPRINT_XML_COUNTER(indexBufferTotalBytesAlloc);
gcmPRINT_XML_COUNTER(indexBufferNewObjectsAlloc);
gcmPRINT_XML_COUNTER(indexBufferTotalObjectsAlloc);
gcmPRINT_XML_COUNTER(textureBufferNewBytesAlloc);
gcmPRINT_XML_COUNTER(textureBufferTotalBytesAlloc);
gcmPRINT_XML_COUNTER(textureBufferNewObjectsAlloc);
gcmPRINT_XML_COUNTER(textureBufferTotalObjectsAlloc);
gcmWRITE_STRING("</HALCounters>\n");
#endif
/* Reset per-frame counters. */
}
/*#endif*/
/*#if PROFILE_HW_COUNTERS*/
/* gcvHAL_READ_ALL_PROFILE_REGISTERS. */
if (gcPLS.hal->profiler.enableHW)
{
if (gcPLS.hal->profiler.isSyncMode)
gcoHAL_Commit(gcvNULL, gcvTRUE);
#if VIVANTE_PROFILER_PERDRAW
/* Set Register clear Flag. */
iface.command = gcvHAL_READ_PROFILER_REGISTER_SETTING;
iface.u.SetProfilerRegisterClear.bclear = gcvFALSE;
/* Call the kernel. */
status = gcoOS_DeviceControl(gcvNULL,
IOCTL_GCHAL_INTERFACE,
&iface, gcmSIZEOF(iface),
&iface, gcmSIZEOF(iface));
/* Verify result. */
if (gcmIS_ERROR(status)) return gcvSTATUS_GENERIC_IO;
#endif
iface.command = gcvHAL_READ_ALL_PROFILE_REGISTERS;
/* Call the kernel. */
status = gcoOS_DeviceControl(gcvNULL,
IOCTL_GCHAL_INTERFACE,
&iface, gcmSIZEOF(iface),
&iface, gcmSIZEOF(iface));
/* Verify result. */
if (gcmNO_ERROR(status))
{
#define gcmCOUNTERCOMPARE(name) ((iface.u.RegisterProfileData.counters.name) - (precounters.name))
#define gcmDRAWCOUNTERPRE(name) (precounters.name)
#if gcdNEW_PROFILER_FILE
if(FirstDraw == gcvFALSE)
{
gcoOS_ZeroMemory(&precounters, gcmSIZEOF(precounters));
gcmDRAWCOUNTERPRE(vs_inst_counter) = gcPLS.hal->profiler.prevVSInstCount;
gcmDRAWCOUNTERPRE(vtx_branch_inst_counter) = gcPLS.hal->profiler.prevVSBranchInstCount ;
gcmDRAWCOUNTERPRE(vtx_texld_inst_counter) = gcPLS.hal->profiler.prevVSTexInstCount;
gcmDRAWCOUNTERPRE(rendered_vertice_counter) = gcPLS.hal->profiler.prevVSVertexCount;
gcmDRAWCOUNTERPRE(ps_inst_counter) =gcPLS.hal->profiler.prevPSInstCount;
gcmDRAWCOUNTERPRE(pxl_branch_inst_counter) = gcPLS.hal->profiler.prevPSBranchInstCount;
gcmDRAWCOUNTERPRE(pxl_texld_inst_counter) = gcPLS.hal->profiler.prevPSTexInstCount;
gcmDRAWCOUNTERPRE(rendered_pixel_counter) = gcPLS.hal->profiler.prevPSPixelCount;
}
gcmWRITE_CONST(VPG_HW);
gcmWRITE_CONST(VPG_GPU);
gcmWRITE_COUNTER(VPC_GPUREAD64BYTE, gcmCOUNTERCOMPARE(gpuTotalRead64BytesPerFrame));
gcmWRITE_COUNTER(VPC_GPUWRITE64BYTE, gcmCOUNTERCOMPARE(gpuTotalWrite64BytesPerFrame));
gcmWRITE_COUNTER(VPC_GPUCYCLES, gcmCOUNTERCOMPARE(gpuCyclesCounter));
gcmWRITE_COUNTER(VPC_GPUTOTALCYCLES, gcmCOUNTERCOMPARE(gpuTotalCyclesCounter));
gcmWRITE_COUNTER(VPC_GPUIDLECYCLES, gcmCOUNTERCOMPARE(gpuIdleCyclesCounter));
gcmWRITE_CONST(VPG_END);
gcmWRITE_CONST(VPG_VS);
gcmWRITE_COUNTER(VPC_VSINSTCOUNT, gcmCOUNTERCOMPARE(vs_inst_counter));
gcmWRITE_COUNTER(VPC_VSBRANCHINSTCOUNT, gcmCOUNTERCOMPARE(vtx_branch_inst_counter));
gcmWRITE_COUNTER(VPC_VSTEXLDINSTCOUNT, gcmCOUNTERCOMPARE(vtx_texld_inst_counter));
gcmWRITE_COUNTER(VPC_VSRENDEREDVERTCOUNT, gcmCOUNTERCOMPARE(rendered_vertice_counter));
gcmWRITE_CONST(VPG_END);
gcmWRITE_CONST(VPG_PA);
gcmWRITE_COUNTER(VPC_PAINVERTCOUNT, gcmCOUNTERCOMPARE(pa_input_vtx_counter));
gcmWRITE_COUNTER(VPC_PAINPRIMCOUNT, gcmCOUNTERCOMPARE(pa_input_prim_counter));
gcmWRITE_COUNTER(VPC_PAOUTPRIMCOUNT, gcmCOUNTERCOMPARE(pa_output_prim_counter));
gcmWRITE_COUNTER(VPC_PADEPTHCLIPCOUNT, gcmCOUNTERCOMPARE(pa_depth_clipped_counter));
gcmWRITE_COUNTER(VPC_PATRIVIALREJCOUNT, gcmCOUNTERCOMPARE(pa_trivial_rejected_counter));
gcmWRITE_COUNTER(VPC_PACULLCOUNT, gcmCOUNTERCOMPARE(pa_culled_counter));
gcmWRITE_CONST(VPG_END);
gcmWRITE_CONST(VPG_SETUP);
gcmWRITE_COUNTER(VPC_SETRIANGLECOUNT, gcmCOUNTERCOMPARE(se_culled_triangle_count));
gcmWRITE_COUNTER(VPC_SELINECOUNT, gcmCOUNTERCOMPARE(se_culled_lines_count));
gcmWRITE_CONST(VPG_END);
gcmWRITE_CONST(VPG_RA);
gcmWRITE_COUNTER(VPC_RAVALIDPIXCOUNT, gcmCOUNTERCOMPARE(ra_valid_pixel_count));
gcmWRITE_COUNTER(VPC_RATOTALQUADCOUNT, gcmCOUNTERCOMPARE(ra_total_quad_count));
gcmWRITE_COUNTER(VPC_RAVALIDQUADCOUNTEZ, gcmCOUNTERCOMPARE(ra_valid_quad_count_after_early_z));
gcmWRITE_COUNTER(VPC_RATOTALPRIMCOUNT, gcmCOUNTERCOMPARE(ra_total_primitive_count));
gcmWRITE_COUNTER(VPC_RAPIPECACHEMISSCOUNT, gcmCOUNTERCOMPARE(ra_pipe_cache_miss_counter));
gcmWRITE_COUNTER(VPC_RAPREFCACHEMISSCOUNT, gcmCOUNTERCOMPARE(ra_prefetch_cache_miss_counter));
gcmWRITE_COUNTER(VPC_RAEEZCULLCOUNT, gcmCOUNTERCOMPARE(ra_eez_culled_counter));
gcmWRITE_CONST(VPG_END);
gcmWRITE_CONST(VPG_TX);
gcmWRITE_COUNTER(VPC_TXTOTBILINEARREQ, gcmCOUNTERCOMPARE(tx_total_bilinear_requests));
gcmWRITE_COUNTER(VPC_TXTOTTRILINEARREQ, gcmCOUNTERCOMPARE(tx_total_trilinear_requests));
gcmWRITE_COUNTER(VPC_TXTOTTEXREQ, gcmCOUNTERCOMPARE(tx_total_texture_requests));
gcmWRITE_COUNTER(VPC_TXMEMREADCOUNT, gcmCOUNTERCOMPARE(tx_mem_read_count));
gcmWRITE_COUNTER(VPC_TXMEMREADIN8BCOUNT, gcmCOUNTERCOMPARE(tx_mem_read_in_8B_count));
gcmWRITE_COUNTER(VPC_TXCACHEMISSCOUNT, gcmCOUNTERCOMPARE(tx_cache_miss_count));
gcmWRITE_COUNTER(VPC_TXCACHEHITTEXELCOUNT, gcmCOUNTERCOMPARE(tx_cache_hit_texel_count));
gcmWRITE_COUNTER(VPC_TXCACHEMISSTEXELCOUNT, gcmCOUNTERCOMPARE(tx_cache_miss_texel_count));
gcmWRITE_CONST(VPG_END);
gcmWRITE_CONST(VPG_PS);
gcmWRITE_COUNTER(VPC_PSINSTCOUNT, gcmCOUNTERCOMPARE(ps_inst_counter));
gcmWRITE_COUNTER(VPC_PSBRANCHINSTCOUNT, gcmCOUNTERCOMPARE(pxl_branch_inst_counter));
gcmWRITE_COUNTER(VPC_PSTEXLDINSTCOUNT, gcmCOUNTERCOMPARE(pxl_texld_inst_counter));
gcmWRITE_COUNTER(VPC_PSRENDEREDPIXCOUNT, gcmCOUNTERCOMPARE(rendered_pixel_counter));
gcmWRITE_CONST(VPG_END);
gcmWRITE_CONST(VPG_PE);
gcmWRITE_COUNTER(VPC_PEKILLEDBYCOLOR, gcmCOUNTERCOMPARE(pe_pixel_count_killed_by_color_pipe));
gcmWRITE_COUNTER(VPC_PEKILLEDBYDEPTH, gcmCOUNTERCOMPARE(pe_pixel_count_killed_by_depth_pipe));
gcmWRITE_COUNTER(VPC_PEDRAWNBYCOLOR, gcmCOUNTERCOMPARE(pe_pixel_count_drawn_by_color_pipe));
gcmWRITE_COUNTER(VPC_PEDRAWNBYDEPTH, gcmCOUNTERCOMPARE(pe_pixel_count_drawn_by_depth_pipe));
gcmWRITE_CONST(VPG_END);
gcmWRITE_CONST(VPG_MC);
gcmWRITE_COUNTER(VPC_MCREADREQ8BPIPE, gcmCOUNTERCOMPARE(mc_total_read_req_8B_from_pipeline));
gcmWRITE_COUNTER(VPC_MCREADREQ8BIP, gcmCOUNTERCOMPARE(mc_total_read_req_8B_from_IP));
gcmWRITE_COUNTER(VPC_MCWRITEREQ8BPIPE, gcmCOUNTERCOMPARE(mc_total_write_req_8B_from_pipeline));
gcmWRITE_CONST(VPG_END);
gcmWRITE_CONST(VPG_AXI);
gcmWRITE_COUNTER(VPC_AXIREADREQSTALLED, gcmCOUNTERCOMPARE(hi_axi_cycles_read_request_stalled));
gcmWRITE_COUNTER(VPC_AXIWRITEREQSTALLED, gcmCOUNTERCOMPARE(hi_axi_cycles_write_request_stalled));
gcmWRITE_COUNTER(VPC_AXIWRITEDATASTALLED, gcmCOUNTERCOMPARE(hi_axi_cycles_write_data_stalled));
gcmWRITE_CONST(VPG_END);
gcmWRITE_CONST(VPG_END);
gcoOS_MemCopy(&precounters,&iface.u.RegisterProfileData.counters,gcmSIZEOF(precounters));
#else
gcmWRITE_STRING("<HWCounters>\n");
gcmPRINT_XML("<read_64Byte value=\"%u\"/>\n",
gcmCOUNTER(gpuTotalRead64BytesPerFrame));
gcmPRINT_XML("<write_64Byte value=\"%u\"/>\n",
gcmCOUNTER(gpuTotalWrite64BytesPerFrame));
gcmPRINT_XML("<gpu_cycles value=\"%u\"/>\n",
gcmCOUNTER(gpuCyclesCounter));
gcmPRINT_XML("<pe_pixel_count_killed_by_color_pipe value=\"%u\"/>\n",
gcmCOUNTER(pe_pixel_count_killed_by_color_pipe));
gcmPRINT_XML("<pe_pixel_count_killed_by_depth_pipe value=\"%u\"/>\n",
gcmCOUNTER(pe_pixel_count_killed_by_depth_pipe));
gcmPRINT_XML("<pe_pixel_count_drawn_by_color_pipe value=\"%u\"/>\n",
gcmCOUNTER(pe_pixel_count_drawn_by_color_pipe));
gcmPRINT_XML("<pe_pixel_count_drawn_by_depth_pipe value=\"%u\"/>\n",
gcmCOUNTER(pe_pixel_count_drawn_by_depth_pipe));
gcmPRINT_XML("<ps_inst_counter value=\"%u\"/>\n",
gcmCOUNTER(ps_inst_counter));
gcmPRINT_XML("<rendered_pixel_counter value=\"%u\"/>\n",
gcmCOUNTER(rendered_pixel_counter));
gcmPRINT_XML("<vs_inst_counter value=\"%u\"/>\n",
gcmCOUNTER(vs_inst_counter));
gcmPRINT_XML("<rendered_vertice_counter value=\"%u\"/>\n",
gcmCOUNTER(rendered_vertice_counter));
gcmPRINT_XML("<vtx_branch_inst_counter value=\"%u\"/>\n",
gcmCOUNTER(vtx_branch_inst_counter));
gcmPRINT_XML("<vtx_texld_inst_counter value=\"%u\"/>\n",
gcmCOUNTER(vtx_texld_inst_counter));
gcmPRINT_XML("<pxl_branch_inst_counter value=\"%u\"/>\n",
gcmCOUNTER(pxl_branch_inst_counter));
gcmPRINT_XML("<pxl_texld_inst_counter value=\"%u\"/>\n",
gcmCOUNTER(pxl_texld_inst_counter));
gcmPRINT_XML("<pa_input_vtx_counter value=\"%u\"/>\n",
gcmCOUNTER(pa_input_vtx_counter));
gcmPRINT_XML("<pa_input_prim_counter value=\"%u\"/>\n",
gcmCOUNTER(pa_input_prim_counter));
gcmPRINT_XML("<pa_output_prim_counter value=\"%u\"/>\n",
gcmCOUNTER(pa_output_prim_counter));
gcmPRINT_XML("<pa_depth_clipped_counter value=\"%u\"/>\n",
gcmCOUNTER(pa_depth_clipped_counter));
gcmPRINT_XML("<pa_trivial_rejected_counter value=\"%u\"/>\n",
gcmCOUNTER(pa_trivial_rejected_counter));
gcmPRINT_XML("<pa_culled_counter value=\"%u\"/>\n",
gcmCOUNTER(pa_culled_counter));
gcmPRINT_XML("<se_culled_triangle_count value=\"%u\"/>\n",
gcmCOUNTER(se_culled_triangle_count));
gcmPRINT_XML("<se_culled_lines_count value=\"%u\"/>\n",
gcmCOUNTER(se_culled_lines_count));
gcmPRINT_XML("<ra_valid_pixel_count value=\"%u\"/>\n",
gcmCOUNTER(ra_valid_pixel_count));
gcmPRINT_XML("<ra_total_quad_count value=\"%u\"/>\n",
gcmCOUNTER(ra_total_quad_count));
gcmPRINT_XML("<ra_valid_quad_count_after_early_z value=\"%u\"/>\n",
gcmCOUNTER(ra_valid_quad_count_after_early_z));
gcmPRINT_XML("<ra_total_primitive_count value=\"%u\"/>\n",
gcmCOUNTER(ra_total_primitive_count));
gcmPRINT_XML("<ra_pipe_cache_miss_counter value=\"%u\"/>\n",
gcmCOUNTER(ra_pipe_cache_miss_counter));
gcmPRINT_XML("<ra_prefetch_cache_miss_counter value=\"%u\"/>\n",
gcmCOUNTER(ra_prefetch_cache_miss_counter));
gcmPRINT_XML("<ra_eez_culled_counter value=\"%u\"/>\n",
gcmCOUNTER(ra_eez_culled_counter));
gcmPRINT_XML("<tx_total_bilinear_requests value=\"%u\"/>\n",
gcmCOUNTER(tx_total_bilinear_requests));
gcmPRINT_XML("<tx_total_trilinear_requests value=\"%u\"/>\n",
gcmCOUNTER(tx_total_trilinear_requests));
gcmPRINT_XML("<tx_total_discarded_texture_requests value=\"%u\"/>\n",
gcmCOUNTER(tx_total_discarded_texture_requests));
gcmPRINT_XML("<tx_total_texture_requests value=\"%u\"/>\n",
gcmCOUNTER(tx_total_texture_requests));
gcmPRINT_XML("<tx_mem_read_count value=\"%u\"/>\n",
gcmCOUNTER(tx_mem_read_count));
gcmPRINT_XML("<tx_mem_read_in_8B_count value=\"%u\"/>\n",
gcmCOUNTER(tx_mem_read_in_8B_count));
gcmPRINT_XML("<tx_cache_miss_count value=\"%u\"/>\n",
gcmCOUNTER(tx_cache_miss_count));
gcmPRINT_XML("<tx_cache_hit_texel_count value=\"%u\"/>\n",
gcmCOUNTER(tx_cache_hit_texel_count));
gcmPRINT_XML("<tx_cache_miss_texel_count value=\"%u\"/>\n",
gcmCOUNTER(tx_cache_miss_texel_count));
gcmPRINT_XML("<mc_total_read_req_8B_from_pipeline value=\"%u\"/>\n",
gcmCOUNTER(mc_total_read_req_8B_from_pipeline));
gcmPRINT_XML("<mc_total_read_req_8B_from_IP value=\"%u\"/>\n",
gcmCOUNTER(mc_total_read_req_8B_from_IP));
gcmPRINT_XML("<mc_total_write_req_8B_from_pipeline value=\"%u\"/>\n",
gcmCOUNTER(mc_total_write_req_8B_from_pipeline));
gcmPRINT_XML("<hi_axi_cycles_read_request_stalled value=\"%u\"/>\n",
gcmCOUNTER(hi_axi_cycles_read_request_stalled));
gcmPRINT_XML("<hi_axi_cycles_write_request_stalled value=\"%u\"/>\n",
gcmCOUNTER(hi_axi_cycles_write_request_stalled));
gcmPRINT_XML("<hi_axi_cycles_write_data_stalled value=\"%u\"/>\n",
gcmCOUNTER(hi_axi_cycles_write_data_stalled));
gcmWRITE_STRING("</HWCounters>\n");
#endif
}
}
/*#endif*/
/* Success. */
gcmFOOTER_NO();
return gcvSTATUS_OK;
}