Ok, so I tested a bit more and the same happens when switching to the reference device, so apparently only drivers save me. The debug layer doesn't give any helpful informations and Calling GetDeviceRemovedReason just returns 0x887A0005 DXGI_ERROR_DEVICE_REMOVED.

That would mean (for my particular setup) I have to stall every render thread so I can update anything there. And thats what Im asking, if I can avoid it or not.
Yes, we saw about a 30% decrease in CPU performance, but since we can just use more cores we actually get less latency and more performance. Our target machines have about 8+ real cpu cores.
To use one thread on one immediate device context would require to create multiple d3d11 devices and share resources accross them. I haven't tried to share vertex/index buffers across devices yet. (The limiting factor is VRAM for models, really. Up to about 10GB, which are shared between each render window)
The solution I went for is using matrix buffers per render window per model-material combination. So even when running at different refresh rates, each window can update its own buffers without waiting/locking the other renderers.

Currently i use one cbuffer for matrices and one cbuffer for material informations.
Using command lists enables me to render multiple views of the same scene on one device. I create command lists for rendering different views (render windows) concurrently, so one rendering does not block the 2nd window. Prepairing commands lists helps also with VR performance.
Yes, I submit command lists in the wrong order and Im looking for a way to update everything as fast as possible while not getting thread interlocks.
All calls to the immediate context are interlocked, I get no d3d11 errors and also renderdoc API is implemented and shows no errors Switchting to D3D12 is currently not an option

TLDR: is there a way to "capture" a constantbuffer in a command list (like the InstanceCount in DrawIndexedInstanced is captured) so i can update it before the command list is executed?
Hey,
I want to draw millions of objects and i use instancing to do so. My current implementation caches the matrix buffers, so I have a constantbuffer for each model-material combination. This is done so I don't have to rebuild my buffers each frame, because most of my scene is static, but can move at times. To update the constantbuffers I have another thread which creates command lists to update the constantbuffers and executes them on the immediate context. My render thread(s) also create command lists ahead of time to issue to the gpu when a new frame is needed. The matrix buffers are shared between multiple render threads.
The result is that when an object changes color, so it goes from one model-material buffer to another, it hides one frame and is visible at the next or is for one frame at a different location where an object was before. I speculate this is because the constantbuffer for matrices is updated immediately but the InstanceCount in the draw command list is not. This leads to matrices which contain old or uninitialized memory.
Is there a way to update my matrix constant buffers without stalling every renderthread and invalidating all render command lists?
regards

I was querying a ID3D11Debug for ID3D11InfoQueue, this crashed the application because RenderDoc didnt support this. This will be fixed in future RenderDoc versions.
Querying the ID3D11Device directly to get the ID3D11InfoQueue seems to work as expected.

Thanks for the suggestion, it definitely looks like the right tool for capturing offscreen rendering. Unfortunately, RederDoc crashes even before my app shows up, produces a 4GB logfile and fails to send the crash report...

Hey everyone,
ive used tools like Intel GPA in the past and I would like to continue doing that.
But in my current work environment I cant find a tool that can analyze rendering without a swapchain and calling Present().
In addition to that, the program Im working on uses WPF for UI, which uses a D3D9Ex Device and some tools attach to that device instead.
So, are there any tools that allow debugging D3D11 without depending on a swapchain?
Thanks for any help!

Yeah, I pretty much checked EVERYTHING else so it had to be a pipeline state.
Glad that it fixed it for you too. My best guess is that the MultisampleEnable bool is for an automated multisampling and messes up with the manually set sample count.
Oh just another info: This change doesnt work well with line rendering and setting IsAntialiasedLineEnabled to true produces this:
I ended up creating another RasterizerState that i use for line rendering which uses IsMultisampleEnabled = true and produces the desired result:
regards

Hey,
i just registered to let you know how I fixed this. I had exactly the same issues which looked like this:
https://imgur.com/a/sOoa7
It took me about 8hours of debuggung. I found out that the PS Invocation Count is changing from frame to frame by +-50000! Then i changed SV_Coverage to see individual samples and saw that the MSAA samples itself were fine and I knew it had to be a state issue.
So after some playing around I found that if I set
MultisampleEnable = FALSE;
inside the D3D11_RASTERIZER_DESC then Multisampling will still work but there wont be any flickering and holes between polygons!
I hope this will help everyone with the same issue!
regards
Valdiralita