st/mesa: optimize DEPTH_STENCIL copies using fragment shader

[mesa.git] / src / mesa / state_tracker / st_shader_cache.c

diff --git a/src/mesa/state_tracker/st_shader_cache.c b/src/mesa/state_tracker/st_shader_cache.c
index 2d630c65aea696d63ac62ec9919f187faa4bde28..000d1c2688b7dc4030594efdc8ee1ad359025b1c 100644 (file)
--- a/src/mesa/state_tracker/st_shader_cache.c
+++ b/src/mesa/state_tracker/st_shader_cache.c
@@ -44,8 +44,13 @@ static void
 write_stream_out_to_cache(struct blob *blob,
                           struct pipe_shader_state *state)
 {
-   blob_write_bytes(blob, &state->stream_output,
-                    sizeof(state->stream_output));
+   blob_write_uint32(blob, state->stream_output.num_outputs);
+   if (state->stream_output.num_outputs) {
+      blob_write_bytes(blob, &state->stream_output.stride,
+                       sizeof(state->stream_output.stride));
+      blob_write_bytes(blob, &state->stream_output.output,
+                       sizeof(state->stream_output.output));
+   }
 }
 
 static void
@@ -74,8 +79,8 @@ write_nir_to_cache(struct blob *blob, struct gl_program *prog)
 
    st_serialize_nir(stp);
 
-   blob_write_intptr(blob, stp->nir_size);
-   blob_write_bytes(blob, stp->nir_binary, stp->nir_size);
+   blob_write_intptr(blob, stp->serialized_nir_size);
+   blob_write_bytes(blob, stp->serialized_nir, stp->serialized_nir_size);
 
    copy_blob_to_driver_cache_blob(blob, prog);
 }
@@ -145,8 +150,14 @@ static void
 read_stream_out_from_cache(struct blob_reader *blob_reader,
                            struct pipe_shader_state *state)
 {
-   blob_copy_bytes(blob_reader, (uint8_t *) &state->stream_output,
-                    sizeof(state->stream_output));
+   memset(&state->stream_output, 0, sizeof(state->stream_output));
+   state->stream_output.num_outputs = blob_read_uint32(blob_reader);
+   if (state->stream_output.num_outputs) {
+      blob_copy_bytes(blob_reader, &state->stream_output.stride,
+                      sizeof(state->stream_output.stride));
+      blob_copy_bytes(blob_reader, &state->stream_output.output,
+                      sizeof(state->stream_output.output));
+   }
 }
 
 static void
@@ -177,9 +188,9 @@ st_deserialise_ir_program(struct gl_context *ctx,
    struct blob_reader blob_reader;
    blob_reader_init(&blob_reader, buffer, size);
 
-   if (prog->info.stage == MESA_SHADER_VERTEX) {
-      st_release_vp_variants(st, stp);
+   st_release_variants(st, stp);
 
+   if (prog->info.stage == MESA_SHADER_VERTEX) {
       struct st_vertex_program *stvp = (struct st_vertex_program *)stp;
       stvp->num_inputs = blob_read_uint32(&blob_reader);
       blob_copy_bytes(&blob_reader, (uint8_t *) stvp->index_to_input,
@@ -188,10 +199,6 @@ st_deserialise_ir_program(struct gl_context *ctx,
                       sizeof(stvp->input_to_index));
       blob_copy_bytes(&blob_reader, (uint8_t *) stvp->result_to_output,
                       sizeof(stvp->result_to_output));
-   } else if (prog->info.stage == MESA_SHADER_FRAGMENT) {
-      st_release_fp_variants(st, stp);
-   } else {
-      st_release_common_variants(st, stp);
    }
 
    if (prog->info.stage == MESA_SHADER_VERTEX ||
@@ -201,14 +208,12 @@ st_deserialise_ir_program(struct gl_context *ctx,
 
    if (nir) {
       assert(prog->nir == NULL);
-      assert(stp->state.ir.nir == NULL);
-      assert(stp->nir_binary == NULL);
+      assert(stp->serialized_nir == NULL);
 
-      /* The remainder of the binary is NIR. */
       stp->state.type = PIPE_SHADER_IR_NIR;
-      stp->nir_size = blob_read_intptr(&blob_reader);
-      stp->nir_binary = malloc(stp->nir_size);
-      blob_copy_bytes(&blob_reader, stp->nir_binary, stp->nir_size);
+      stp->serialized_nir_size = blob_read_intptr(&blob_reader);
+      stp->serialized_nir = malloc(stp->serialized_nir_size);
+      blob_copy_bytes(&blob_reader, stp->serialized_nir, stp->serialized_nir_size);
       stp->shader_program = shProg;
    } else {
       read_tgsi_from_cache(&blob_reader, &stp->state.tokens);