Screen window metric count types

Graphics and Screen4.0 (8.x)Screen Graphics Subsystem Developer's GuideAPIProgrammingUtilities

Types of metric counts for windows

Synopsis:

#include <screen/screen.h>

enum {
    SCREEN_WINDOW_METRIC_OBJECT_COUNT = 0,
    SCREEN_WINDOW_METRIC_API_COUNT = 1,
    SCREEN_WINDOW_METRIC_DRAW_COUNT = 2,
    SCREEN_WINDOW_METRIC_TRIANGLE_COUNT = 3,
    SCREEN_WINDOW_METRIC_VERTEX_COUNT = 4,
    SCREEN_WINDOW_METRIC_IMAGE_DATA_BYTES = 5,
    SCREEN_WINDOW_METRIC_BUFFER_DATA_BYTES = 6,
    SCREEN_WINDOW_METRIC_EVENT_COUNT = 7,
    SCREEN_WINDOW_METRIC_BLIT_COUNT = 8,
    SCREEN_WINDOW_METRIC_BLIT_PIXELS = 9,
    SCREEN_WINDOW_METRIC_BLIT_READS = 10,
    SCREEN_WINDOW_METRIC_BLIT_WRITES = 11,
    SCREEN_WINDOW_METRIC_POST_COUNT = 12,
    SCREEN_WINDOW_METRIC_POST_PIXELS = 13,
    SCREEN_WINDOW_METRIC_UPDATE_COUNT = 14,
    SCREEN_WINDOW_METRIC_UPDATE_PIXELS = 15,
    SCREEN_WINDOW_METRIC_UPDATE_READS = 16,
    SCREEN_WINDOW_METRIC_UPDATE_WRITES = 17,
    SCREEN_WINDOW_METRIC_CPU_TIME = 18,
    SCREEN_WINDOW_METRIC_GPU_TIME = 19,
    SCREEN_WINDOW_METRIC_VISIBLE_TIME = 20,
    SCREEN_WINDOW_METRIC_FULLY_VISIBLE_TIME = 21
};

Data:

SCREEN_WINDOW_METRIC_OBJECT_COUNT: A general purpose counter whose meaning is defined by SDKs (e.g., WebKit, Adobe AIR, ...).
SCREEN_WINDOW_METRIC_API_COUNT: The number of OpenGL ES 1.X, 2.X, 3.X, and OpenVG API calls that were made by the process owning the window since the last time Screen window metrics were queried.; Note that if multiple processes, other than the one that owns the window, made OpenGL ES 1.X, 2.X, 3.X, OpenVG API calls to the window, these API calls aren't counted.
SCREEN_WINDOW_METRIC_DRAW_COUNT: The number of draw API calls (e.g., glDrawArrays(), glDrawElements(), ...) that were made in the window since the last time Screen window metrics were queried.; This metric isn't counted for OpenVG API calls.
SCREEN_WINDOW_METRIC_TRIANGLE_COUNT: An estimate of the number of triangles drawn in the window since the last time Screen window metrics were queried.; This count is an estimate because two triangles are counted per line and two triangles are also counted per point. This metric isn't counted for OpenVG API calls.
SCREEN_WINDOW_METRIC_VERTEX_COUNT: An estimate of the number of vertices passed to OpenGL in the window since the last time Screen window metrics were queried.; This metric isn't counted for OpenVG API calls.
SCREEN_WINDOW_METRIC_IMAGE_DATA_BYTES: An estimate of the number of bytes requested to upload the texture in the window since the last time Screen window metrics were queried.; This metric isn't counted for OpenVG API calls.
SCREEN_WINDOW_METRIC_BUFFER_DATA_BYTES: An estimate of the number of bytes uploaded to vertex buffers in the window (e.g., from calls such as glBufferData(), glBufferSubData(), ...) since the last time Screen window metrics were queried.; This metric isn't counted for OpenVG API calls.
SCREEN_WINDOW_METRIC_EVENT_COUNT: The number of events that are sent directly to the window since the last time Screen window metrics were queried.; This metric doesn't include events for any child windows that the window may have.
SCREEN_WINDOW_METRIC_BLIT_COUNT: The number of blit requests (when the window was a target of a blit) since the last time Screen window metrics were queried.
SCREEN_WINDOW_METRIC_BLIT_PIXELS: The number of pixels affected by the blit requests (when the window was a target of a blit) since the last time Screen window metrics have been queried.
SCREEN_WINDOW_METRIC_BLIT_READS: An estimate of the number of bytes that have been read from the window since the last time Screen window metrics were queried.; The number of bytes read is an estimation calculated based on the number of pixels affected by the blit requests.
SCREEN_WINDOW_METRIC_BLIT_WRITES: An estimate of the number of bytes that have been written to the window since the last time Screen window metrics were queried.; The number of bytes written is an estimate based on the number of pixels affected by the blit requests.
SCREEN_WINDOW_METRIC_POST_COUNT: The number of times that the window has posted since the last time Screen window metrics were queried.
SCREEN_WINDOW_METRIC_POST_PIXELS: The number of pixels that were marked as dirty in all of the window's posts since the last time Screen window metrics were queried.
SCREEN_WINDOW_METRIC_UPDATE_COUNT: The number of times that the window was in an update since the last time Screen window metrics were queried.; The window must be visible (its SCREEN_PROPERTY_VISIBLE is set) in order for this count to be incremented. If the window is static (i.e., the window property SCREEN_PROPERTY_STATIC is set), this count can still increment if there is another window or layer on top so that there is blending required for this window.
SCREEN_WINDOW_METRIC_UPDATE_PIXELS: The number of pixels that has been used in the updates of the window since the last time Screen window metrics were queried.
SCREEN_WINDOW_METRIC_UPDATE_READS: An estimate of the number of bytes that have been read from the window buffer (if there are multiple buffers, it's the front buffer) since the last time Screen window metrics were queried.; The number of bytes read is an estimate based on the number of pixels affected by the update.
SCREEN_WINDOW_METRIC_UPDATE_WRITES: An estimate of the number of bytes that has been written to the window framebuffer since the last time Screen window metrics have been queried.; The number of bytes written is an estimate based on the number of pixels affected by the update.
SCREEN_WINDOW_METRIC_CPU_TIME: An estimate of the total CPU time (in microseconds) spent preparing updates.; The quantity is estimated by measuring the time between the window timestamp property and the time when screen_post_window() is called. The SCREEN_PROPERTY_TIMESTAMP must be set on the window for this metric to be reliable.
SCREEN_WINDOW_METRIC_GPU_TIME: An estimate of the total GPU time (in microseconds) spent rendering to back buffers.; The quantity is estimated by measuring the time between when eglSwapBuffers() is called and when the post is actually flushed out to the server. This metric is only reliable if the GPU does most of its rendering after eglSwapBuffers() is called.
SCREEN_WINDOW_METRIC_VISIBLE_TIME: An estimate of the total number of nanoseconds for which the window was visible.; The quantity is estimated by measuring the time spent between scene rebuilds where the window is at least partially visible. If the window is covered by another window with transparency, the counter is incremented.
SCREEN_WINDOW_METRIC_FULLY_VISIBLE_TIME: An estimate of the total number of nanoseconds for which the window was fully visible.; The quantity is estimated by measuring the time spent between scene rebuilds where the window is completely visible. If the window is covered by another window with transparency, the counter won't be incremented even though the window may actually be visible.

Library:

libscreen

Description:

The metrics are on a per-window basis, and the counts are reset after being queried. That is, the counts are reset to 0 after you call screen_get_window_property_llv() to retrieve SCREEN_PROPERTY_METRICS.

Page updated: March 05, 2025