← Back to branch summary

~mmach/netext73/mesa-ryzen

« back to all changes in this revision

Viewing changes to src/gallium/frontends/lavapipe/lvp_query.c

  • Committer: mmach
  • Date: 2023-11-02 21:31:35 UTC
  • Revision ID: netbit73@gmail.com-20231102213135-18d4tzh7tj0uz752
2023-11-02 22:11:57

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gallium/frontends/lavapipe/lvp_query.c
47
47
      pipeq = PIPE_QUERY_PIPELINE_STATISTICS;
48
48
      break;
49
49
   case VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT:
 
50
   case VK_QUERY_TYPE_MESH_PRIMITIVES_GENERATED_EXT:
50
51
      pipeq = PIPE_QUERY_PRIMITIVES_GENERATED;
51
52
      break;
52
53
   default:
53
54
      return VK_ERROR_FEATURE_NOT_PRESENT;
54
55
   }
 
56
 
55
57
   struct lvp_query_pool *pool;
56
 
   uint32_t pool_size = sizeof(*pool) + pCreateInfo->queryCount * sizeof(struct pipe_query *);
 
58
   size_t pool_size = sizeof(*pool)
 
59
      + pCreateInfo->queryCount * sizeof(struct pipe_query *);
57
60
 
58
61
   pool = vk_zalloc2(&device->vk.alloc, pAllocator,
59
62
                    pool_size, 8,
107
110
   device->vk.dispatch_table.DeviceWaitIdle(_device);
108
111
 
109
112
   for (unsigned i = firstQuery; i < firstQuery + queryCount; i++) {
110
 
      uint8_t *dptr = (uint8_t *)((char *)pData + (stride * (i - firstQuery)));
 
113
      uint8_t *dest = (uint8_t *)((char *)pData + (stride * (i - firstQuery)));
111
114
      union pipe_query_result result;
112
115
      bool ready = false;
 
116
 
113
117
      if (pool->queries[i]) {
114
 
        ready = device->queue.ctx->get_query_result(device->queue.ctx,
115
 
                                                    pool->queries[i],
116
 
                                                    (flags & VK_QUERY_RESULT_WAIT_BIT),
117
 
                                                    &result);
 
118
         ready = device->queue.ctx->get_query_result(device->queue.ctx,
 
119
                                                     pool->queries[i],
 
120
                                                     (flags & VK_QUERY_RESULT_WAIT_BIT),
 
121
                                                     &result);
118
122
      } else {
119
 
        result.u64 = 0;
 
123
         result.u64 = 0;
120
124
      }
121
125
 
122
126
      if (!ready && !(flags & VK_QUERY_RESULT_PARTIAL_BIT))
123
127
          vk_result = VK_NOT_READY;
 
128
 
124
129
      if (flags & VK_QUERY_RESULT_64_BIT) {
 
130
         uint64_t *dest64 = (uint64_t *) dest;
125
131
         if (ready || (flags & VK_QUERY_RESULT_PARTIAL_BIT)) {
126
132
            if (pool->type == VK_QUERY_TYPE_PIPELINE_STATISTICS) {
127
133
               uint32_t mask = pool->pipeline_stats;
128
 
               uint64_t *pstats = (uint64_t *)&result.pipeline_statistics;
 
134
               const uint64_t *pstats = result.pipeline_statistics.counters;
129
135
               while (mask) {
130
136
                  uint32_t i = u_bit_scan(&mask);
131
 
 
132
 
                  *(uint64_t *)dptr = pstats[i];
133
 
                  dptr += 8;
 
137
                  *dest64++ = pstats[i];
134
138
               }
135
139
            } else if (pool->type == VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT) {
136
 
               *(uint64_t *)dptr = result.so_statistics.num_primitives_written;
137
 
               dptr += 8;
138
 
               *(uint64_t *)dptr = result.so_statistics.primitives_storage_needed;
139
 
               dptr += 8;
 
140
               *dest64++ = result.so_statistics.num_primitives_written;
 
141
               *dest64++ = result.so_statistics.primitives_storage_needed;
140
142
            } else {
141
 
               *(uint64_t *)dptr = result.u64;
142
 
               dptr += 8;
 
143
               *dest64++ = result.u64;
143
144
            }
144
145
         } else {
145
 
            if (pool->type == VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT)
146
 
               dptr += 16;
147
 
            else
148
 
               dptr += 8;
149
 
         }
150
 
 
 
146
            if (pool->type == VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT) {
 
147
               dest64 += 2; // 16 bytes
 
148
            } else {
 
149
               dest64 += 1; // 8 bytes
 
150
            }
 
151
         }
 
152
         if (flags & VK_QUERY_RESULT_WITH_AVAILABILITY_BIT) {
 
153
            *dest64 = ready;
 
154
         }
151
155
      } else {
 
156
         uint32_t *dest32 = (uint32_t *) dest;
152
157
         if (ready || (flags & VK_QUERY_RESULT_PARTIAL_BIT)) {
153
158
            if (pool->type == VK_QUERY_TYPE_PIPELINE_STATISTICS) {
154
159
               uint32_t mask = pool->pipeline_stats;
155
 
               uint64_t *pstats = (uint64_t *)&result.pipeline_statistics;
 
160
               const uint64_t *pstats = result.pipeline_statistics.counters;
156
161
               while (mask) {
157
162
                  uint32_t i = u_bit_scan(&mask);
158
 
 
159
 
                  if (pstats[i] > UINT32_MAX)
160
 
                     *(uint32_t *)dptr = UINT32_MAX;
161
 
                  else
162
 
                     *(uint32_t *)dptr = pstats[i];
163
 
                  dptr += 4;
 
163
                  *dest32++ = (uint32_t) MIN2(pstats[i], UINT32_MAX);
164
164
               }
165
165
            } else if (pool->type == VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT) {
166
 
               if (result.so_statistics.num_primitives_written > UINT32_MAX)
167
 
                  *(uint32_t *)dptr = UINT32_MAX;
168
 
               else
169
 
                  *(uint32_t *)dptr = (uint32_t)result.so_statistics.num_primitives_written;
170
 
               dptr += 4;
171
 
               if (result.so_statistics.primitives_storage_needed > UINT32_MAX)
172
 
                  *(uint32_t *)dptr = UINT32_MAX;
173
 
               else
174
 
                  *(uint32_t *)dptr = (uint32_t)result.so_statistics.primitives_storage_needed;
175
 
               dptr += 4;
176
 
            } else {
177
 
               if (result.u64 > UINT32_MAX)
178
 
                  *(uint32_t *)dptr = UINT32_MAX;
179
 
               else
180
 
                  *(uint32_t *)dptr = result.u32;
181
 
               dptr += 4;
182
 
            }
183
 
         } else
184
 
            if (pool->type == VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT)
185
 
               dptr += 8;
186
 
            else
187
 
               dptr += 4;
188
 
      }
189
 
 
190
 
      if (flags & VK_QUERY_RESULT_WITH_AVAILABILITY_BIT) {
191
 
        if (flags & VK_QUERY_RESULT_64_BIT)
192
 
           *(uint64_t *)dptr = ready;
193
 
        else
194
 
           *(uint32_t *)dptr = ready;
 
166
               *dest32++ = (uint32_t)
 
167
                  MIN2(result.so_statistics.num_primitives_written, UINT32_MAX);
 
168
               *dest32++ = (uint32_t)
 
169
                  MIN2(result.so_statistics.primitives_storage_needed, UINT32_MAX);
 
170
            } else {
 
171
               *dest32++ = (uint32_t) MIN2(result.u64, UINT32_MAX);
 
172
            }
 
173
         } else {
 
174
            if (pool->type == VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT) {
 
175
               dest32 += 2;  // 8 bytes
 
176
            } else {
 
177
               dest32 += 1;  // 4 bytes
 
178
            }
 
179
         }
 
180
         if (flags & VK_QUERY_RESULT_WITH_AVAILABILITY_BIT) {
 
181
            *dest32 = ready;
 
182
         }
195
183
      }
196
184
   }
197
185
   return vk_result;