Measuring the performance of your Kanzi application

There are several ways to measure the performance of your Kanzi application.

Viewing application performance in Kanzi Studio

To view the performance of your Kanzi application in Kanzi Studio, in the Preview enter the Debug mode and select:

Performance HUD shows the overall performance statistics including:
- Frames per second determines the overall frame rate. See Viewing the frame rate of your application.
- Batch count determines how many individual draw calls were executed (glDrawElements and glDrawArrays).
  You can access the batch count in the API by calling kzcRendererGetBatchCount.
- Triangle count determines how many individual triangles were drawn in total during a frame.
  You can access the triangle count in the API by calling kzcRendererGetTriangleCount.
- Texture switches determine how many times new texture was bound to GPU.
  You can access the texture switch count in the API by calling kzcRendererGetTextureSwitchCount.
- Framebuffer object (FBO) switches determines how many framebuffer objects were bound to GPU. See Rendering best practices.
  You can access the buffer switch count in the API by calling kzcRendererGetFrameBufferSwitchCount.
- Shader switches determine how many times new shader was bound for the newly applied batch. See Reducing shader switches.
  You can access the shader switch count in the API by calling kzcRendererGetShaderSwitchCount.
- Uniforms sent determines how many individual uniforms were sent for the last frame.
  You can access the uniforms sent in the API by calling kzcRendererGetUniformSendCount.
- Buffer switches determines how many vertex, index, and uniform buffer objects were bound to GPU.
  You can access the buffer switch count in the API by calling kzcRendererGetBufferSwitchCount.
- Buffer/texture data updates determines how many times new vertex buffer or texture data was uploaded to GPU.
  You can access the number in the API by calling kzcRendererGetHeavyweightCallCount.
- View camera shows which camera is used for displaying the scene in your application.
- Resource memory consumption shows how much VRAM and RAM the application uses.
- Animation player shows the current time in your application.
Animation HUD shows the animation performance statistics:
- Total time shows the amount of time used per frame for the execution of animation.
- Field Entries shows the amount of time used for the entry tree iteration.
- Samples(n) shows the amount of time used by animation data that consists keyframe interpolation for a single property attribute. The number in parentheses shows how many such animations were iterated.
- Blended(n) shows the amount of time used by animation data under Timeline Entry where Timeline Entry contains Blend Mode other than None. The number in parentheses shows the number of such samples.
- Layout total time shows the amount of time Kanzi Engine used for iterating the layout objects such as grid layout and stack layout.
- Currently running Timeline Entry graph. The smaller the graph, the faster the Kanzi Engine executes. It also shows if the graph has completed entries that still belong to the animation graph.
See Viewing the frame rate of your application and Animations best practices.
Overdraw visualization shows the overdraw of objects in your application. See Preventing overdraw with sorting filters.
Layer render to texture visualization shows whether a layer is rendered into a texture, and causing a framebuffer object (FBO) switch. See Rendering best practices.
Layer is transparent visualization shows transparent layers in your application. See Setting layers for efficient rendering.

Viewing the frame rate of your application

To view the frame rate of your Kanzi application:

In the Kanzi Studio Preview, enter the Debug mode and select Performance HUD.
Enable it in the application framework configuration using
```
configuration->fpsInfoEnabled = KZ_TRUE;
```

Enable it on-the-fly using the kzu_preview_system.h interface.

struct KzuPreviewSystem* previewSystem;

previewSystem = kzaApplicationGetPreviewSystem(application);

result = kzuPreviewSystemEnableFeature(previewSystem,
	KZU_PREVIEW_SYSTEM_FEATURE_HUD);
kzsErrorForward(result);

result = kzuPreviewSystemSetPreviewOptionInteger(previewSystem,
	KZU_PREVIEW_SYSTEM_OPTION_PERFORMANCE_HUD, 1);
kzsErrorForward(result);

To write the frame rate values to a log file, you can retrieve the current frame rate value from the Kanzi Engine by calling kzuEngineGetFramesPerSecond. You can retrieve Kanzi Engine from the application by calling kzaApplicationGetEngine.

In addition to the GPU specific profiling, you can also trigger function call profiling:

configuration->functionCallProfiling = KZ_TRUE;

When enabled, application prints every 100th frame the information from the function call tree and how much time (in milliseconds) specific functions took.

Viewing loading times of resources in your application

Loading times of resources show how much time the loading of resources and the scene graph in the .kzb used by your Kanzi application takes.

To view loading times of resources in your Kanzi application, enable the profiling in the application framework configuration with:

configuration->loadingTimeProfilingEnabled = KZ_TRUE;

Viewing overdraw of objects in your application

Overdraw visualization shows a lot of intensity in areas where fragments are unnecessarily rendered.

To view overdraw of objects in your Kanzi application:

In the Kanzi StudioPreview enter the Debug mode and select Overdraw visualization.
Enable overdraw visualization in application framework configuration with:
```
configuration->overdrawVisualizationEnabled = KZ_TRUE;
```

Viewing animation and layout performance of your application

To view the animation and layout performance of your Kanzi your application:

In Kanzi StudioPreview enter the Debug mode and select Animation HUD.
Enable the visualization in application framework configuration with:
```
configuration->animationVisualizationEnabled = KZ_TRUE;
```

Viewing layers in your application that are rendered into texture

Switching between framebuffer objects can cause significant performance reduction on some platforms. Conditions when Kanzi renders a layer into a texture can be complex. For example, rotation, scale, or opacity can cause render to texture to occur.

To view if a layer is rendered into a texture, and causing a framebuffer object (FBO) switch, in the Preview enter the Debug mode and select Layer render to texture visualization.
The Preview highlights the layers that are rendered into texture with transparent, orange stripes.

Viewing transparent layers in your application

In Kanzi Studio you can see which layers in your applications are transparent, and thus show the content behind them.

To view transparent layers in the Preview enter the Debug mode and select Layer is transparent visualization.
The Preview highlights the transparent areas with transparent, blue stripes.

Note that by default the value of Layer Background Brush Color property of viewport layers is transparent (0, 0, 0, 0), and that the Clear Color does not affect the transparency condition directly.