Direct3D: allocations during play counted, and none left but the shaders made ahead

tools/rend/d3d_allocs.sh runs the test discs under d3d_hdr with Direct3D
11 and 12, each renderer, threaded rendering on and off, counting from
frame 20 on the core's heap - what it imports for it pointed at
tools/rend/alloc_count.c's Windows half, the C++ runtime linked into it
included - and the Direct3D objects it makes through the device's
methods, named by the build's symbol table, against
tools/rend/d3d_allocs.allowed. In CI.

A render read back takes its room from one readback buffer (12) or one
staging picture (11), a ring made with the renderer: nothing is made in
the fault handler. A texture's name for the log is written into the
caller's room. The thread that makes shaders and pipelines ahead is
started with the renderer and parks on an eventcount, not started for
each batch. Direct3D 11's shader sources are put together once, and what
it compiles is kept as the compiler's blob in a fixed map. The texture
pool has render targets four times as long as they are wide, to 256.
Left on the list: a polygon's own Direct3D 11 pixel shader, made on that
thread when a frame first wants it.

d3d_warm_test, dx11_shaders_ahead_test and dx12_pipelines_ahead_test run
in CI, the last two brought up to the renderers as they are; Direct3D
12's on wine's own vkd3d, with its virtual heaps.

Author: LibretroAdmin

.github/workflows/vulkan-negotiation.yml

@@ -14,6 +14,10 @@ name: Vulkan negotiation
 # 24-bit, HDR10 and scRGB pictures read back and judged:
 # tools/hdr/d3d_hdr.sh. SSAA's exact average on Direct3D 12 is the
 # encoders' (hdr_d3d 12ssaa, 12sums): wine's vkd3d cannot draw SSAA.
+# And with Direct3D 11 and 12, no allocation during play
+# (tools/rend/d3d_allocs.sh), the thread that makes shaders and pipelines
+# ahead (tools/rend/d3d_warm_test.sh) and what it makes, on a device
+# (tools/rend/dx11_shaders_ahead_test.sh, dx12_pipelines_ahead_test.sh).
 # The HDR post effects (bloom, halation, chromatic aberration) are judged
 # in each against what the CPU makes of the picture (vk_hdr --post).
 # And renders to textures: what is fetched off the card and when
@@ -71,6 +75,12 @@ on:
       - 'core/rend/gl4/**'
       - 'tools/gl/**'
       - 'tools/rend/alloc_count.*'
+      - 'tools/vulkan/vk_alloc_sites.py'
+      - 'tools/rend/d3d_allocs.*'
+      - 'core/rend/d3d_warm.*'
+      - 'tools/rend/d3d_warm_test.*'
+      - 'tools/rend/dx11_shaders_ahead_test.*'
+      - 'tools/rend/dx12_pipelines_ahead_test.*'
       - 'core/rend/TexCache.*'
       - 'core/hw/sh4/sh4_mem.cpp'
       - 'tools/rend/rtt_watch_test.*'
@@ -122,6 +132,12 @@ on:
       - 'core/rend/gl4/**'
       - 'tools/gl/**'
       - 'tools/rend/alloc_count.*'
+      - 'tools/vulkan/vk_alloc_sites.py'
+      - 'tools/rend/d3d_allocs.*'
+      - 'core/rend/d3d_warm.*'
+      - 'tools/rend/d3d_warm_test.*'
+      - 'tools/rend/dx11_shaders_ahead_test.*'
+      - 'tools/rend/dx12_pipelines_ahead_test.*'
       - 'core/rend/TexCache.*'
       - 'core/hw/sh4/sh4_mem.cpp'
       - 'tools/rend/rtt_watch_test.*'
@@ -251,3 +267,13 @@ jobs:
         run: VK_DRIVER_FILES=/usr/share/vulkan/icd.d/lvp_icd.json sh tools/rend/d3d_dxil.sh parallel_dc_libretro.dll
       - name: Direct3D 11 - nothing compiled or made on the draw path, cold, every renderer (AGENTS.md)
         run: VK_DRIVER_FILES=/usr/share/vulkan/icd.d/lvp_icd.json sh tools/rend/d3d_draw_path.sh parallel_dc_libretro.dll
+      - name: Direct3D 11 and 12 - no allocation during play, every renderer (AGENTS.md)
+        run: VK_DRIVER_FILES=/usr/share/vulkan/icd.d/lvp_icd.json sh tools/rend/d3d_allocs.sh parallel_dc_libretro.dll
+      - name: The Direct3D renderers' thread ahead and their shader file (TSan, ASan/UBSan, no threads, Windows)
+        run: |
+          sh tools/rend/d3d_warm_test.sh
+          WINDOWS=1 sh tools/rend/d3d_warm_test.sh
+      - name: Direct3D 11's shaders made ahead and kept on disk, on a device
+        run: sh tools/rend/dx11_shaders_ahead_test.sh
+      - name: Direct3D 12's pipelines made ahead, on a device
+        run: VK_DRIVER_FILES=/usr/share/vulkan/icd.d/lvp_icd.json sh tools/rend/dx12_pipelines_ahead_test.sh

core/rend/TexCache.cpp

@@ -646,8 +646,11 @@ void BaseTextureCacheData::PrintTextureName()
 		strcat(str, " Bilinear");
 
 	sprintf(str + strlen(str), " %dx%d @ 0x%X", 8 << tsp.TexU, 8 << tsp.TexV, tcw.TexAddr << 3);
-	std::string id = GetId();
-	sprintf(str + strlen(str), " id=%s", id.c_str());
+	{
+		char id[32];
+		GetId(id, sizeof(id));
+		sprintf(str + strlen(str), " id=%s", id);
+	}
 	DEBUG_LOG(RENDERER, "%s", str);
 }
 

core/rend/TexCache.h

@@ -1082,7 +1082,8 @@ class BaseTextureCacheData
 	bool changed_pieces;
 
 	void PrintTextureName();
-	virtual std::string GetId() = 0;
+	/* what the renderer calls it, into @s (@n bytes) */
+	virtual void GetId(char *s, size_t n) = 0;
 
 	bool IsPaletted()
 	{

core/rend/d3d_warm.c

@@ -30,6 +30,7 @@
 #ifdef D3D_WARM_THREADS
 #include <retro_spsc.h>
 #include <rthreads/rthreads.h>
+#include <rthreads/retro_eventcount.h>
 
 struct d3d_warm
 {
@@ -39,12 +40,12 @@ struct d3d_warm
 	d3d_warm_release_t  release;
 	void               *ctx;
 	sthread_t          *thread;    /* renderer's thread only */
+	retro_eventcount_t  work;      /* the worker parks here */
+	retro_eventcount_t  idle;      /* and d3d_warm_drain_wait(), here */
 	/* Jobs handed over and not done with: added to by the renderer after
 	 * it queues them, taken from by the worker once one is built and its
-	 * result handed back. Changed by read-modify-writes only, one total
-	 * order: the renderer that finds it 0 starts a worker; the worker that
-	 * takes it to 0 has nothing left and leaves; while it is not 0 there is
-	 * a worker, which has every job counted in it to read. */
+	 * result handed back. Once 0, the worker touches nothing of the
+	 * renderer's until more are added. */
 	retro_atomic_int_t  pending;
 	retro_atomic_int_t  stop;
 };
@@ -57,25 +58,37 @@ static void d3d_warm_thread(void *data)
 
 	for (;;)
 	{
+		int key;
+
 		/* (stopped: whoever stopped it joins it and drops the rest) */
 		if (retro_atomic_load_acquire_int(&w->stop))
 			break;
-		/* (always there: counted after it was queued) */
-		if (retro_spsc_read(&w->jobs, &job, sizeof(job)) != sizeof(job))
-			break;
-		memset(&res, 0, sizeof(res));
-		res.key  = job.key;
-		res.kind = job.kind;
-		res.aux  = job.aux;
-		if (w->build(w->ctx, &job, &res))
+		if (retro_spsc_read(&w->jobs, &job, sizeof(job)) == sizeof(job))
 		{
-			if (       retro_spsc_write_avail(&w->results) < sizeof(res)
-					|| retro_spsc_write(&w->results, &res, sizeof(res)) != sizeof(res))
-				w->release(w->ctx, &res);
+			memset(&res, 0, sizeof(res));
+			res.key  = job.key;
+			res.kind = job.kind;
+			res.aux  = job.aux;
+			if (w->build(w->ctx, &job, &res))
+			{
+				if (       retro_spsc_write_avail(&w->results) < sizeof(res)
+						|| retro_spsc_write(&w->results, &res, sizeof(res)) != sizeof(res))
+					w->release(w->ctx, &res);
+			}
+			/* the last one: nothing of the renderer's is touched after this */
+			if (retro_atomic_fetch_sub_int(&w->pending, 1) == 1)
+				retro_eventcount_notify(&w->idle);
+			continue;
 		}
-		/* the last one: nothing of the renderer's is touched after this */
-		if (retro_atomic_fetch_sub_int(&w->pending, 1) == 1)
-			break;
+		/* none: parked until there are, or it is stopped */
+		key = retro_eventcount_prepare_wait(&w->work);
+		if (       retro_atomic_load_acquire_int(&w->stop)
+				|| retro_spsc_read_avail(&w->jobs) >= sizeof(job))
+		{
+			retro_eventcount_cancel_wait(&w->work);
+			continue;
+		}
+		retro_eventcount_commit_wait(&w->work, key);
 	}
 }
 
@@ -88,38 +101,49 @@ d3d_warm_t *d3d_warm_new(d3d_warm_build_t build, d3d_warm_release_t release, voi
 	if (!(w = (d3d_warm_t*)calloc(1, sizeof(*w))))
 		return NULL;
 	if (!retro_spsc_init(&w->jobs, max_jobs * sizeof(d3d_warm_job_t)))
-	{
-		free(w);
-		return NULL;
-	}
+		goto no_jobs;
 	if (!retro_spsc_init(&w->results, max_jobs * sizeof(d3d_warm_result_t)))
-	{
-		retro_spsc_free(&w->jobs);
-		free(w);
-		return NULL;
-	}
+		goto no_results;
+	if (!retro_eventcount_init(&w->work))
+		goto no_work;
+	if (!retro_eventcount_init(&w->idle))
+		goto no_idle;
 	w->build   = build;
 	w->release = release;
 	w->ctx     = ctx;
 	retro_atomic_int_init(&w->pending, 0);
 	retro_atomic_int_init(&w->stop, 0);
+	if (!(w->thread = sthread_create(d3d_warm_thread, w)))
+		goto no_thread;
 	return w;
-}
 
-/* The thread joined, so the renderer is the only one at either queue. */
-static void d3d_warm_join(d3d_warm_t *w)
-{
-	if (w->thread)
-	{
-		sthread_join(w->thread);
-		w->thread = NULL;
-	}
+no_thread:
+	retro_eventcount_free(&w->idle);
+no_idle:
+	retro_eventcount_free(&w->work);
+no_work:
+	retro_spsc_free(&w->results);
+no_results:
+	retro_spsc_free(&w->jobs);
+no_jobs:
+	free(w);
+	return NULL;
 }
 
 void d3d_warm_drain_wait(d3d_warm_t *w)
 {
-	if (w)
-		d3d_warm_join(w);
+	if (!w)
+		return;
+	while (retro_atomic_load_acquire_int(&w->pending) != 0)
+	{
+		int key = retro_eventcount_prepare_wait(&w->idle);
+		if (retro_atomic_load_acquire_int(&w->pending) == 0)
+		{
+			retro_eventcount_cancel_wait(&w->idle);
+			break;
+		}
+		retro_eventcount_commit_wait(&w->idle, key);
+	}
 }
 
 size_t d3d_warm_submit(d3d_warm_t *w, const d3d_warm_job_t *jobs, size_t n)
@@ -133,20 +157,8 @@ size_t d3d_warm_submit(d3d_warm_t *w, const d3d_warm_job_t *jobs, size_t n)
 	if (!put)
 		return 0;
 	retro_spsc_write(&w->jobs, jobs, put * sizeof(*jobs));
-	/* None pending: no worker (the last one has left, or is leaving, and
-	 * reads nothing more). Start one. */
-	if (retro_atomic_fetch_add_int(&w->pending, (int)put) == 0)
-	{
-		d3d_warm_join(w);
-		if (!(w->thread = sthread_create(d3d_warm_thread, w)))
-		{
-			/* Nothing will take them: they go back to the caller (none
-			 * other is queued: none was pending). */
-			retro_spsc_clear(&w->jobs);
-			retro_atomic_store_release_int(&w->pending, 0);
-			return 0;
-		}
-	}
+	retro_atomic_fetch_add_int(&w->pending, (int)put);
+	retro_eventcount_notify(&w->work);
 	return put;
 }
 
@@ -155,10 +167,16 @@ void d3d_warm_stop(d3d_warm_t *w)
 	if (!w)
 		return;
 	retro_atomic_store_release_int(&w->stop, 1);
-	d3d_warm_join(w);
+	retro_eventcount_notify(&w->work);
+	if (w->thread)
+	{
+		sthread_join(w->thread);
+		w->thread = NULL;
+	}
 	/* (what was not started is not going to be) */
 	retro_spsc_clear(&w->jobs);
 	retro_atomic_store_release_int(&w->pending, 0);
+	retro_eventcount_notify(&w->idle);
 }
 
 bool d3d_warm_take(d3d_warm_t *w, d3d_warm_result_t *res)
@@ -180,6 +198,8 @@ void d3d_warm_free(d3d_warm_t *w)
 	d3d_warm_stop(w);
 	while (retro_spsc_read(&w->results, &res, sizeof(res)) == sizeof(res))
 		w->release(w->ctx, &res);
+	retro_eventcount_free(&w->work);
+	retro_eventcount_free(&w->idle);
 	retro_spsc_free(&w->jobs);
 	retro_spsc_free(&w->results);
 	free(w);

core/rend/d3d_warm.h

@@ -19,10 +19,12 @@
  *
  * The renderer hands over jobs (a kind and a key of its own); a thread
  * builds each with the renderer's build function and hands the result
- * back. The thread exits once there is no job left, and the next jobs
- * handed over start another: it never waits for work. Both hand-overs are
- * lock-free single-producer single-consumer queues: the renderer's thread
- * gives jobs and takes results, the worker the other way round.
+ * back. The thread is started with it (d3d_warm_new()), not as jobs come:
+ * with none left it parks on an eventcount, which the next jobs handed
+ * over wake it from - nothing made, and no lock taken, to start it again.
+ * Both hand-overs are lock-free single-producer single-consumer queues:
+ * the renderer's thread gives jobs and takes results, the worker the
+ * other way round.
  *
  * The renderer takes results when it misses something it would otherwise
  * build: a result is never required, and one that could not be handed back
@@ -69,16 +71,16 @@ d3d_warm_t *d3d_warm_new(d3d_warm_build_t build, d3d_warm_release_t release, voi
 /* Stops the thread (the job it is building is finished), releases what
  * was not taken, frees. */
 void d3d_warm_free(d3d_warm_t *w);
-/* Hands over @n jobs, starting a thread if none is running. Returns how
- * many were taken: the rest are the caller's to build. */
+/* Hands over @n jobs, waking the thread. Returns how many were taken: the
+ * rest are the caller's to build. */
 size_t d3d_warm_submit(d3d_warm_t *w, const d3d_warm_job_t *jobs, size_t n);
 /* One result, if there is one. */
 bool d3d_warm_take(d3d_warm_t *w, d3d_warm_result_t *res);
 /* Whether any job handed over is not done yet (renderer's thread). Once
  * false, the worker touches nothing of the renderer's until the next
  * submit. */
 bool d3d_warm_busy(d3d_warm_t *w);
-/* Waits for the thread to finish what it was given (tests). */
+/* Waits for the thread to finish what it was given. */
 void d3d_warm_drain_wait(d3d_warm_t *w);
 /* Stops the thread after the job it is building, and joins it: what it
  * finished is still there to take, and nothing more is built. */

core/rend/dx11/dx11_renderer.cpp

@@ -108,6 +108,8 @@ bool DX11Renderer::Init()
 	success = depthStencilStates.MakeAll() && success;
 	success = blendStates->MakeAll() && success;
 	success = samplers->MakeAll() && success;
+	// what a render read back takes, made now (dx11_rtt_init())
+	dx11_rtt_init();
 	ID3DBlob *blob = shaders->GetVertexShaderBlob();
 	success = success && blob != nullptr
 			&& SUCCEEDED(device->CreateInputLayout(MainLayout, ARRAY_SIZE(MainLayout), blob->GetBufferPointer(), blob->GetBufferSize(), mainInputLayout.put()));