GL_APICALL void GL_APIENTRY
glGenRenderbuffers(
GLsizei n,
GLuint *renderbuffers
)
{
#if gcdNULL_DRIVER < 3
GLContext context;
GLRenderbuffer renderbuffer;
GLsizei i;
gcmHEADER_ARG("n=%d", n);
context = _glshGetCurrentContext();
if (context == gcvNULL)
{
gcmFOOTER_NO();
return;
}
if (n < 0)
{
gl2mERROR(GL_INVALID_VALUE);
gcmFOOTER_NO();
return;
}
/* Loop while there are renderbuffers to generate. */
for (i = 0; i < n; ++i)
{
/* Create a new renderbuffer. */
renderbuffer = _NewRenderbuffer(context, 0);
if (renderbuffer == gcvNULL)
{
gcmFOOTER_NO();
return;
}
/* Return Renderbuffer name. */
gcmTRACE(gcvLEVEL_VERBOSE,
"glGenRenderbuffers: ==> %u",
renderbuffer->object.name);
renderbuffers[i] = renderbuffer->object.name;
}
gcmDUMP_API("${ES20 glGenRenderbuffers 0x%08X (0x%08X)", n, renderbuffers);
gcmDUMP_API_ARRAY(renderbuffers, n);
gcmDUMP_API("$}");
gcmFOOTER_NO();
#else
while (n-- > 0)
{
*renderbuffers++ = 1;
}
#endif
}
/*******************************************************************************
**
** 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;
}
gceSTATUS
gcoQUEUE_Free(
IN gcoQUEUE Queue
)
{
gcmHEADER_ARG("Queue=0x%x", Queue);
/* Verify the arguments. */
gcmVERIFY_OBJECT(Queue, gcvOBJ_QUEUE);
/* Free any records in the queue. */
#ifdef __QNXNTO__
Queue->head = gcvNULL;
#else
while (Queue->head != gcvNULL)
{
gcsQUEUE_PTR record;
/* Unlink the first record from the queue. */
record = Queue->head;
Queue->head = record->next;
/* Put record on free list. */
record->next = Queue->freeList;
Queue->freeList = record;
}
#endif
/* Update count */
Queue->recordCount = 0;
/* Success. */
gcmFOOTER_NO();
return gcvSTATUS_OK;
}
gceSTATUS
gcoOS_DisplayBufferRegions(
IN HALNativeDisplayType Display,
IN HALNativeWindowType Window,
IN gctINT NumRects,
IN gctINT_PTR Rects
)
{
screen_buffer_t buf[gcdDISPLAY_BACK_BUFFERS];
int rc;
gceSTATUS status = gcvSTATUS_OK;
gcmHEADER_ARG("Display=0x%x Window=0x%x NumRects=%d", Display, Window, NumRects);
rc = screen_get_window_property_pv((screen_window_t)Window, SCREEN_PROPERTY_RENDER_BUFFERS, (void**)buf);
if (rc) {
goto OnError;
}
rc = screen_post_window((screen_window_t)Window, buf[0], NumRects, Rects, 0);
if (rc) {
goto OnError;
}
gcmFOOTER_NO();
return status;
OnError:
status = gcvSTATUS_INVALID_ARGUMENT;
gcmFOOTER();
return status;
}
__fini(
void
)
{
VEGLThreadData thread;
gcmHEADER();
if (initialized)
{
/* Get a pointer to the associated object. */
thread = (VEGLThreadData) pthread_getspecific(key);
if (0 == access(GAL_DEV, F_OK)) {
veglDestroyThreadData(thread);
}
gcmVERIFY_OK(gcoOS_Free(gcvNULL, thread));
pthread_setspecific(key, NULL);
pthread_key_delete(key);
_thread = NULL;
veglDeinitializeGlobalData();
initialized = gcvFALSE;
}
gcmFOOTER_NO();
}
void
vgshRemoveObject(
_VGContext *Context,
_VGObject *Object
)
{
VGuint index;
gcmHEADER_ARG("Context=0x%x Object=0x%x", Context, Object);
index = Object->name % NAMED_OBJECTS_HASH;
if (Object->prev != gcvNULL)
{
Object->prev->next = Object->next;
}
else
{
Context->sharedData->namedObjects[index] = Object->next;
}
if (Object->next != gcvNULL)
{
Object->next->prev = Object->prev;
}
gcmFOOTER_NO();
}
/*******************************************************************************
**
** gcoDUMP_Destroy
**
** Destroy a gcoDUMP object created by gcDUMP_COnstruct.
**
** INPUT:
**
** gcoDUMP Dump
** Pointer to a gcoDUMP object.
**
** OUTPUT:
**
** Nothing.
*/
gceSTATUS
gcoDUMP_Destroy(
IN gcoDUMP Dump
)
{
gcmHEADER_ARG("Dump=0x%x", Dump);
/* Verify the arguments. */
gcmVERIFY_OBJECT(Dump, gcvOBJ_DUMP);
if (Dump->file != gcvNULL)
{
if (Dump->frameStart != 0)
{
gcoDUMP_FrameEnd(Dump);
}
/* Close any open file. */
gcmVERIFY_OK(gcoDUMP_Control(Dump, gcvNULL));
}
if (gcPLS.hal->dump == Dump)
{
/* Remove current gcoDUMP object. */
gcPLS.hal->dump = gcvNULL;
}
/* Free the gcoDUMP structure. */
gcmVERIFY_OK(gcmOS_SAFE_FREE(gcvNULL, Dump));
/* Success. */
gcmFOOTER_NO();
return gcvSTATUS_OK;
}
static void _ClearBindings(
IN gctPOINTER Object
)
{
gctUINT32 i;
/* Cast the object. */
glsBUFFER_PTR object = (glsBUFFER_PTR) Object;
gcmHEADER_ARG("Object=0x%x", Object);
/* Reset the bound target. */
object->bound = gcvFALSE;
object->boundAtLeastOnce = gcvFALSE;
/* Reset bound streams. */
for (i = 0; i < glvTOTALBINDINGS; i++)
{
if (object->binding[i])
{
*object->binding[i] = gcvNULL;
object->binding[i] = gcvNULL;
}
}
gcmFOOTER_NO();
}
gceSTATUS
gcoQUEUE_Destroy(
IN gcoQUEUE Queue
)
{
gceSTATUS status;
gcmHEADER_ARG("Queue=0x%x", Queue);
/* Verify the arguments. */
gcmVERIFY_OBJECT(Queue, gcvOBJ_QUEUE);
#ifndef __QNXNTO__
/* Free any records in the queue. */
while (Queue->head != gcvNULL)
{
gcsQUEUE_PTR record;
/* Unlink the first record from the queue. */
record = Queue->head;
Queue->head = record->next;
gcmONERROR(gcmOS_SAFE_FREE(gcvNULL, record));
}
/* Free any records in the free list. */
while (Queue->freeList != gcvNULL)
{
gcsQUEUE_PTR record;
/* Unlink the first record from the queue. */
record = Queue->freeList;
Queue->freeList = record->next;
gcmONERROR(gcmOS_SAFE_FREE(gcvNULL, record));
}
#else
/* Free any records in the queue. */
if ( Queue->records )
{
gcmVERIFY_OK(gcoOS_FreeNonPagedMemory(gcvNULL,
BUFFER_SIZE,
gcvNULL,
Queue->records));
}
#endif
/* Free the queue. */
gcmONERROR(gcmOS_SAFE_FREE(gcvNULL, Queue));
/* Success. */
gcmFOOTER_NO();
return gcvSTATUS_OK;
OnError:
/* Return the status. */
gcmFOOTER();
return status;
}
gceSTATUS
gcoPROFILER_ShaderVS(
IN gcoHAL Hal,
IN gctPOINTER Vs
)
{
/*#if PROFILE_SHADER_COUNTERS*/
gcmHEADER_ARG("Vs=0x%x", Vs);
if (gcPLS.hal->profiler.enableSH)
{
if (gcPLS.hal->profiler.enable)
{
#if gcdNEW_PROFILER_FILE
gctUINT16 alu = 0, tex = 0, i;
gcSHADER Shader = (gcSHADER)Vs;
/* Profile shader */
for (i = 0; i < Shader->codeCount; i++ )
{
switch (Shader->code[i].opcode)
{
case gcSL_NOP:
break;
case gcSL_TEXLD:
tex++;
break;
default:
alu++;
break;
}
}
gcmWRITE_CONST(VPG_PVS);
gcmWRITE_COUNTER(VPC_PVSINSTRCOUNT, (tex + alu));
gcmWRITE_COUNTER(VPC_PVSALUINSTRCOUNT, alu);
gcmWRITE_COUNTER(VPC_PVSTEXINSTRCOUNT, tex);
gcmWRITE_COUNTER(VPC_PVSATTRIBCOUNT, (Shader->attributeCount));
gcmWRITE_COUNTER(VPC_PVSUNIFORMCOUNT, (Shader->uniformCount));
gcmWRITE_COUNTER(VPC_PVSFUNCTIONCOUNT, (Shader->functionCount));
#else
gcmWRITE_STRING("<VS>\n");
gcoPROFILER_Shader(gcvNULL, (gcSHADER) Vs);
#endif
#if gcdNEW_PROFILER_FILE
gcmWRITE_CONST(VPG_END);
#else
gcmWRITE_STRING("</VS>\n");
#endif
}
}
/*#endif*/
gcmFOOTER_NO();
return gcvSTATUS_OK;
}
/* Call to signal end of frame. */
gceSTATUS
gcoPROFILER_EndFrame(
IN gcoHAL Hal
)
{
gcmHEADER();
gcmFOOTER_NO();
return gcvSTATUS_INVALID_REQUEST;
}
/* Call to signal end of draw. */
gceSTATUS
gcoPROFILER_EndDraw(
IN gcoHAL Hal,
IN gctBOOL FirstDraw
)
{
gcmHEADER();
gcmFOOTER_NO();
return gcvSTATUS_INVALID_REQUEST;
}
/* Profile input fragment shader. */
gceSTATUS
gcoPROFILER_ShaderFS(
IN gcoHAL Hal,
IN gctPOINTER Fs
)
{
gcmHEADER_ARG("Fs=0x%x", Fs);
gcmFOOTER_NO();
return gcvSTATUS_INVALID_REQUEST;
}
gceSTATUS
gcoPROFILER_Count(
IN gcoHAL Hal,
IN gctUINT32 Enum,
IN gctINT Value
)
{
#if PROFILE_HAL_COUNTERS
gcmHEADER_ARG("Enum=%lu Value=%d", Enum, Value);
if (gcPLS.hal->profiler.enable)
{
switch (Enum)
{
case GLINDEX_OBJECT:
gcPLS.hal->profiler.indexBufferNewObjectsAlloc += Value;
gcPLS.hal->profiler.indexBufferTotalObjectsAlloc += Value;
break;
case GLINDEX_OBJECT_BYTES:
gcPLS.hal->profiler.indexBufferNewBytesAlloc += Value;
gcPLS.hal->profiler.indexBufferTotalBytesAlloc += Value;
break;
case GLVERTEX_OBJECT:
gcPLS.hal->profiler.vertexBufferNewObjectsAlloc += Value;
gcPLS.hal->profiler.vertexBufferTotalObjectsAlloc += Value;
break;
case GLVERTEX_OBJECT_BYTES:
gcPLS.hal->profiler.vertexBufferNewBytesAlloc += Value;
gcPLS.hal->profiler.vertexBufferTotalBytesAlloc += Value;
break;
case GLTEXTURE_OBJECT:
gcPLS.hal->profiler.textureBufferNewObjectsAlloc += Value;
gcPLS.hal->profiler.textureBufferTotalObjectsAlloc += Value;
break;
case GLTEXTURE_OBJECT_BYTES:
gcPLS.hal->profiler.textureBufferNewBytesAlloc += Value;
gcPLS.hal->profiler.textureBufferTotalBytesAlloc += Value;
break;
default:
break;
}
}
#endif
gcmFOOTER_NO();
return gcvSTATUS_OK;
}
gceSTATUS
gcoPROFILER_Count(
IN gcoHAL Hal,
IN gctUINT32 Enum,
IN gctINT Value
)
{
gcmHEADER_ARG("Enum=%lu Value=%d", Enum, Value);
gcmFOOTER_NO();
return gcvSTATUS_INVALID_REQUEST;
}
/*******************************************************************************
**
** gcoDUMP_AddSurface
**
** Allocate a surface.
**
** INPUT:
**
** gcoDUMP Dump
** Pointer to a gcoDUMP object.
**
** gctINT32 Width, Height
** Width and height of the surface.
**
** gceSURF_FORMAT PixelFormat
** Pixel format for the surface.
**
** gctUINT32 Address
** Physical address to be used as a handle for the surface.
**
** gctSIZE_T ByteCount
** Number of bytes inside the surface.
**
** OUTPUT:
**
** Nothing.
*/
gceSTATUS
gcoDUMP_AddSurface(
IN gcoDUMP Dump,
IN gctINT32 Width,
IN gctINT32 Height,
IN gceSURF_FORMAT PixelFormat,
IN gctUINT32 Address,
IN gctSIZE_T ByteCount
)
{
gceSTATUS status;
gcsDUMP_SURFACE surface;
gcmHEADER_ARG("Dump=0x%x Width=%d Height=%d PixelFormat=%d Address=%x "
"ByteCount=%d",
Dump, Width, Height, PixelFormat, Address, ByteCount);
/* Verify the arguments. */
gcmVERIFY_OBJECT(Dump, gcvOBJ_DUMP);
gcmVERIFY_ARGUMENT(ByteCount > 0);
if (Dump->file == gcvNULL)
{
/* There is no open dump file. */
gcmFOOTER_NO();
return gcvSTATUS_OK;
}
do
{
/* Write the data record. */
surface.type = gcvTAG_SURFACE;
surface.address = Address;
surface.width = (gctINT16) Width;
surface.height = (gctINT16) Height;
surface.format = PixelFormat;
surface.length = ByteCount;
gcmERR_BREAK(
gcoOS_Write(gcvNULL, Dump->file, sizeof(surface), &surface));
/* Update the frame length. */
Dump->frameLength += sizeof(surface);
/* Update the file length. */
Dump->length += sizeof(surface);
}
while (gcvFALSE);
/* Return the status. */
gcmFOOTER();
return status;
}
/* Write data to profile. */
gceSTATUS
gcoPROFILER_Write(
IN gcoHAL Hal,
IN gctSIZE_T ByteCount,
IN gctCONST_POINTER Data
)
{
gcmHEADER_ARG("ByteCount=%lu Data=0x%x", ByteCount, Data);
gcmFOOTER_NO();
return gcvSTATUS_INVALID_REQUEST;
}
/*******************************************************************************
**
** gcoDUMP_DumpData
**
** Dump data the file.
**
** INPUT:
**
** gcoDUMP Dump
** Pointer to a gcoDUMP object.
**
** gceDUMP_TAG Type
** Type of data.
**
** gctUINT32 Address
** Physical address to be used as a handle for the data.
**
** gctSIZE_T ByteCount
** Number of bytes to write.
**
** gctCONST_POINTER Data
** Pointer to the data to write.
**
** OUTPUT:
**
** Nothing.
*/
gceSTATUS
gcoDUMP_DumpData(
IN gcoDUMP Dump,
IN gceDUMP_TAG Type,
IN gctUINT32 Address,
IN gctSIZE_T ByteCount,
IN gctCONST_POINTER Data
)
{
gceSTATUS status;
gcsDUMP_DATA header;
gcmHEADER_ARG("Dump=0x%x Type=%d Address=%x ByteCount=%d Data=0x%x",
Dump, Type, Address, ByteCount, Data);
/* Verify the arguments. */
gcmVERIFY_OBJECT(Dump, gcvOBJ_DUMP);
gcmVERIFY_ARGUMENT(ByteCount > 0);
gcmVERIFY_ARGUMENT(Data != gcvNULL);
if (Dump->file == gcvNULL)
{
/* There is no open dump file. */
gcmFOOTER_NO();
return gcvSTATUS_OK;
}
do
{
/* Write the data record. */
header.type = Type;
header.length = ByteCount;
header.address = Address;
gcmERR_BREAK(
gcoOS_Write(gcvNULL, Dump->file, sizeof(header), &header));
/* Write the data. */
gcmERR_BREAK(gcoOS_Write(gcvNULL, Dump->file, ByteCount, Data));
/* Update the frame length. */
Dump->frameLength += sizeof(header) + ByteCount;
/* Update the file length. */
Dump->length += sizeof(header) + ByteCount;
}
while (gcvFALSE);
/* Return the status. */
gcmFOOTER();
return status;
}
/*******************************************************************************
**
** gcoDUMP_FrameEnd
**
** Mark the end of a frame.
**
** INPUT:
**
** gcoDUMP Dump
** Pointer to a gcoDUMP object.
**
** OUTPUT:
**
** Nothing.
*/
gceSTATUS
gcoDUMP_FrameEnd(
IN gcoDUMP Dump
)
{
gceSTATUS status;
gcsDUMP_DATA header;
gctUINT32 pos;
gcmHEADER_ARG("Dump=0x%x", Dump);
/* Verify the arguments. */
gcmVERIFY_OBJECT(Dump, gcvOBJ_DUMP);
if (Dump->file == gcvNULL)
{
/* There is no open dump file. */
gcmFOOTER_NO();
return gcvSTATUS_OK;
}
do
{
/* Get the current position. */
gcmERR_BREAK(gcoOS_GetPos(gcvNULL, Dump->file, &pos));
/* Seek to the beginning of the frame. */
gcmERR_BREAK(gcoOS_SetPos(gcvNULL, Dump->file, Dump->frameStart));
/* Make sure we got the right byte count. */
gcmASSERT(pos - Dump->frameStart == Dump->frameLength + sizeof(header));
/* Update the frame header. */
header.type = gcvTAG_FRAME;
header.length = Dump->frameLength;
header.address = ++ Dump->frameCount;
gcmERR_BREAK(gcoOS_Write(gcvNULL, Dump->file, sizeof(header), &header));
/* Seek to the end of the file. */
gcmERR_BREAK(gcoOS_SetPos(gcvNULL, Dump->file, pos));
/* Mark the frame as ended. */
Dump->frameStart = 0;
}
while (gcvFALSE);
/* Return the status. */
gcmFOOTER();
return status;
}
/*******************************************************************************
**
** gcoDUMP_SetDumpFlag
**
** Enabel dump or not
**
** INPUT:
**
** gctBOOL DumpState
** Dump state to set.
**
** OUTPUT:
**
** Nothing.
*/
gceSTATUS
gcoDUMP_SetDumpFlag(
IN gctBOOL DumpState
)
{
gcmHEADER_ARG("DumpState=%d", DumpState);
setDumpFlag = DumpState;
/* Success. */
gcmFOOTER_NO();
return gcvSTATUS_OK;
}
gceSTATUS
gcoPROFILER_Shader(
IN gcoHAL Hal,
IN gcSHADER Shader
)
{
/*#if PROFILE_SHADER_COUNTERS*/
gcmHEADER_ARG("Shader=0x%x", Shader);
if (gcPLS.hal->profiler.enableSH)
{
gctUINT16 alu = 0, tex = 0, i;
if (gcPLS.hal->profiler.enable)
{
/* Profile shader */
for (i = 0; i < Shader->codeCount; i++ )
{
switch (Shader->code[i].opcode)
{
case gcSL_NOP:
break;
case gcSL_TEXLD:
tex++;
break;
default:
alu++;
break;
}
}
gcmPRINT_XML("<InstructionCount value=\"%d\"/>\n", tex + alu);
gcmPRINT_XML("<ALUInstructionCount value=\"%d\"/>\n", alu);
gcmPRINT_XML("<TextureInstructionCount value=\"%d\"/>\n", tex);
gcmPRINT_XML("<Attributes value=\"%lu\"/>\n", Shader->attributeCount);
gcmPRINT_XML("<Uniforms value=\"%lu\"/>\n", Shader->uniformCount);
gcmPRINT_XML("<Functions value=\"%lu\"/>\n", Shader->functionCount);
}
/*#endif*/
}
gcmFOOTER_NO();
return gcvSTATUS_OK;
}
gceSTATUS
gcoOS_SetDisplayVirtual(
IN HALNativeDisplayType Display,
IN HALNativeWindowType Window,
IN gctUINT Offset,
IN gctINT X,
IN gctINT Y
)
{
screen_buffer_t buf[gcdDISPLAY_BACK_BUFFERS];
int rc;
int rects[4];
gceSTATUS status = gcvSTATUS_OK;
gcmHEADER_ARG("Display=0x%x Window=0x%x Offset=%u X=%d Y=%d", Display, Window, Offset, X, Y);
rects[0] = 0;
rects[1] = 0;
rc = screen_get_window_property_pv((screen_window_t)Window, SCREEN_PROPERTY_RENDER_BUFFERS, (void**)buf);
if (rc)
{
goto OnError;
}
rc = screen_get_window_property_iv((screen_window_t)Window, SCREEN_PROPERTY_BUFFER_SIZE, &rects[2]);
if (rc)
{
goto OnError;
}
rc = screen_post_window((screen_window_t)Window, buf[0], 1, rects, 0);
if (rc)
{
goto OnError;
}
_ReleaseWindowInfoNode(Window);
gcmFOOTER_NO();
return status;
OnError:
status = gcvSTATUS_INVALID_ARGUMENT;
gcmFOOTER();
return status;
}
/*******************************************************************************
**
** gcoDUMP_Delete
**
** Mark an address as deleted.
**
** INPUT:
**
** gcoDUMP Dump
** Pointer to a gcoDUMP object.
**
** gctUINT32 Address
** Physical address to delete.
**
** OUTPUT:
**
** Nothing.
*/
gceSTATUS
gcoDUMP_Delete(
IN gcoDUMP Dump,
IN gctUINT32 Address
)
{
gceSTATUS status;
gcsDUMP_DATA header;
gcmHEADER_ARG("Dump=0x%x Address=%x", Dump, Address);
/* Verify the arguments. */
gcmVERIFY_OBJECT(Dump, gcvOBJ_DUMP);
if (Dump->file == gcvNULL)
{
/* There is no open dump file. */
gcmFOOTER_NO();
return gcvSTATUS_OK;
}
do
{
/* Write the delete record. */
header.type = gcvTAG_DELETE;
header.length = 0;
header.address = Address;
gcmERR_BREAK(
gcoOS_Write(gcvNULL, Dump->file, sizeof(header), &header));
/* Update the frame length. */
Dump->frameLength += sizeof(header);
/* Update the file length. */
Dump->length += sizeof(header);
}
while (gcvFALSE);
/* Return the status. */
gcmFOOTER();
return status;
}
gceSTATUS
gcoQUEUE_Commit(
IN gcoQUEUE Queue
)
{
gceSTATUS status = gcvSTATUS_OK;
gcsHAL_INTERFACE iface;
gcmHEADER_ARG("Queue=0x%x", Queue);
/* Verify the arguments. */
gcmVERIFY_OBJECT(Queue, gcvOBJ_QUEUE);
if (Queue->head != gcvNULL)
{
/* Initialize event commit command. */
iface.command = gcvHAL_EVENT_COMMIT;
iface.u.Event.queue = Queue->head;
/* Send command to kernel. */
gcmONERROR(
gcoOS_DeviceControl(gcvNULL,
IOCTL_GCHAL_INTERFACE,
&iface, gcmSIZEOF(iface),
&iface, gcmSIZEOF(iface)));
/* Test for error. */
gcmONERROR(iface.status);
/* Free any records in the queue. */
gcmONERROR(gcoQUEUE_Free(Queue));
}
/* Success. */
gcmFOOTER_NO();
return gcvSTATUS_OK;
OnError:
/* Return the status. */
gcmFOOTER();
return status;
}
/*******************************************************************************
**
** gcoDUMP_FrameBegin
**
** Mark the beginning of a frame.
**
** INPUT:
**
** gcoDUMP Dump
** Pointer to a gcoDUMP object.
**
** OUTPUT:
**
** Nothing.
*/
gceSTATUS
gcoDUMP_FrameBegin(
IN gcoDUMP Dump
)
{
gceSTATUS status;
gcsDUMP_DATA header;
gcmHEADER_ARG("Dump=0x%x", Dump);
/* Verify the arguments. */
gcmVERIFY_OBJECT(Dump, gcvOBJ_DUMP);
if ( (Dump->file == gcvNULL) || (Dump->frameStart != 0) )
{
/* There is no open dump file. */
gcmFOOTER_NO();
return gcvSTATUS_OK;
}
do
{
/* Get the current position. */
gcmERR_BREAK(gcoOS_GetPos(gcvNULL, Dump->file, &Dump->frameStart));
/* Write the frame header. */
header.type = gcvTAG_FRAME;
header.length = Dump->frameLength = 0;
header.address = 0;
gcmERR_BREAK(gcoOS_Write(gcvNULL, Dump->file, sizeof(header), &header));
/* Update the file length. */
Dump->length += sizeof(header);
}
while (gcvFALSE);
/* Return the status. */
gcmFOOTER();
return status;
}
static void
_DestroyThreadData(
gcsTLS_PTR TLS
)
{
gcmHEADER_ARG("TLS=0x%x", TLS);
if (TLS->context != gcvNULL)
{
/*VEGLThreadData thread;*/
VEGLDisplay head;
/*thread = (VEGLThreadData) TLS->context;*/
head = (VEGLDisplay) gcoOS_GetPLSValue(gcePLS_VALUE_EGL_DISPLAY_INFO);
while (head != EGL_NO_DISPLAY)
{
VEGLDisplay display = head;
if (display->ownerThread == gcoOS_GetCurrentThreadID())
{
/* This thread has not eglTerminated the display.*/
eglTerminate(display);
}
head = display->next;
if (TLS->ProcessExiting)
{
gcmVERIFY_OK(gcmOS_SAFE_FREE(gcvNULL, display));
gcoOS_SetPLSValue(gcePLS_VALUE_EGL_DISPLAY_INFO, (gctPOINTER) head);
}
}
TLS->context = gcvNULL;
}
gcmFOOTER_NO();
}
static void
veglThreadDestructor(
void * Thread
)
{
gcmHEADER_ARG("Thread=0x%x", Thread);
pthread_setspecific(key, Thread);
if (Thread != NULL)
{
veglDestroyThreadData(Thread);
gcmVERIFY_OK(gcoOS_Free(gcvNULL, Thread));
if (_thread == Thread) _thread = NULL;
}
pthread_setspecific(key, NULL);
gcmFOOTER_NO();
}
gceSTATUS
gcoPROFILER_Destroy(
IN gcoHAL Hal
)
{
gcmHEADER();
if (gcPLS.hal->profiler.enable == 1)
{
#if gcdNEW_PROFILER_FILE
gcmWRITE_CONST(VPG_END);
#else
gcmWRITE_STRING("</VProfile>\n");
#endif
gcoPROFILER_Flush(gcvNULL);
if (gcPLS.hal->profiler.useSocket)
{
/* Close the socket. */
gcmVERIFY_OK(gcoOS_CloseSocket(gcvNULL, gcPLS.hal->profiler.sockFd));
}
else
{
/* Close the profiler file. */
gcmVERIFY_OK(gcoOS_Close(gcvNULL, gcPLS.hal->profiler.file));
}
gcPLS.hal->profiler.enable = 0;
}
else
{
gcPLS.hal->profiler.enable--;
}
gcmFOOTER_NO();
return gcvSTATUS_OK;
}
/*******************************************************************************
**
** gcoBUFFER_Commit
**
** Commit the command buffer to the hardware.
**
** INPUT:
**
** gcoBUFFER Buffer
** Pointer to a gcoBUFFER object.
**
** gcePIPE_SELECT CurrentPipe
** Current graphics pipe.
**
** gcsSTATE_DELTA_PTR StateDelta
** Pointer to the state delta.
**
** gcoQUEUE Queue
** Pointer to a gcoQUEUE object.
**
** OUTPUT:
**
** Nothing.
*/
gceSTATUS
gcoBUFFER_Commit(
IN gcoBUFFER Buffer,
IN gcePIPE_SELECT CurrentPipe,
IN gcsSTATE_DELTA_PTR StateDelta,
IN gcoQUEUE Queue
)
{
gcsHAL_INTERFACE iface;
gceSTATUS status;
gcoCMDBUF current;
gcmHEADER_ARG("Buffer=0x%x Queue=0x%x",
Buffer, Queue);
/* Verify the arguments. */
gcmVERIFY_OBJECT(Buffer, gcvOBJ_BUFFER);
gcmVERIFY_OBJECT(Queue, gcvOBJ_QUEUE);
/* Grab current command buffer. */
current = Buffer->currentCommandBuffer;
if (current == gcvNULL)
{
/* No command buffer, done. */
gcmFOOTER_NO();
return gcvSTATUS_OK;
}
if (current->offset - current->startOffset <= Buffer->info.reservedHead)
{
/* Commit the event queue. */
status = gcoQUEUE_Commit(Queue);
gcmFOOTER();
return status;
}
/* Make sure the tail got aligned properly. */
current->offset = gcmALIGN(current->offset, Buffer->info.alignment);
if (gcPLS.hal->dump != gcvNULL)
{
/* Dump the command buffer. */
gcmVERIFY_OK(
gcoDUMP_DumpData(gcPLS.hal->dump,
gcvTAG_COMMAND,
0,
current->offset
- current->startOffset
- Buffer->info.reservedHead,
(gctUINT8_PTR) current->logical
+ current->startOffset
+ Buffer->info.reservedHead));
}
/* The current pipe becomes the exit pipe for the current command buffer. */
current->exitPipe = CurrentPipe;
/* Send command and context buffer to hardware. */
iface.command = gcvHAL_COMMIT;
iface.u.Commit.context =
#ifndef VIVANTE_NO_3D
(current->using2D && !current->using3D) ? gcvNULL : Buffer->context;
#else
gcvNULL;
#endif
iface.u.Commit.commandBuffer = current;
iface.u.Commit.delta = StateDelta;
iface.u.Commit.queue = Queue->head;
/* Call kernel service. */
gcmONERROR(
gcoOS_DeviceControl(gcvNULL,
IOCTL_GCHAL_INTERFACE,
&iface, gcmSIZEOF(iface),
&iface, gcmSIZEOF(iface)));
gcmONERROR(iface.status);
/* Free the event queue. */
gcmONERROR(gcoQUEUE_Free(Queue));
/* Advance the offset for next commit. */
current->startOffset = current->offset + Buffer->info.reservedTail;
if (current->bytes - current->startOffset > Buffer->totalReserved)
{
/* Adjust buffer offset and size. */
current->offset = current->startOffset + Buffer->info.reservedHead;
current->free = current->bytes - current->offset
- Buffer->info.alignment
- Buffer->info.reservedTail;
}
else
{
/* Buffer is full. */
current->startOffset = current->bytes;
current->offset = current->bytes;
current->free = 0;
}
/* The exit pipe becomes the entry pipe for the next command buffer. */
current->entryPipe = current->exitPipe;
#if gcdSECURE_USER
/* Reset the state array tail. */
current->hintArrayTail = current->hintArray;
#endif
/* Reset usage flags. */
current->using2D = gcvFALSE;
current->using3D = gcvFALSE;
current->usingFilterBlit = gcvFALSE;
current->usingPalette = gcvFALSE;
/* Success. */
gcmFOOTER_NO();
return gcvSTATUS_OK;
OnError:
/* Return the status. */
gcmFOOTER();
return status;
}
/*#endif*/
gcmFOOTER_NO();
return gcvSTATUS_OK;
}
#endif /* vivante_no_3d */
gceSTATUS
gcoPROFILER_EndFrame(
IN gcoHAL Hal
)
{
/*#if (PROFILE_HAL_COUNTERS || PROFILE_HW_COUNTERS)*/
gcsHAL_INTERFACE iface;
gceSTATUS status;
/*#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
gcmWRITE_CONST(VPG_HAL);
gcmWRITE_COUNTER(VPC_HALVERTBUFNEWBYTEALLOC, gcPLS.hal->profiler.vertexBufferNewBytesAlloc);
gcmWRITE_COUNTER(VPC_HALVERTBUFTOTALBYTEALLOC, gcPLS.hal->profiler.vertexBufferTotalBytesAlloc);
gcmWRITE_COUNTER(VPC_HALVERTBUFNEWOBJALLOC, gcPLS.hal->profiler.vertexBufferNewObjectsAlloc);
gcmWRITE_COUNTER(VPC_HALVERTBUFTOTALOBJALLOC, gcPLS.hal->profiler.vertexBufferTotalObjectsAlloc);
gcmWRITE_COUNTER(VPC_HALINDBUFNEWBYTEALLOC, gcPLS.hal->profiler.indexBufferNewBytesAlloc);
gcmWRITE_COUNTER(VPC_HALINDBUFTOTALBYTEALLOC, gcPLS.hal->profiler.indexBufferTotalBytesAlloc);
gcmWRITE_COUNTER(VPC_HALINDBUFNEWOBJALLOC, gcPLS.hal->profiler.indexBufferNewObjectsAlloc);
gcmWRITE_COUNTER(VPC_HALINDBUFTOTALOBJALLOC, gcPLS.hal->profiler.indexBufferTotalObjectsAlloc);
gcmWRITE_COUNTER(VPC_HALTEXBUFNEWBYTEALLOC, gcPLS.hal->profiler.textureBufferNewBytesAlloc);
gcmWRITE_COUNTER(VPC_HALTEXBUFTOTALBYTEALLOC, gcPLS.hal->profiler.textureBufferTotalBytesAlloc);
gcmWRITE_COUNTER(VPC_HALTEXBUFNEWOBJALLOC, gcPLS.hal->profiler.textureBufferNewObjectsAlloc);
gcmWRITE_COUNTER(VPC_HALTEXBUFTOTALOBJALLOC, gcPLS.hal->profiler.textureBufferTotalObjectsAlloc);
gcmWRITE_CONST(VPG_END);
#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. */
gcPLS.hal->profiler.vertexBufferNewBytesAlloc = 0;
gcPLS.hal->profiler.vertexBufferNewObjectsAlloc = 0;
gcPLS.hal->profiler.indexBufferNewBytesAlloc = 0;
gcPLS.hal->profiler.indexBufferNewObjectsAlloc = 0;
gcPLS.hal->profiler.textureBufferNewBytesAlloc = 0;
gcPLS.hal->profiler.textureBufferNewObjectsAlloc = 0;
}
/*#endif*/
/*#if PROFILE_HW_COUNTERS*/
/* gcvHAL_READ_ALL_PROFILE_REGISTERS. */
if (gcPLS.hal->profiler.enableHW)
{
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 gcmCOUNTER(name) iface.u.RegisterProfileData.counters.name
#if gcdNEW_PROFILER_FILE
gcmWRITE_CONST(VPG_HW);
gcmWRITE_CONST(VPG_GPU);
gcmWRITE_COUNTER(VPC_GPUREAD64BYTE, gcmCOUNTER(gpuTotalRead64BytesPerFrame));
gcmWRITE_COUNTER(VPC_GPUWRITE64BYTE, gcmCOUNTER(gpuTotalWrite64BytesPerFrame));
gcmWRITE_COUNTER(VPC_GPUCYCLES, gcmCOUNTER(gpuCyclesCounter));
gcmWRITE_CONST(VPG_END);
gcmWRITE_CONST(VPG_VS);
gcmWRITE_COUNTER(VPC_VSINSTCOUNT, gcmCOUNTER(vs_inst_counter) - gcPLS.hal->profiler.prevVSInstCount);
gcmWRITE_COUNTER(VPC_VSBRANCHINSTCOUNT, gcmCOUNTER(vtx_branch_inst_counter) - gcPLS.hal->profiler.prevVSBranchInstCount);
gcmWRITE_COUNTER(VPC_VSTEXLDINSTCOUNT, gcmCOUNTER(vtx_texld_inst_counter) - gcPLS.hal->profiler.prevVSTexInstCount);
gcmWRITE_COUNTER(VPC_VSRENDEREDVERTCOUNT, gcmCOUNTER(rendered_vertice_counter) - gcPLS.hal->profiler.prevVSVertexCount);
gcmWRITE_CONST(VPG_END);
gcPLS.hal->profiler.prevVSInstCount = gcmCOUNTER(vs_inst_counter);
gcPLS.hal->profiler.prevVSBranchInstCount = gcmCOUNTER(vtx_branch_inst_counter);
gcPLS.hal->profiler.prevVSTexInstCount = gcmCOUNTER(vtx_texld_inst_counter);
gcPLS.hal->profiler.prevVSVertexCount = gcmCOUNTER(rendered_vertice_counter);
gcmWRITE_CONST(VPG_PA);
gcmWRITE_COUNTER(VPC_PAINVERTCOUNT, gcmCOUNTER(pa_input_vtx_counter));
gcmWRITE_COUNTER(VPC_PAINPRIMCOUNT, gcmCOUNTER(pa_input_prim_counter));
gcmWRITE_COUNTER(VPC_PAOUTPRIMCOUNT, gcmCOUNTER(pa_output_prim_counter));
gcmWRITE_COUNTER(VPC_PADEPTHCLIPCOUNT, gcmCOUNTER(pa_depth_clipped_counter));
gcmWRITE_COUNTER(VPC_PATRIVIALREJCOUNT, gcmCOUNTER(pa_trivial_rejected_counter));
gcmWRITE_COUNTER(VPC_PACULLCOUNT, gcmCOUNTER(pa_culled_counter));
gcmWRITE_CONST(VPG_END);
gcmWRITE_CONST(VPG_SETUP);
gcmWRITE_COUNTER(VPC_SETRIANGLECOUNT, gcmCOUNTER(se_culled_triangle_count));
gcmWRITE_COUNTER(VPC_SELINECOUNT, gcmCOUNTER(se_culled_lines_count));
gcmWRITE_CONST(VPG_END);
gcmWRITE_CONST(VPG_RA);
gcmWRITE_COUNTER(VPC_RAVALIDPIXCOUNT, gcmCOUNTER(ra_valid_pixel_count));
gcmWRITE_COUNTER(VPC_RATOTALQUADCOUNT, gcmCOUNTER(ra_total_quad_count));
gcmWRITE_COUNTER(VPC_RAVALIDQUADCOUNTEZ, gcmCOUNTER(ra_valid_quad_count_after_early_z));
gcmWRITE_COUNTER(VPC_RATOTALPRIMCOUNT, gcmCOUNTER(ra_total_primitive_count));
gcmWRITE_COUNTER(VPC_RAPIPECACHEMISSCOUNT, gcmCOUNTER(ra_pipe_cache_miss_counter));
gcmWRITE_COUNTER(VPC_RAPREFCACHEMISSCOUNT, gcmCOUNTER(ra_prefetch_cache_miss_counter));
gcmWRITE_COUNTER(VPC_RAEEZCULLCOUNT, gcmCOUNTER(ra_eez_culled_counter));
gcmWRITE_CONST(VPG_END);
gcmWRITE_CONST(VPG_TX);
gcmWRITE_COUNTER(VPC_TXTOTBILINEARREQ, gcmCOUNTER(tx_total_bilinear_requests));
gcmWRITE_COUNTER(VPC_TXTOTTRILINEARREQ, gcmCOUNTER(tx_total_trilinear_requests));
gcmWRITE_COUNTER(VPC_TXTOTTEXREQ, gcmCOUNTER(tx_total_texture_requests));
gcmWRITE_COUNTER(VPC_TXMEMREADCOUNT, gcmCOUNTER(tx_mem_read_count));
gcmWRITE_COUNTER(VPC_TXMEMREADIN8BCOUNT, gcmCOUNTER(tx_mem_read_in_8B_count));
gcmWRITE_COUNTER(VPC_TXCACHEMISSCOUNT, gcmCOUNTER(tx_cache_miss_count));
gcmWRITE_COUNTER(VPC_TXCACHEHITTEXELCOUNT, gcmCOUNTER(tx_cache_hit_texel_count));
gcmWRITE_COUNTER(VPC_TXCACHEMISSTEXELCOUNT, gcmCOUNTER(tx_cache_miss_texel_count));
gcmWRITE_CONST(VPG_END);
gcmWRITE_CONST(VPG_PS);
gcmWRITE_COUNTER(VPC_PSINSTCOUNT, gcmCOUNTER(ps_inst_counter) - gcPLS.hal->profiler.prevPSInstCount);
gcmWRITE_COUNTER(VPC_PSBRANCHINSTCOUNT, gcmCOUNTER(pxl_branch_inst_counter) - gcPLS.hal->profiler.prevPSBranchInstCount);
gcmWRITE_COUNTER(VPC_PSTEXLDINSTCOUNT, gcmCOUNTER(pxl_texld_inst_counter) - gcPLS.hal->profiler.prevPSTexInstCount);
gcmWRITE_COUNTER(VPC_PSRENDEREDPIXCOUNT, gcmCOUNTER(rendered_pixel_counter) - gcPLS.hal->profiler.prevPSPixelCount);
gcmWRITE_CONST(VPG_END);
gcPLS.hal->profiler.prevPSInstCount = gcmCOUNTER(ps_inst_counter);
gcPLS.hal->profiler.prevPSBranchInstCount = gcmCOUNTER(pxl_branch_inst_counter);
gcPLS.hal->profiler.prevPSTexInstCount = gcmCOUNTER(pxl_texld_inst_counter);
gcPLS.hal->profiler.prevPSPixelCount = gcmCOUNTER(rendered_pixel_counter);
gcmWRITE_CONST(VPG_PE);
gcmWRITE_COUNTER(VPC_PEKILLEDBYCOLOR, gcmCOUNTER(pe_pixel_count_killed_by_color_pipe));
gcmWRITE_COUNTER(VPC_PEKILLEDBYDEPTH, gcmCOUNTER(pe_pixel_count_killed_by_depth_pipe));
gcmWRITE_COUNTER(VPC_PEDRAWNBYCOLOR, gcmCOUNTER(pe_pixel_count_drawn_by_color_pipe));
gcmWRITE_COUNTER(VPC_PEDRAWNBYDEPTH, gcmCOUNTER(pe_pixel_count_drawn_by_depth_pipe));
gcmWRITE_CONST(VPG_END);
gcmWRITE_CONST(VPG_MC);
gcmWRITE_COUNTER(VPC_MCREADREQ8BPIPE, gcmCOUNTER(mc_total_read_req_8B_from_pipeline));
gcmWRITE_COUNTER(VPC_MCREADREQ8BIP, gcmCOUNTER(mc_total_read_req_8B_from_IP));
gcmWRITE_COUNTER(VPC_MCWRITEREQ8BPIPE, gcmCOUNTER(mc_total_write_req_8B_from_pipeline));
gcmWRITE_CONST(VPG_END);
gcmWRITE_CONST(VPG_AXI);
gcmWRITE_COUNTER(VPC_AXIREADREQSTALLED, gcmCOUNTER(hi_axi_cycles_read_request_stalled));
gcmWRITE_COUNTER(VPC_AXIWRITEREQSTALLED, gcmCOUNTER(hi_axi_cycles_write_request_stalled));
gcmWRITE_COUNTER(VPC_AXIWRITEDATASTALLED, gcmCOUNTER(hi_axi_cycles_write_data_stalled));
gcmWRITE_CONST(VPG_END);
gcmWRITE_CONST(VPG_END);
#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;
}
