![]() ![]() If not, is it worth changing? Will it make the game play smoother? Has the game been tested on multiple platforms? The Intel® GPA tools help you see what is going on so that you can make smart decisions. Now is the time to go to the architect and developers to find out if there is a reason for this. So this is a case where looking at a single frame could be misleading because it doesn’t tell the bigger picture. See how the frames actually take the same amount of time to process in the CPU, but if you only look at start and end time for each frame, it looks like frame number one takes 2.5x longer to process than frames 2 and 3 (5:18) because, for frame 1, the wait time is aggregated along with the processing time. Because the CPU was waiting, it is not ready with more work for the GPU. ![]() The CPU does all preprocessing for a triplet of frames (frame 1, frame 2, frame 3,) then waits until the GPU renders those three frames before it starts processing the next three frames. This means that, for some reason, the CPU and GPU are synchronized.The activity line is green at the beginning of the wait when it is being initialized, then the thread does nothing until it hears back from the GPU signal where it is again green. You can see that it is inactive while it is waiting by the absence of the green activity line over the thread track. We also see that the CPU thread-the one that is the main rendering thread the one that is responsible for scheduling and execution of all graphics work-is inactive.We see that the frames are rendered in triplets: frame1, frame2, frame3, then the GPU waits, then another frame1, frame2, and frame3, and so on.But maybe there is a reason for the Wait. But typically, the CPU sends data and instructions to the GPU, and the CPU then goes on with more processing while the GPU is working. Sometimes a job has to wait for some other job to finish before it can continue. So did the CPU just hang out waiting? Hmm. What does that tell us? Well, the CPU told the GPU that it would be waiting to hear back when the GPU finished processing something. This takes us to a WaitForSingleObject call in the main CPU thread. So we follow the green arrow to see what the GPU is signaling. It’s a signal, which means something in the process is waiting for the GPU to signal that it finished something. Let’s look at the preceding package in the UMD driver queue. Following the orange arrow backwards, we find that our initial render package depends on the render package shown here in the UMD driver queue, where we find the same gap. Then we will trace backwards in the call stack to find out what the GPU package is waiting for. Let’s click on the first render execution package after a gap. Zooming in, we see several gaps in the rendering queue. So let’s look at the CPU cores and the GPU rendering queue. Or we might find gaps in CPU or GPU usage, leading us to look for how we can better balance the load.įirst, we check for bottlenecks, meaning glaring sections of downtime in the GPU or the CPU. We might find certain frames take too long, degrading the FPS rate. ![]() If not, or if we think we might be able to do some tuning, we capture a trace so we can start analysis. We run our game and check whether the FPS rate is good. We may find gaps in the CPU and/or GPU activity. We may find particular frames take a long time to process. ![]() And also synchronization flows between the CPU threads and the GPU.Gaps in GPU utilization, which shows GPU downtime.Frame patterns, particularly frames that take longer to render than the others.Getting the bigger picture, using Graphics Trace Analyzer, we can see: In these cases, a single frame may not help us to understand the reason for FPS being lower than expected. However, there are times when doing optimizations based on analysis of individual frames does not give us the FPS boost we were expecting. Graphics Frame Analyzer helps with this by, for example, doing experiments to simplify textures to see if a particular texture is eating the frame rate. It makes sense to analyze a single frame when you want to determine how to increase the frames per second rate, the FPS. Graphics Trace Analyzer can help you pinpoint some areas for potential improvement, helping you to discover how to most efficiently increase the performance of your application. This use case will guide you through a scenario where we find an interesting pattern occurring in the GPU cycles. After assessing the root cause of the GPU down time using Intel® GPA tools, the game developer can make informed decisions about what to change. From there, we will trace backward in time to seek the root cause. We will see in this scenario that the GPU is underutilized. I'm Pamela Harrison from Intel here to take you on a guided tour of a use case looking at the performance of frame rendering. ![]()
0 Comments
Leave a Reply. |