use BufferSubData for uploading rf data on NVIDIA/AMD

It may seem counter-intuitive and goes against all of NVIDIA's
presentations and other documentation but this is the fastest way
to upload the data.

Unfourtanetely this doesn't work on Intel for some reason so it
gets a seperate path. The seperate path code is necessary anyways
because we want to add CUDA support for NVIDIA.

Author: rnpnr

beamformer.c

@@ -69,12 +69,17 @@ alloc_shader_storage(BeamformerCtx *ctx, Arena a)
 	glDeleteBuffers(ARRAY_COUNT(cs->rf_data_ssbos), cs->rf_data_ssbos);
 	glGenBuffers(ARRAY_COUNT(cs->rf_data_ssbos),    cs->rf_data_ssbos);
 
+	i32 storage_flags = GL_DYNAMIC_STORAGE_BIT;
+	if (ctx->gl_vendor_id == GL_VENDOR_INTEL)
+		storage_flags |= GL_MAP_WRITE_BIT;
 	glDeleteBuffers(1, &cs->raw_data_ssbo);
-	glGenBuffers(1,    &cs->raw_data_ssbo);
+	glCreateBuffers(1, &cs->raw_data_ssbo);
+	glNamedBufferStorage(cs->raw_data_ssbo, ARRAY_COUNT(cs->raw_data_fences) * rf_raw_size, 0,
+	                     storage_flags);
 
-	glBindBuffer(GL_SHADER_STORAGE_BUFFER, cs->raw_data_ssbo);
-	glBufferStorage(GL_SHADER_STORAGE_BUFFER, ARRAY_COUNT(cs->raw_data_fences) * rf_raw_size,
-	                0, GL_MAP_WRITE_BIT);
+	/* TODO: allow this to grow if the raw data has been resized */
+	if (cs->raw_data_arena.beg == 0)
+		cs->raw_data_arena = os_new_arena(rf_raw_size);
 
 	for (u32 i = 0; i < ARRAY_COUNT(cs->rf_data_ssbos); i++) {
 		glBindBuffer(GL_SHADER_STORAGE_BUFFER, cs->rf_data_ssbos[i]);
@@ -538,7 +543,8 @@ do_beamformer(BeamformerCtx *ctx, Arena arena)
 	BeamformerParameters *bp = &ctx->params->raw;
 	/* NOTE: Check for and Load RF Data into GPU */
 	if (os_poll_pipe(ctx->data_pipe)) {
-		if (!uv4_equal(ctx->csctx.dec_data_dim, bp->dec_data_dim) || ctx->flags & ALLOC_SSBOS)
+		ComputeShaderCtx *cs = &ctx->csctx;
+		if (!uv4_equal(cs->dec_data_dim, bp->dec_data_dim) || ctx->flags & ALLOC_SSBOS)
 			alloc_shader_storage(ctx, arena);
 		if (!uv4_equal(ctx->out_data_dim, bp->output_points) || ctx->flags & ALLOC_OUT_TEX)
 			alloc_output_image(ctx);
@@ -547,31 +553,39 @@ do_beamformer(BeamformerCtx *ctx, Arena arena)
 		/* NOTE: if this times out it means the command queue is more than 3 frames behind.
 		 * In that case we need to re-evaluate the buffer size */
 		if (ctx->csctx.raw_data_fences[raw_index]) {
-			i32 result = glClientWaitSync(ctx->csctx.raw_data_fences[raw_index], 0, 10000);
+			i32 result = glClientWaitSync(cs->raw_data_fences[raw_index], 0, 10000);
 			if (result == GL_TIMEOUT_EXPIRED) {
 				//ASSERT(0);
 			}
-			glDeleteSync(ctx->csctx.raw_data_fences[raw_index]);
-			ctx->csctx.raw_data_fences[raw_index] = NULL;
+			glDeleteSync(cs->raw_data_fences[raw_index]);
+			cs->raw_data_fences[raw_index] = NULL;
 		}
 
-		uv2  rf_raw_dim   = ctx->csctx.rf_raw_dim;
+		uv2  rf_raw_dim   = cs->rf_raw_dim;
 		size rf_raw_size  = rf_raw_dim.x * rf_raw_dim.y * sizeof(i16);
 
-		glBindBuffer(GL_SHADER_STORAGE_BUFFER, ctx->csctx.raw_data_ssbo);
-		void *rf_data_buf = glMapBufferRange(GL_SHADER_STORAGE_BUFFER,
-		                                     raw_index * rf_raw_size, rf_raw_size,
-		                                     GL_MAP_UNSYNCHRONIZED_BIT | GL_MAP_WRITE_BIT);
-		if (!rf_data_buf) {
-			rlCheckErrors();
-			ASSERT(0);
+		if (ctx->gl_vendor_id == GL_VENDOR_INTEL) {
+			/* TODO: intel complains about this buffer being busy even with
+			 * MAP_UNSYNCHRONIZED_BIT */
+			void *rf_data_buf = glMapNamedBufferRange(cs->raw_data_ssbo,
+			                                          raw_index * rf_raw_size,
+			                                          rf_raw_size,
+			                                          GL_MAP_WRITE_BIT);
+			size rlen = os_read_pipe_data(ctx->data_pipe, rf_data_buf, rf_raw_size);
+			glUnmapNamedBuffer(cs->raw_data_ssbo);
+			if (rlen == rf_raw_size) ctx->flags |= DO_COMPUTE;
+			else                     ctx->partial_transfer_count++;
+		} else {
+			void *rf_data_buf = cs->raw_data_arena.beg + raw_index * rf_raw_size;
+			size rlen = os_read_pipe_data(ctx->data_pipe, rf_data_buf, rf_raw_size);
+			if (rlen == rf_raw_size) {
+				ctx->flags |= DO_COMPUTE;
+				glNamedBufferSubData(cs->raw_data_ssbo, raw_index * rf_raw_size,
+				                     rf_raw_size, rf_data_buf);
+			} else {
+				ctx->partial_transfer_count++;
+			}
 		}
-		size rlen = os_read_pipe_data(ctx->data_pipe, rf_data_buf, rf_raw_size);
-
-		glUnmapBuffer(GL_SHADER_STORAGE_BUFFER);
-
-		if (rlen == rf_raw_size) ctx->flags |= DO_COMPUTE;
-		else                     ctx->partial_transfer_count++;
 	}
 
 	if (ctx->flags & UPLOAD_FILTER)

beamformer.h

@@ -60,6 +60,12 @@ enum program_flags {
 	DO_COMPUTE     = 1 << 30,
 };
 
+enum gl_vendor_ids {
+	GL_VENDOR_AMD,
+	GL_VENDOR_INTEL,
+	GL_VENDOR_NVIDIA,
+};
+
 typedef struct {
 	char buf[64];
 	i32  buf_len;
@@ -98,13 +104,17 @@ typedef struct {
 	GLsync timer_fence;
 	f32    last_frame_time[CS_LAST];
 
-	/* NOTE: multiple raw data SSBOs for unsynchronized mapping.
-	 * Decoded data is only relavent in the context of a single frame, two are
-	 * used so that they can be swapped when chaining multiple compute stages */
+	/* NOTE: the raw_data_ssbo is allocated at 3x the required size to allow for tiled
+	 * transfers when the GPU is running behind the CPU. It is not mapped because NVIDIA's
+	 * drivers _will_ store the buffer in the sytem memory in that case (this doesn't happen
+	 * for Intel or AMD). Instead BufferSubData is used to update the correct subrange */
 	GLsync raw_data_fences[3];
+	Arena  raw_data_arena;
 	u32    raw_data_ssbo;
 	u32    raw_data_index;
 
+	/* NOTE: Decoded data is only relevant in the context of a single frame. We use two
+	 * buffers so that they can be swapped when chaining multiple compute stages */
 	u32 rf_data_ssbos[2];
 	u32 last_output_ssbo_index;
 	u32 hadamard_ssbo;
@@ -134,6 +144,7 @@ typedef struct {
 typedef struct {
 	uv2 window_size;
 	u32 flags;
+	enum gl_vendor_ids gl_vendor_id;
 
 	f32 dt;
 

main.c

@@ -185,6 +185,18 @@ main(void)
 
 	ctx.params->raw.output_points = ctx.out_data_dim;
 
+	/* NOTE: Determine which graphics vendor we are running on */
+	{
+		const u8 *vendor = glGetString(GL_VENDOR);
+		if (!vendor)
+			die("Failed to determine GL Vendor\n");
+		switch (vendor[0]) {
+		case 'A': ctx.gl_vendor_id = GL_VENDOR_AMD;       break;
+		case 'I': ctx.gl_vendor_id = GL_VENDOR_INTEL;     break;
+		case 'N': ctx.gl_vendor_id = GL_VENDOR_NVIDIA;    break;
+		default:  die("Unknown GL Vendor: %s\n", vendor); break;
+		}
+	}
 
 	/* NOTE: set up OpenGL debug logging */
 	glDebugMessageCallback(gl_debug_logger, NULL);