Our program crashes when we analyze it with Intel GPA under the following circumstances.
When resizing the window (in response to the windows flag WM_SIZE) the program will crash on a call to resize the swap chain buffer. This crash only occurs if we are analyzing the program using Intel GPA. If we run the program using the Visual Studio debugger or using RenderDoc then the program does not crash.
The relevant line of code is:
HRESULT hr = m_renderer.GetSwapChain()->ResizeBuffers(0,cx,cy,DXGI_FORMAT_UNKNOWN, NULL);
This line is executed successfully twice before the program crashes on the third call in response to WM_SIZE.
We have confirmed that the DirectX 11.1 device and swap chain are created successfully during these program runs. In all cases we are releasing the references to the swap chain buffer and observe 0 remaining references returned by calling Reset() on our relevant ComPtr's:
- Render target view (ID3D11RenderTargetView)
- MSAA render target view (ID3D11RenderTargetView)
- MSAA render target buffer (ID3D11Texture2D)
- Depth stencil view (ID3D11DepthStencilView)
- MSAA depth stencil view (ID3D11DepthStencilView)
- Depth stencil buffer (ID3D11Texture2D)
- MSAA depth stencil buffer (ID3D11Texture2D)
- Back buffer (ID3D11Texture2D)
By commenting out the call to ResizeBuffers we can avoid the crash when our OnSize() is invoked, however that is not a real solution as this leaves are buffers not the same size. It seems like perhaps it is related to the GPA overlay, disabling the overlay also avoids the crash, however we don't know how to get a frame capture without the overlay (ctl-shift-c only seems to work when overlay is in window).
Graphics Performance Analyzers: Version: 21.2.1624350604
Windows 10 Enterprise x64
It has been just over two weeks since our group posted this question. We have not been able to move forward with use of the debugging tool since Aug. 24, 2021. Can someone please provide a follow-up? Otherwise, we will need to move onto use of a non-Intel tool.
Here is what I've found. The issue is with our legacy HUD. So you can hide the HUD and do a capture. Or, if you are capturing based on HUD info, then you will need to capture from System Analyzer. See details below for your options.
The Ctrl+Shift+C hotkey combo should work properly even if the HUD is hidden. If it doesn’t work for you for some reason, then try one of the following to capture a frame.
#1 Connect System Analyzer (SA) to your running application , and then capture a frame from SA:
- In Graphics Monitor click the "play" button (the triangle) for the application you want to analyze
- After clicking the play button, the "stop" button (the square) turns into the System Analyzer icon. Click on that. System Analyzer will open.
- After SA opens, make sure your application is in the foreground (if not, there is no rendering from the application) and click on the camera image (upper left of the SA window) to capture a frame.
#2 Run your application in “Stream” mode and then select a single frame in Multi-Frame view. (Note: Stream mode for DX11 is in Tech Preview stage and may not work).
Let me know if you continue to face this issue after trying these workarounds.
Thanks again for the detailed workaround suggestions.
Our outcomes are briefly summarized below in the spirt of just following up with you, and also, in welcoming any further suggestions or additional ideas.
Regarding item #1:
We have been able to carry out this workaround. However, our application routinely has multiple DirectX windows open at a given time. As a result, to carry out this workaround, we have to actually make temporary source-code changes to limit window generation to one-at-a-time and THEN carry out this workaround. Any further suggestions are welcomed here, but we recognize that this may be the end of the line for this option.
Regarding item #2:
Our application is currently 32-bit (but we would plan to ultimately move to 64-bit), and so, it does not appear that we can make use of the "Stream" mode. However, if we're missing anything along these lines (i.e., that we can actually make use of "Stream" mode despite being 32-bit), then we welcome any further thoughts you may have.
Thanks once more,