← Back to branch summary

~mmach/netext73/mesa-haswell

« back to all changes in this revision

Viewing changes to src/mesa/state_tracker/st_atom_atomicbuf.c

  • Committer: mmach
  • Date: 2022-09-22 19:56:13 UTC
  • Revision ID: netbit73@gmail.com-20220922195613-wtik9mmy20tmor0i
2022-09-22 21:17:09

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/mesa/state_tracker/st_atom_atomicbuf.c
1
 
/**************************************************************************
2
 
 *
3
 
 * Copyright 2014 Ilia Mirkin. All Rights Reserved.
4
 
 *
5
 
 * Permission is hereby granted, free of charge, to any person obtaining a
6
 
 * copy of this software and associated documentation files (the
7
 
 * "Software"), to deal in the Software without restriction, including
8
 
 * without limitation the rights to use, copy, modify, merge, publish,
9
 
 * distribute, sub license, and/or sell copies of the Software, and to
10
 
 * permit persons to whom the Software is furnished to do so, subject to
11
 
 * the following conditions:
12
 
 *
13
 
 * The above copyright notice and this permission notice (including the
14
 
 * next paragraph) shall be included in all copies or substantial portions
15
 
 * of the Software.
16
 
 *
17
 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18
 
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
19
 
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
20
 
 * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
21
 
 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
22
 
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
23
 
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
24
 
 *
25
 
 **************************************************************************/
26
 
 
27
 
 
28
 
#include "program/prog_parameter.h"
29
 
#include "program/prog_print.h"
30
 
#include "compiler/glsl/ir_uniform.h"
31
 
 
32
 
#include "pipe/p_context.h"
33
 
#include "pipe/p_defines.h"
34
 
#include "util/u_inlines.h"
35
 
#include "util/u_surface.h"
36
 
 
37
 
#include "st_debug.h"
38
 
#include "st_context.h"
39
 
#include "st_atom.h"
40
 
#include "st_program.h"
41
 
 
42
 
static void
43
 
st_binding_to_sb(struct gl_buffer_binding *binding,
44
 
                 struct pipe_shader_buffer *sb)
45
 
{
46
 
   struct gl_buffer_object *st_obj = binding->BufferObject;
47
 
 
48
 
   if (st_obj && st_obj->buffer) {
49
 
     sb->buffer = st_obj->buffer;
50
 
     sb->buffer_offset = binding->Offset;
51
 
     sb->buffer_size = st_obj->buffer->width0 - binding->Offset;
52
 
 
53
 
     /* AutomaticSize is FALSE if the buffer was set with BindBufferRange.
54
 
      * Take the minimum just to be sure.
55
 
      */
56
 
     if (!binding->AutomaticSize)
57
 
       sb->buffer_size = MIN2(sb->buffer_size, (unsigned) binding->Size);
58
 
   } else {
59
 
     sb->buffer = NULL;
60
 
     sb->buffer_offset = 0;
61
 
     sb->buffer_size = 0;
62
 
   }
63
 
}
64
 
 
65
 
static void
66
 
st_bind_atomics(struct st_context *st, struct gl_program *prog,
67
 
                gl_shader_stage stage)
68
 
{
69
 
   unsigned i;
70
 
   enum pipe_shader_type shader_type = pipe_shader_type_from_mesa(stage);
71
 
 
72
 
   if (!prog || !st->pipe->set_shader_buffers || st->has_hw_atomics)
73
 
      return;
74
 
 
75
 
   /* For !has_hw_atomics, the atomic counters have been rewritten to be above
76
 
    * the SSBOs used by the program.
77
 
    */
78
 
   unsigned buffer_base = prog->info.num_ssbos;
79
 
   unsigned used_bindings = 0;
80
 
   for (i = 0; i < prog->sh.data->NumAtomicBuffers; i++) {
81
 
      struct gl_active_atomic_buffer *atomic =
82
 
         &prog->sh.data->AtomicBuffers[i];
83
 
      struct pipe_shader_buffer sb;
84
 
 
85
 
      st_binding_to_sb(&st->ctx->AtomicBufferBindings[atomic->Binding], &sb);
86
 
 
87
 
      st->pipe->set_shader_buffers(st->pipe, shader_type,
88
 
                                   buffer_base + atomic->Binding, 1, &sb, 0x1);
89
 
      used_bindings = MAX2(atomic->Binding + 1, used_bindings);
90
 
   }
91
 
   st->last_used_atomic_bindings[shader_type] = used_bindings;
92
 
}
93
 
 
94
 
void
95
 
st_bind_vs_atomics(struct st_context *st)
96
 
{
97
 
   struct gl_program *prog =
98
 
      st->ctx->_Shader->CurrentProgram[MESA_SHADER_VERTEX];
99
 
 
100
 
   st_bind_atomics(st, prog, MESA_SHADER_VERTEX);
101
 
}
102
 
 
103
 
void
104
 
st_bind_fs_atomics(struct st_context *st)
105
 
{
106
 
   struct gl_program *prog =
107
 
      st->ctx->_Shader->CurrentProgram[MESA_SHADER_FRAGMENT];
108
 
 
109
 
   st_bind_atomics(st, prog, MESA_SHADER_FRAGMENT);
110
 
}
111
 
 
112
 
void
113
 
st_bind_gs_atomics(struct st_context *st)
114
 
{
115
 
   struct gl_program *prog =
116
 
      st->ctx->_Shader->CurrentProgram[MESA_SHADER_GEOMETRY];
117
 
 
118
 
   st_bind_atomics(st, prog, MESA_SHADER_GEOMETRY);
119
 
}
120
 
 
121
 
void
122
 
st_bind_tcs_atomics(struct st_context *st)
123
 
{
124
 
   struct gl_program *prog =
125
 
      st->ctx->_Shader->CurrentProgram[MESA_SHADER_TESS_CTRL];
126
 
 
127
 
   st_bind_atomics(st, prog, MESA_SHADER_TESS_CTRL);
128
 
}
129
 
 
130
 
void
131
 
st_bind_tes_atomics(struct st_context *st)
132
 
{
133
 
   struct gl_program *prog =
134
 
      st->ctx->_Shader->CurrentProgram[MESA_SHADER_TESS_EVAL];
135
 
 
136
 
   st_bind_atomics(st, prog, MESA_SHADER_TESS_EVAL);
137
 
}
138
 
 
139
 
void
140
 
st_bind_cs_atomics(struct st_context *st)
141
 
{
142
 
   if (st->has_hw_atomics) {
143
 
      st_bind_hw_atomic_buffers(st);
144
 
      return;
145
 
   }
146
 
   struct gl_program *prog =
147
 
      st->ctx->_Shader->CurrentProgram[MESA_SHADER_COMPUTE];
148
 
 
149
 
   st_bind_atomics(st, prog, MESA_SHADER_COMPUTE);
150
 
}
151
 
 
152
 
void
153
 
st_bind_hw_atomic_buffers(struct st_context *st)
154
 
{
155
 
   struct pipe_shader_buffer buffers[PIPE_MAX_HW_ATOMIC_BUFFERS];
156
 
   int i;
157
 
 
158
 
   if (!st->has_hw_atomics)
159
 
      return;
160
 
 
161
 
   for (i = 0; i < st->ctx->Const.MaxAtomicBufferBindings; i++)
162
 
      st_binding_to_sb(&st->ctx->AtomicBufferBindings[i], &buffers[i]);
163
 
 
164
 
   st->pipe->set_hw_atomic_buffers(st->pipe, 0, st->ctx->Const.MaxAtomicBufferBindings, buffers);
165
 
}