Introduction

In the world of mobile app development, ensuring a smooth and seamless user experience is crucial. Two critical performance metrics that can significantly impact user experience are jank and stutter. In this article, we will dive deep into understanding jank and stutter, their causes, how to calculate them, and how tools like PerfDog can help developers identify and address these performance issues effectively.

Understanding Jank

Jank refers to the disruptions in an app's UI smoothness, caused by the app's inability to render frames in sync with the device's screen refresh rate. On a 60Hz screen, the ideal frame rendering time is 16ms (1 second / 60 frames). When an app takes longer than 16ms to render a frame, it misses the screen's refresh cycle, causing a noticeable pause or jump in the UI. This disruption in smoothness is called jank.

Causes of Jank

Jank can be caused by various factors, including:

● Complex UI elements: If the app's UI is too complex or contains many elements, rendering a frame might take longer than the ideal 16ms.

● Resource-intensive operations: Heavy computations or operations, like loading large images or running complex animations, can slow down frame rendering.

● Garbage collection: Inefficient memory management can lead to garbage collection events, causing the app to pause momentarily while freeing up memory.

● Main thread blocking: Running resource-intensive tasks on the main thread can block UI updates, leading to jank.

Understanding Stutter

While jank refers to individual instances of frame rendering delays, stutter is a term used to describe the uneven distribution of frame rendering times. An app can achieve a high average FPS (frames per second) but still appear choppy to the user if the frame rendering times vary significantly. This unevenness in frame rendering times is called stutter.

Causes of Stutter

Stutter can be caused by factors such as:

● Variable workload: If the app's workload varies significantly between frames, it can lead to uneven frame rendering times.

● Inefficient code: Poorly optimized code can cause some frames to take longer to render than others.

● Synchronization issues: If the app relies on multiple threads or processes that need to synchronize, it can cause delays in frame rendering times.

Calculating Jank and Stutter

To calculate jank, you can analyze the frame rendering times and identify frames that took longer than the screen's refresh cycle (e.g., 16ms for a 60Hz screen) to render. The jank rate can be calculated by dividing the number of janky frames by the total number of frames.

In PerfDog's Jank analysis, FrameTime plays a crucial role in calculating Jank. Here's how it works:

1. Visual Inertia and Average FrameTime: PerfDog takes into account visual inertia and the average FrameTime of the previous three frames. Visual inertia refers to the expected FPS based on the current FPS. If the refresh FPS suddenly drops, it will disturb the user's visual inertia, leading to a Jank experience.

2. Calculating Jank: If the FrameTime of the next frame is longer than twice the average FrameTime of the previous three frames, it is considered a potential Jank.

3. Real Jank and Big Jank: If the FrameTime of a single frame is longer than twice the movie FrameTime (1000ms/24*2), it is considered a real Jank. If the FrameTime of a single frame is longer than three times the movie FrameTime, it is considered a Big Jank.

4. Stutter Calculation: Stutter, which is the proportion of Jank time during testing, is also calculated based on FrameTime. It is calculated as the sum of Jank times divided by the total test duration.

● Google-Jank:

● PerfDog-Jank:

● Jank calculation by really testing FrameTime

● PerfDog-Jank

PerfDog's Stutter is defined as the proportion of Jank time during testing, calculated as the sum of all Jank times divided by the total test duration. This measure provides a comprehensive view of the overall performance of your application or game, as it takes into account all instances of Jank that occur during testing.

Here's how PerfDog calculates Stutter:

1. Jank Time: Each instance of Jank has a corresponding Jank time, which is the duration of that specific performance hiccup.

2. Multiple Janks: During testing, multiple instances of Jank may occur, each with their own Jank times.

3. Total Test Duration: This is the total time span of the testing session.

4. Stutter Calculation: Stutter is calculated as the sum of all Jank times (∑Jank time) divided by the total test duration (Time).

                                                                  Stutter = ∑Jank time / Time

It's important to note that while Jank indicates the number of times performance hiccups occur (Jank times), Stutter represents the rate of these hiccups (Jank rate). The trends of Jank and Stutter are generally consistent, but not completely linear, as the severity of Jank can vary at different times. If no Jank occurs, the Stutter will be zero, indicating a smooth and seamless user experience.

● Performance of some mainstream games: