1 /**************************************************************************
2 *
3 * Copyright 2008 VMware, Inc.
4 * All Rights Reserved.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sub license, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
13 *
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
16 * of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
21 * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 *
26 **************************************************************************/
27
28
29 #include "util/u_memory.h"
30 #include "util/u_math.h"
31 #include "util/u_cpu_detect.h"
32 #include "util/format/u_format.h"
33 #include "util/u_screen.h"
34 #include "util/u_string.h"
35 #include "util/format/u_format_s3tc.h"
36 #include "pipe/p_defines.h"
37 #include "pipe/p_screen.h"
38 #include "draw/draw_context.h"
39 #include "gallivm/lp_bld_type.h"
40 #include "gallivm/lp_bld_nir.h"
41 #include "util/disk_cache.h"
42 #include "util/hex.h"
43 #include "util/os_misc.h"
44 #include "util/os_time.h"
45 #include "util/u_helpers.h"
46 #include "util/anon_file.h"
47 #include "lp_texture.h"
48 #include "lp_fence.h"
49 #include "lp_jit.h"
50 #include "lp_screen.h"
51 #include "lp_context.h"
52 #include "lp_debug.h"
53 #include "lp_public.h"
54 #include "lp_limits.h"
55 #include "lp_rast.h"
56 #include "lp_cs_tpool.h"
57 #include "lp_flush.h"
58
59 #include "frontend/sw_winsys.h"
60
61 #include "nir.h"
62
63 #ifdef HAVE_LIBDRM
64 #include <xf86drm.h>
65 #include <fcntl.h>
66 #endif
67
68 int LP_DEBUG = 0;
69
70 static const struct debug_named_value lp_debug_flags[] = {
71 { "pipe", DEBUG_PIPE, NULL },
72 { "tgsi", DEBUG_TGSI, NULL },
73 { "tex", DEBUG_TEX, NULL },
74 { "setup", DEBUG_SETUP, NULL },
75 { "rast", DEBUG_RAST, NULL },
76 { "query", DEBUG_QUERY, NULL },
77 { "screen", DEBUG_SCREEN, NULL },
78 { "counters", DEBUG_COUNTERS, NULL },
79 { "scene", DEBUG_SCENE, NULL },
80 { "fence", DEBUG_FENCE, NULL },
81 { "no_fastpath", DEBUG_NO_FASTPATH, NULL },
82 { "linear", DEBUG_LINEAR, NULL },
83 { "linear2", DEBUG_LINEAR2, NULL },
84 { "mem", DEBUG_MEM, NULL },
85 { "fs", DEBUG_FS, NULL },
86 { "cs", DEBUG_CS, NULL },
87 { "accurate_a0", DEBUG_ACCURATE_A0 },
88 { "mesh", DEBUG_MESH },
89 DEBUG_NAMED_VALUE_END
90 };
91
92 int LP_PERF = 0;
93 static const struct debug_named_value lp_perf_flags[] = {
94 { "texmem", PERF_TEX_MEM, NULL },
95 { "no_mipmap", PERF_NO_MIPMAPS, NULL },
96 { "no_linear", PERF_NO_LINEAR, NULL },
97 { "no_mip_linear", PERF_NO_MIP_LINEAR, NULL },
98 { "no_tex", PERF_NO_TEX, NULL },
99 { "no_blend", PERF_NO_BLEND, NULL },
100 { "no_depth", PERF_NO_DEPTH, NULL },
101 { "no_alphatest", PERF_NO_ALPHATEST, NULL },
102 { "no_rast_linear", PERF_NO_RAST_LINEAR, NULL },
103 { "no_shade", PERF_NO_SHADE, NULL },
104 DEBUG_NAMED_VALUE_END
105 };
106
107
108 static const char *
llvmpipe_get_vendor(struct pipe_screen * screen)109 llvmpipe_get_vendor(struct pipe_screen *screen)
110 {
111 return "Mesa";
112 }
113
114
115 static const char *
llvmpipe_get_name(struct pipe_screen * screen)116 llvmpipe_get_name(struct pipe_screen *screen)
117 {
118 struct llvmpipe_screen *lscreen = llvmpipe_screen(screen);
119 return lscreen->renderer_string;
120 }
121
122
123 static int
llvmpipe_get_param(struct pipe_screen * screen,enum pipe_cap param)124 llvmpipe_get_param(struct pipe_screen *screen, enum pipe_cap param)
125 {
126 #ifdef HAVE_LIBDRM
127 struct llvmpipe_screen *lscreen = llvmpipe_screen(screen);
128 #endif
129 switch (param) {
130 case PIPE_CAP_DMABUF:
131 #ifdef HAVE_LIBDRM
132 if (lscreen->winsys->get_fd)
133 return DRM_PRIME_CAP_IMPORT | DRM_PRIME_CAP_EXPORT;
134 #ifdef HAVE_LINUX_UDMABUF_H
135 if (lscreen->udmabuf_fd != -1)
136 return DRM_PRIME_CAP_IMPORT | DRM_PRIME_CAP_EXPORT;
137 else
138 return DRM_PRIME_CAP_IMPORT;
139 #endif
140 #endif
141 return 0;
142 #if defined(HAVE_LIBDRM) && defined(HAVE_LINUX_UDMABUF_H)
143 case PIPE_CAP_NATIVE_FENCE_FD:
144 return lscreen->dummy_sync_fd != -1;
145 #endif
146 case PIPE_CAP_NPOT_TEXTURES:
147 case PIPE_CAP_MIXED_FRAMEBUFFER_SIZES:
148 case PIPE_CAP_MIXED_COLOR_DEPTH_BITS:
149 case PIPE_CAP_ANISOTROPIC_FILTER:
150 return 1;
151 case PIPE_CAP_FRAGMENT_SHADER_TEXTURE_LOD:
152 case PIPE_CAP_FRAGMENT_SHADER_DERIVATIVES:
153 return 1;
154 case PIPE_CAP_MAX_DUAL_SOURCE_RENDER_TARGETS:
155 return 1;
156 case PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS:
157 return PIPE_MAX_SO_BUFFERS;
158 case PIPE_CAP_MAX_RENDER_TARGETS:
159 return PIPE_MAX_COLOR_BUFS;
160 case PIPE_CAP_OCCLUSION_QUERY:
161 case PIPE_CAP_QUERY_TIMESTAMP:
162 case PIPE_CAP_TIMER_RESOLUTION:
163 case PIPE_CAP_QUERY_TIME_ELAPSED:
164 return 1;
165 case PIPE_CAP_QUERY_PIPELINE_STATISTICS:
166 return 1;
167 case PIPE_CAP_TEXTURE_MIRROR_CLAMP:
168 case PIPE_CAP_TEXTURE_MIRROR_CLAMP_TO_EDGE:
169 return 1;
170 case PIPE_CAP_TEXTURE_SWIZZLE:
171 case PIPE_CAP_TEXTURE_SHADOW_LOD:
172 return 1;
173 case PIPE_CAP_MAX_TEXTURE_2D_SIZE:
174 return 1 << (LP_MAX_TEXTURE_2D_LEVELS - 1);
175 case PIPE_CAP_MAX_TEXTURE_3D_LEVELS:
176 return LP_MAX_TEXTURE_3D_LEVELS;
177 case PIPE_CAP_MAX_TEXTURE_CUBE_LEVELS:
178 return LP_MAX_TEXTURE_CUBE_LEVELS;
179 case PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS:
180 return LP_MAX_TEXTURE_ARRAY_LAYERS;
181 case PIPE_CAP_BLEND_EQUATION_SEPARATE:
182 return 1;
183 case PIPE_CAP_INDEP_BLEND_ENABLE:
184 return 1;
185 case PIPE_CAP_INDEP_BLEND_FUNC:
186 return 1;
187 case PIPE_CAP_FS_COORD_ORIGIN_UPPER_LEFT:
188 case PIPE_CAP_FS_COORD_PIXEL_CENTER_INTEGER:
189 case PIPE_CAP_FS_COORD_PIXEL_CENTER_HALF_INTEGER:
190 return 1;
191 case PIPE_CAP_PRIMITIVE_RESTART:
192 case PIPE_CAP_PRIMITIVE_RESTART_FIXED_INDEX:
193 return 1;
194 case PIPE_CAP_DEPTH_CLIP_DISABLE:
195 return 1;
196 case PIPE_CAP_DEPTH_CLAMP_ENABLE:
197 return 1;
198 case PIPE_CAP_SHADER_STENCIL_EXPORT:
199 return 1;
200 case PIPE_CAP_VS_INSTANCEID:
201 case PIPE_CAP_VERTEX_ELEMENT_INSTANCE_DIVISOR:
202 case PIPE_CAP_START_INSTANCE:
203 return 1;
204 case PIPE_CAP_SEAMLESS_CUBE_MAP:
205 case PIPE_CAP_SEAMLESS_CUBE_MAP_PER_TEXTURE:
206 return 1;
207 /* this is a lie could support arbitrary large offsets */
208 case PIPE_CAP_MIN_TEXTURE_GATHER_OFFSET:
209 case PIPE_CAP_MIN_TEXEL_OFFSET:
210 return -32;
211 case PIPE_CAP_MAX_TEXTURE_GATHER_OFFSET:
212 case PIPE_CAP_MAX_TEXEL_OFFSET:
213 return 31;
214 case PIPE_CAP_CONDITIONAL_RENDER:
215 case PIPE_CAP_TEXTURE_BARRIER:
216 return 1;
217 case PIPE_CAP_MAX_STREAM_OUTPUT_SEPARATE_COMPONENTS:
218 case PIPE_CAP_MAX_STREAM_OUTPUT_INTERLEAVED_COMPONENTS:
219 return 16*4;
220 case PIPE_CAP_MAX_GEOMETRY_OUTPUT_VERTICES:
221 case PIPE_CAP_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS:
222 return 1024;
223 case PIPE_CAP_MAX_VERTEX_STREAMS:
224 return 4;
225 case PIPE_CAP_MAX_VERTEX_ATTRIB_STRIDE:
226 return 2048;
227 case PIPE_CAP_STREAM_OUTPUT_PAUSE_RESUME:
228 case PIPE_CAP_STREAM_OUTPUT_INTERLEAVE_BUFFERS:
229 case PIPE_CAP_VERTEX_COLOR_UNCLAMPED:
230 case PIPE_CAP_VERTEX_COLOR_CLAMPED:
231 return 1;
232 case PIPE_CAP_GLSL_FEATURE_LEVEL_COMPATIBILITY:
233 case PIPE_CAP_GLSL_FEATURE_LEVEL:
234 return 450;
235 case PIPE_CAP_COMPUTE:
236 return GALLIVM_COROUTINES;
237 case PIPE_CAP_USER_VERTEX_BUFFERS:
238 return 1;
239 case PIPE_CAP_TGSI_TEXCOORD:
240 case PIPE_CAP_DRAW_INDIRECT:
241 return 1;
242
243 case PIPE_CAP_CUBE_MAP_ARRAY:
244 return 1;
245 case PIPE_CAP_CONSTANT_BUFFER_OFFSET_ALIGNMENT:
246 return 16;
247 case PIPE_CAP_MIN_MAP_BUFFER_ALIGNMENT:
248 return 64;
249 case PIPE_CAP_TEXTURE_BUFFER_OBJECTS:
250 return 1;
251 case PIPE_CAP_LINEAR_IMAGE_PITCH_ALIGNMENT:
252 return 1;
253 case PIPE_CAP_LINEAR_IMAGE_BASE_ADDRESS_ALIGNMENT:
254 return 1;
255 /* Adressing that many 64bpp texels fits in an i32 so this is a reasonable value */
256 case PIPE_CAP_MAX_TEXEL_BUFFER_ELEMENTS_UINT:
257 return LP_MAX_TEXEL_BUFFER_ELEMENTS;
258 case PIPE_CAP_TEXTURE_BUFFER_OFFSET_ALIGNMENT:
259 return 16;
260 case PIPE_CAP_TEXTURE_TRANSFER_MODES:
261 return 0;
262 case PIPE_CAP_MAX_VIEWPORTS:
263 return PIPE_MAX_VIEWPORTS;
264 case PIPE_CAP_ENDIANNESS:
265 return PIPE_ENDIAN_NATIVE;
266 case PIPE_CAP_TES_LAYER_VIEWPORT:
267 case PIPE_CAP_VS_LAYER_VIEWPORT:
268 return 1;
269 case PIPE_CAP_MAX_TEXTURE_GATHER_COMPONENTS:
270 return 4;
271 case PIPE_CAP_VS_WINDOW_SPACE_POSITION:
272 return 1;
273 case PIPE_CAP_FS_FINE_DERIVATIVE:
274 return 1;
275 case PIPE_CAP_TGSI_TEX_TXF_LZ:
276 case PIPE_CAP_SAMPLER_VIEW_TARGET:
277 return 1;
278 case PIPE_CAP_FAKE_SW_MSAA:
279 return 0;
280 case PIPE_CAP_TEXTURE_QUERY_LOD:
281 case PIPE_CAP_CONDITIONAL_RENDER_INVERTED:
282 case PIPE_CAP_SHADER_ARRAY_COMPONENTS:
283 case PIPE_CAP_DOUBLES:
284 case PIPE_CAP_INT64:
285 case PIPE_CAP_QUERY_SO_OVERFLOW:
286 case PIPE_CAP_TGSI_DIV:
287 return 1;
288 case PIPE_CAP_VENDOR_ID:
289 return 0xFFFFFFFF;
290 case PIPE_CAP_DEVICE_ID:
291 return 0xFFFFFFFF;
292 case PIPE_CAP_ACCELERATED:
293 return 0;
294 case PIPE_CAP_VIDEO_MEMORY: {
295 /* XXX: Do we want to return the full amount fo system memory ? */
296 uint64_t system_memory;
297
298 if (!os_get_total_physical_memory(&system_memory))
299 return 0;
300
301 if (sizeof(void *) == 4)
302 /* Cap to 2 GB on 32 bits system. We do this because llvmpipe does
303 * eat application memory, which is quite limited on 32 bits. App
304 * shouldn't expect too much available memory. */
305 system_memory = MIN2(system_memory, 2048 << 20);
306
307 return (int)(system_memory >> 20);
308 }
309 case PIPE_CAP_UMA:
310 return 1;
311 case PIPE_CAP_QUERY_MEMORY_INFO:
312 return 1;
313 case PIPE_CAP_CLIP_HALFZ:
314 return 1;
315 case PIPE_CAP_POLYGON_OFFSET_CLAMP:
316 case PIPE_CAP_TEXTURE_FLOAT_LINEAR:
317 case PIPE_CAP_TEXTURE_HALF_FLOAT_LINEAR:
318 return 1;
319 case PIPE_CAP_CULL_DISTANCE:
320 return 1;
321 case PIPE_CAP_COPY_BETWEEN_COMPRESSED_AND_PLAIN_FORMATS:
322 return 1;
323 case PIPE_CAP_MAX_VARYINGS:
324 return 32;
325 case PIPE_CAP_SHADER_BUFFER_OFFSET_ALIGNMENT:
326 return 16;
327 case PIPE_CAP_QUERY_BUFFER_OBJECT:
328 return 1;
329 case PIPE_CAP_DRAW_PARAMETERS:
330 return 1;
331 case PIPE_CAP_FBFETCH:
332 return 8;
333 case PIPE_CAP_FBFETCH_COHERENT:
334 case PIPE_CAP_FBFETCH_ZS:
335 case PIPE_CAP_MULTI_DRAW_INDIRECT:
336 case PIPE_CAP_MULTI_DRAW_INDIRECT_PARAMS:
337 return 1;
338 case PIPE_CAP_DEVICE_RESET_STATUS_QUERY:
339 case PIPE_CAP_ROBUST_BUFFER_ACCESS_BEHAVIOR:
340 return 1;
341 case PIPE_CAP_MAX_SHADER_PATCH_VARYINGS:
342 return 32;
343 case PIPE_CAP_RASTERIZER_SUBPIXEL_BITS:
344 return 8;
345 case PIPE_CAP_PCI_GROUP:
346 case PIPE_CAP_PCI_BUS:
347 case PIPE_CAP_PCI_DEVICE:
348 case PIPE_CAP_PCI_FUNCTION:
349 case PIPE_CAP_ALLOW_MAPPED_BUFFERS_DURING_EXECUTION:
350 return 0;
351
352 case PIPE_CAP_SHAREABLE_SHADERS:
353 /* Can't expose shareable shaders because the draw shaders reference the
354 * draw module's state, which is per-context.
355 */
356 return 0;
357 case PIPE_CAP_MAX_GS_INVOCATIONS:
358 return 32;
359 case PIPE_CAP_MAX_SHADER_BUFFER_SIZE_UINT:
360 return LP_MAX_TGSI_SHADER_BUFFER_SIZE;
361 case PIPE_CAP_FRAMEBUFFER_NO_ATTACHMENT:
362 case PIPE_CAP_TGSI_TG4_COMPONENT_IN_SWIZZLE:
363 case PIPE_CAP_FS_FACE_IS_INTEGER_SYSVAL:
364 case PIPE_CAP_RESOURCE_FROM_USER_MEMORY:
365 case PIPE_CAP_IMAGE_STORE_FORMATTED:
366 case PIPE_CAP_IMAGE_LOAD_FORMATTED:
367 return 1;
368 #ifdef PIPE_MEMORY_FD
369 case PIPE_CAP_MEMOBJ:
370 return 1;
371 #endif
372 case PIPE_CAP_SAMPLER_REDUCTION_MINMAX:
373 case PIPE_CAP_TEXTURE_QUERY_SAMPLES:
374 case PIPE_CAP_SHADER_GROUP_VOTE:
375 case PIPE_CAP_SHADER_BALLOT:
376 case PIPE_CAP_IMAGE_ATOMIC_FLOAT_ADD:
377 case PIPE_CAP_LOAD_CONSTBUF:
378 case PIPE_CAP_TEXTURE_MULTISAMPLE:
379 case PIPE_CAP_SAMPLE_SHADING:
380 case PIPE_CAP_GL_SPIRV:
381 case PIPE_CAP_POST_DEPTH_COVERAGE:
382 case PIPE_CAP_SHADER_CLOCK:
383 case PIPE_CAP_PACKED_UNIFORMS:
384 return 1;
385 case PIPE_CAP_SYSTEM_SVM:
386 return 1;
387 case PIPE_CAP_ATOMIC_FLOAT_MINMAX:
388 return LLVM_VERSION_MAJOR >= 15;
389 case PIPE_CAP_NIR_IMAGES_AS_DEREF:
390 return 0;
391 default:
392 return u_pipe_screen_get_param_defaults(screen, param);
393 }
394 }
395
396
397 static int
llvmpipe_get_shader_param(struct pipe_screen * screen,enum pipe_shader_type shader,enum pipe_shader_cap param)398 llvmpipe_get_shader_param(struct pipe_screen *screen,
399 enum pipe_shader_type shader,
400 enum pipe_shader_cap param)
401 {
402 struct llvmpipe_screen *lscreen = llvmpipe_screen(screen);
403 switch (shader) {
404 case PIPE_SHADER_COMPUTE:
405 if ((lscreen->allow_cl) && param == PIPE_SHADER_CAP_SUPPORTED_IRS)
406 return ((1 << PIPE_SHADER_IR_TGSI) |
407 (1 << PIPE_SHADER_IR_NIR) |
408 (1 << PIPE_SHADER_IR_NIR_SERIALIZED));
409 FALLTHROUGH;
410 case PIPE_SHADER_MESH:
411 case PIPE_SHADER_TASK:
412 case PIPE_SHADER_FRAGMENT:
413 return gallivm_get_shader_param(param);
414 case PIPE_SHADER_TESS_CTRL:
415 case PIPE_SHADER_TESS_EVAL:
416 /* Tessellation shader needs llvm coroutines support */
417 if (!GALLIVM_COROUTINES)
418 return 0;
419 FALLTHROUGH;
420 case PIPE_SHADER_VERTEX:
421 case PIPE_SHADER_GEOMETRY:
422 switch (param) {
423 case PIPE_SHADER_CAP_MAX_TEXTURE_SAMPLERS:
424 /* At this time, the draw module and llvmpipe driver only
425 * support vertex shader texture lookups when LLVM is enabled in
426 * the draw module.
427 */
428 if (debug_get_bool_option("DRAW_USE_LLVM", true))
429 return PIPE_MAX_SAMPLERS;
430 else
431 return 0;
432 case PIPE_SHADER_CAP_MAX_SAMPLER_VIEWS:
433 if (debug_get_bool_option("DRAW_USE_LLVM", true))
434 return PIPE_MAX_SHADER_SAMPLER_VIEWS;
435 else
436 return 0;
437 case PIPE_SHADER_CAP_MAX_CONST_BUFFERS:
438 if (debug_get_bool_option("DRAW_USE_LLVM", false))
439 return LP_MAX_TGSI_CONST_BUFFERS;
440 else
441 return draw_get_shader_param(shader, param);
442 default:
443 return draw_get_shader_param(shader, param);
444 }
445 default:
446 return 0;
447 }
448 }
449
450
451 static float
llvmpipe_get_paramf(struct pipe_screen * screen,enum pipe_capf param)452 llvmpipe_get_paramf(struct pipe_screen *screen, enum pipe_capf param)
453 {
454 switch (param) {
455 case PIPE_CAPF_MIN_LINE_WIDTH:
456 case PIPE_CAPF_MIN_LINE_WIDTH_AA:
457 case PIPE_CAPF_MIN_POINT_SIZE:
458 case PIPE_CAPF_MIN_POINT_SIZE_AA:
459 return 1.0;
460 case PIPE_CAPF_POINT_SIZE_GRANULARITY:
461 case PIPE_CAPF_LINE_WIDTH_GRANULARITY:
462 return 0.1;
463 case PIPE_CAPF_MAX_LINE_WIDTH:
464 FALLTHROUGH;
465 case PIPE_CAPF_MAX_LINE_WIDTH_AA:
466 return 255.0; /* arbitrary */
467 case PIPE_CAPF_MAX_POINT_SIZE:
468 FALLTHROUGH;
469 case PIPE_CAPF_MAX_POINT_SIZE_AA:
470 return LP_MAX_POINT_WIDTH; /* arbitrary */
471 case PIPE_CAPF_MAX_TEXTURE_ANISOTROPY:
472 return 16.0; /* not actually signficant at this time */
473 case PIPE_CAPF_MAX_TEXTURE_LOD_BIAS:
474 return 16.0; /* arbitrary */
475 case PIPE_CAPF_MIN_CONSERVATIVE_RASTER_DILATE:
476 return 0.0;
477 case PIPE_CAPF_MAX_CONSERVATIVE_RASTER_DILATE:
478 return 0.0;
479 case PIPE_CAPF_CONSERVATIVE_RASTER_DILATE_GRANULARITY:
480 return 0.0;
481 }
482 /* should only get here on unhandled cases */
483 debug_printf("Unexpected PIPE_CAP %d query\n", param);
484 return 0.0;
485 }
486
487
488 static int
llvmpipe_get_compute_param(struct pipe_screen * _screen,enum pipe_shader_ir ir_type,enum pipe_compute_cap param,void * ret)489 llvmpipe_get_compute_param(struct pipe_screen *_screen,
490 enum pipe_shader_ir ir_type,
491 enum pipe_compute_cap param,
492 void *ret)
493 {
494 switch (param) {
495 case PIPE_COMPUTE_CAP_IR_TARGET:
496 return 0;
497 case PIPE_COMPUTE_CAP_MAX_GRID_SIZE:
498 if (ret) {
499 uint64_t *grid_size = ret;
500 grid_size[0] = 65535;
501 grid_size[1] = 65535;
502 grid_size[2] = 65535;
503 }
504 return 3 * sizeof(uint64_t) ;
505 case PIPE_COMPUTE_CAP_MAX_BLOCK_SIZE:
506 if (ret) {
507 uint64_t *block_size = ret;
508 block_size[0] = 1024;
509 block_size[1] = 1024;
510 block_size[2] = 1024;
511 }
512 return 3 * sizeof(uint64_t);
513 case PIPE_COMPUTE_CAP_MAX_THREADS_PER_BLOCK:
514 if (ret) {
515 uint64_t *max_threads_per_block = ret;
516 *max_threads_per_block = 1024;
517 }
518 return sizeof(uint64_t);
519 case PIPE_COMPUTE_CAP_MAX_LOCAL_SIZE:
520 if (ret) {
521 uint64_t *max_local_size = ret;
522 *max_local_size = 32768;
523 }
524 return sizeof(uint64_t);
525 case PIPE_COMPUTE_CAP_GRID_DIMENSION:
526 if (ret) {
527 uint64_t *grid_dim = ret;
528 *grid_dim = 3;
529 }
530 return sizeof(uint64_t);
531 case PIPE_COMPUTE_CAP_MAX_GLOBAL_SIZE:
532 if (ret) {
533 uint64_t *max_global_size = ret;
534 *max_global_size = (1ULL << 31);
535 }
536 return sizeof(uint64_t);
537 case PIPE_COMPUTE_CAP_MAX_MEM_ALLOC_SIZE:
538 if (ret) {
539 uint64_t *max_mem_alloc_size = ret;
540 *max_mem_alloc_size = (1ULL << 31);
541 }
542 return sizeof(uint64_t);
543 case PIPE_COMPUTE_CAP_MAX_PRIVATE_SIZE:
544 if (ret) {
545 uint64_t *max_private = ret;
546 *max_private = (1UL << 31);
547 }
548 return sizeof(uint64_t);
549 case PIPE_COMPUTE_CAP_MAX_INPUT_SIZE:
550 if (ret) {
551 uint64_t *max_input = ret;
552 *max_input = 1576;
553 }
554 return sizeof(uint64_t);
555 case PIPE_COMPUTE_CAP_IMAGES_SUPPORTED:
556 if (ret) {
557 uint32_t *images = ret;
558 *images = LP_MAX_TGSI_SHADER_IMAGES;
559 }
560 return sizeof(uint32_t);
561 case PIPE_COMPUTE_CAP_MAX_VARIABLE_THREADS_PER_BLOCK:
562 return 0;
563 case PIPE_COMPUTE_CAP_SUBGROUP_SIZES:
564 if (ret) {
565 uint32_t *subgroup_size = ret;
566 *subgroup_size = lp_native_vector_width / 32;
567 }
568 return sizeof(uint32_t);
569 case PIPE_COMPUTE_CAP_MAX_SUBGROUPS:
570 if (ret) {
571 uint32_t *subgroup_size = ret;
572 *subgroup_size = 1024 / (lp_native_vector_width / 32);
573 }
574 return sizeof(uint32_t);
575 case PIPE_COMPUTE_CAP_MAX_COMPUTE_UNITS:
576 if (ret) {
577 uint32_t *max_compute_units = ret;
578 *max_compute_units = 8;
579 }
580 return sizeof(uint32_t);
581 case PIPE_COMPUTE_CAP_MAX_CLOCK_FREQUENCY:
582 if (ret) {
583 uint32_t *max_clock_freq = ret;
584 *max_clock_freq = 300;
585 }
586 return sizeof(uint32_t);
587 case PIPE_COMPUTE_CAP_ADDRESS_BITS:
588 if (ret) {
589 uint32_t *address_bits = ret;
590 *address_bits = sizeof(void*) * 8;
591 }
592 return sizeof(uint32_t);
593 }
594 return 0;
595 }
596
597
598 static void
llvmpipe_get_driver_uuid(struct pipe_screen * pscreen,char * uuid)599 llvmpipe_get_driver_uuid(struct pipe_screen *pscreen, char *uuid)
600 {
601 memset(uuid, 0, PIPE_UUID_SIZE);
602 snprintf(uuid, PIPE_UUID_SIZE, "llvmpipeUUID");
603 }
604
605
606 static void
llvmpipe_get_device_uuid(struct pipe_screen * pscreen,char * uuid)607 llvmpipe_get_device_uuid(struct pipe_screen *pscreen, char *uuid)
608 {
609 memset(uuid, 0, PIPE_UUID_SIZE);
610 #if defined(__clang__)
611 #pragma GCC diagnostic push
612 #pragma GCC diagnostic ignored "-Wunknown-warning-option"
613 #pragma GCC diagnostic ignored "-Wformat-truncation"
614 #endif /* __clang__ */
615 snprintf(uuid, PIPE_UUID_SIZE, "mesa" PACKAGE_VERSION);
616 #if defined(__clang__)
617 #pragma GCC diagnostic pop
618 #endif /* __clang__ */
619 }
620
621
622 static const struct nir_shader_compiler_options gallivm_nir_options = {
623 .lower_scmp = true,
624 .lower_flrp32 = true,
625 .lower_flrp64 = true,
626 .lower_fsat = true,
627 .lower_bitfield_insert = true,
628 .lower_bitfield_extract = true,
629 .lower_fdot = true,
630 .lower_fdph = true,
631 .lower_ffma16 = true,
632 .lower_ffma32 = true,
633 .lower_ffma64 = true,
634 .lower_flrp16 = true,
635 .lower_fmod = true,
636 .lower_hadd = true,
637 .lower_uadd_sat = true,
638 .lower_usub_sat = true,
639 .lower_iadd_sat = true,
640 .lower_ldexp = true,
641 .lower_pack_snorm_2x16 = true,
642 .lower_pack_snorm_4x8 = true,
643 .lower_pack_unorm_2x16 = true,
644 .lower_pack_unorm_4x8 = true,
645 .lower_pack_half_2x16 = true,
646 .lower_pack_split = true,
647 .lower_unpack_snorm_2x16 = true,
648 .lower_unpack_snorm_4x8 = true,
649 .lower_unpack_unorm_2x16 = true,
650 .lower_unpack_unorm_4x8 = true,
651 .lower_unpack_half_2x16 = true,
652 .lower_extract_byte = true,
653 .lower_extract_word = true,
654 .lower_insert_byte = true,
655 .lower_insert_word = true,
656 .lower_uadd_carry = true,
657 .lower_usub_borrow = true,
658 .lower_mul_2x32_64 = true,
659 .lower_ifind_msb = true,
660 .lower_int64_options = nir_lower_imul_2x32_64,
661 .lower_doubles_options = nir_lower_dround_even,
662 .max_unroll_iterations = 32,
663 .use_interpolated_input_intrinsics = true,
664 .lower_to_scalar = true,
665 .lower_uniforms_to_ubo = true,
666 .lower_vector_cmp = true,
667 .lower_device_index_to_zero = true,
668 .support_16bit_alu = true,
669 .lower_fisnormal = true,
670 .lower_fquantize2f16 = true,
671 .driver_functions = true,
672 .has_ddx_intrinsics = true,
673 .scalarize_ddx = true,
674 };
675
676
677 static char *
llvmpipe_finalize_nir(struct pipe_screen * screen,void * nirptr)678 llvmpipe_finalize_nir(struct pipe_screen *screen,
679 void *nirptr)
680 {
681 struct nir_shader *nir = (struct nir_shader *)nirptr;
682 lp_build_opt_nir(nir);
683 return NULL;
684 }
685
686
687 static inline const void *
llvmpipe_get_compiler_options(struct pipe_screen * screen,enum pipe_shader_ir ir,enum pipe_shader_type shader)688 llvmpipe_get_compiler_options(struct pipe_screen *screen,
689 enum pipe_shader_ir ir,
690 enum pipe_shader_type shader)
691 {
692 assert(ir == PIPE_SHADER_IR_NIR);
693 return &gallivm_nir_options;
694 }
695
696
697 bool
lp_storage_render_image_format_supported(enum pipe_format format)698 lp_storage_render_image_format_supported(enum pipe_format format)
699 {
700 const struct util_format_description *format_desc = util_format_description(format);
701
702 if (format_desc->colorspace == UTIL_FORMAT_COLORSPACE_SRGB) {
703 /* this is a lie actually other formats COULD exist where we would fail */
704 if (format_desc->nr_channels < 3)
705 return false;
706 } else if (format_desc->colorspace != UTIL_FORMAT_COLORSPACE_RGB) {
707 return false;
708 }
709
710 if (format_desc->layout != UTIL_FORMAT_LAYOUT_PLAIN &&
711 format != PIPE_FORMAT_R11G11B10_FLOAT)
712 return false;
713
714 assert(format_desc->block.width == 1);
715 assert(format_desc->block.height == 1);
716
717 if (format_desc->is_mixed)
718 return false;
719
720 if (!format_desc->is_array && !format_desc->is_bitmask &&
721 format != PIPE_FORMAT_R11G11B10_FLOAT)
722 return false;
723
724 return true;
725 }
726
727
728 bool
lp_storage_image_format_supported(enum pipe_format format)729 lp_storage_image_format_supported(enum pipe_format format)
730 {
731 switch (format) {
732 case PIPE_FORMAT_R32G32B32A32_FLOAT:
733 case PIPE_FORMAT_R16G16B16A16_FLOAT:
734 case PIPE_FORMAT_R32G32_FLOAT:
735 case PIPE_FORMAT_R16G16_FLOAT:
736 case PIPE_FORMAT_R11G11B10_FLOAT:
737 case PIPE_FORMAT_R32_FLOAT:
738 case PIPE_FORMAT_R16_FLOAT:
739 case PIPE_FORMAT_R32G32B32A32_UINT:
740 case PIPE_FORMAT_R16G16B16A16_UINT:
741 case PIPE_FORMAT_R10G10B10A2_UINT:
742 case PIPE_FORMAT_R8G8B8A8_UINT:
743 case PIPE_FORMAT_R32G32_UINT:
744 case PIPE_FORMAT_R16G16_UINT:
745 case PIPE_FORMAT_R8G8_UINT:
746 case PIPE_FORMAT_R32_UINT:
747 case PIPE_FORMAT_R16_UINT:
748 case PIPE_FORMAT_R8_UINT:
749 case PIPE_FORMAT_R32G32B32A32_SINT:
750 case PIPE_FORMAT_R16G16B16A16_SINT:
751 case PIPE_FORMAT_R8G8B8A8_SINT:
752 case PIPE_FORMAT_R32G32_SINT:
753 case PIPE_FORMAT_R16G16_SINT:
754 case PIPE_FORMAT_R8G8_SINT:
755 case PIPE_FORMAT_R32_SINT:
756 case PIPE_FORMAT_R16_SINT:
757 case PIPE_FORMAT_R8_SINT:
758 case PIPE_FORMAT_R16G16B16A16_UNORM:
759 case PIPE_FORMAT_R10G10B10A2_UNORM:
760 case PIPE_FORMAT_R8G8B8A8_UNORM:
761 case PIPE_FORMAT_R16G16_UNORM:
762 case PIPE_FORMAT_R8G8_UNORM:
763 case PIPE_FORMAT_R16_UNORM:
764 case PIPE_FORMAT_R8_UNORM:
765 case PIPE_FORMAT_R16G16B16A16_SNORM:
766 case PIPE_FORMAT_R8G8B8A8_SNORM:
767 case PIPE_FORMAT_R16G16_SNORM:
768 case PIPE_FORMAT_R8G8_SNORM:
769 case PIPE_FORMAT_R16_SNORM:
770 case PIPE_FORMAT_R8_SNORM:
771 case PIPE_FORMAT_B8G8R8A8_UNORM:
772 case PIPE_FORMAT_A8_UNORM:
773 return true;
774 default:
775 return false;
776 }
777 }
778
779
780 /**
781 * Query format support for creating a texture, drawing surface, etc.
782 * \param format the format to test
783 * \param type one of PIPE_TEXTURE, PIPE_SURFACE
784 */
785 static bool
llvmpipe_is_format_supported(struct pipe_screen * _screen,enum pipe_format format,enum pipe_texture_target target,unsigned sample_count,unsigned storage_sample_count,unsigned bind)786 llvmpipe_is_format_supported(struct pipe_screen *_screen,
787 enum pipe_format format,
788 enum pipe_texture_target target,
789 unsigned sample_count,
790 unsigned storage_sample_count,
791 unsigned bind)
792 {
793 struct llvmpipe_screen *screen = llvmpipe_screen(_screen);
794 struct sw_winsys *winsys = screen->winsys;
795 const struct util_format_description *format_desc =
796 util_format_description(format);
797
798 assert(target == PIPE_BUFFER ||
799 target == PIPE_TEXTURE_1D ||
800 target == PIPE_TEXTURE_1D_ARRAY ||
801 target == PIPE_TEXTURE_2D ||
802 target == PIPE_TEXTURE_2D_ARRAY ||
803 target == PIPE_TEXTURE_RECT ||
804 target == PIPE_TEXTURE_3D ||
805 target == PIPE_TEXTURE_CUBE ||
806 target == PIPE_TEXTURE_CUBE_ARRAY);
807
808 if (sample_count != 0 && sample_count != 1 && sample_count != 4)
809 return false;
810
811 if (bind & (PIPE_BIND_RENDER_TARGET | PIPE_BIND_SHADER_IMAGE))
812 if (!lp_storage_render_image_format_supported(format))
813 return false;
814
815 if (bind & PIPE_BIND_SHADER_IMAGE) {
816 if (!lp_storage_image_format_supported(format))
817 return false;
818 }
819
820 if ((bind & (PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW)) &&
821 ((bind & PIPE_BIND_DISPLAY_TARGET) == 0)) {
822 /* Disable all 3-channel formats, where channel size != 32 bits.
823 * In some cases we run into crashes (in generate_unswizzled_blend()),
824 * for 3-channel RGB16 variants, there was an apparent LLVM bug.
825 * In any case, disabling the shallower 3-channel formats avoids a
826 * number of issues with GL_ARB_copy_image support.
827 */
828 if (format_desc->is_array &&
829 format_desc->nr_channels == 3 &&
830 format_desc->block.bits != 96) {
831 return false;
832 }
833
834 /* Disable 64-bit integer formats for RT/samplers.
835 * VK CTS crashes with these and they don't make much sense.
836 */
837 int c = util_format_get_first_non_void_channel(format_desc->format);
838 if (c >= 0) {
839 if (format_desc->channel[c].pure_integer &&
840 format_desc->channel[c].size == 64)
841 return false;
842 }
843
844 }
845
846 if (!(bind & PIPE_BIND_VERTEX_BUFFER) &&
847 util_format_is_scaled(format))
848 return false;
849
850 if (bind & PIPE_BIND_DISPLAY_TARGET) {
851 if (!winsys->is_displaytarget_format_supported(winsys, bind, format))
852 return false;
853 }
854
855 if (bind & PIPE_BIND_DEPTH_STENCIL) {
856 if (format_desc->layout != UTIL_FORMAT_LAYOUT_PLAIN)
857 return false;
858
859 if (format_desc->colorspace != UTIL_FORMAT_COLORSPACE_ZS)
860 return false;
861 }
862
863 if (format_desc->layout == UTIL_FORMAT_LAYOUT_ASTC ||
864 format_desc->layout == UTIL_FORMAT_LAYOUT_ATC) {
865 /* Software decoding is not hooked up. */
866 return false;
867 }
868
869 if (format_desc->layout == UTIL_FORMAT_LAYOUT_ETC &&
870 format != PIPE_FORMAT_ETC1_RGB8)
871 return false;
872
873 /* planar not supported natively */
874 if ((format_desc->layout == UTIL_FORMAT_LAYOUT_SUBSAMPLED ||
875 format_desc->layout == UTIL_FORMAT_LAYOUT_PLANAR2 ||
876 format_desc->layout == UTIL_FORMAT_LAYOUT_PLANAR3) &&
877 target == PIPE_BUFFER)
878 return false;
879
880 if (format_desc->colorspace == UTIL_FORMAT_COLORSPACE_YUV) {
881 if (format == PIPE_FORMAT_UYVY ||
882 format == PIPE_FORMAT_YUYV ||
883 format == PIPE_FORMAT_NV12)
884 return true;
885 return false;
886 }
887
888 /*
889 * Everything can be supported by u_format
890 * (those without fetch_rgba_float might be not but shouldn't hit that)
891 */
892
893 return true;
894 }
895
896
897 static void
llvmpipe_flush_frontbuffer(struct pipe_screen * _screen,struct pipe_context * _pipe,struct pipe_resource * resource,unsigned level,unsigned layer,void * context_private,unsigned nboxes,struct pipe_box * sub_box)898 llvmpipe_flush_frontbuffer(struct pipe_screen *_screen,
899 struct pipe_context *_pipe,
900 struct pipe_resource *resource,
901 unsigned level, unsigned layer,
902 void *context_private,
903 unsigned nboxes,
904 struct pipe_box *sub_box)
905 {
906 struct llvmpipe_screen *screen = llvmpipe_screen(_screen);
907 struct sw_winsys *winsys = screen->winsys;
908 struct llvmpipe_resource *texture = llvmpipe_resource(resource);
909
910 assert(texture->dt);
911
912 if (texture->dt) {
913 if (_pipe)
914 llvmpipe_flush_resource(_pipe, resource, 0, true, true,
915 false, "frontbuffer");
916 winsys->displaytarget_display(winsys, texture->dt,
917 context_private, nboxes, sub_box);
918 }
919 }
920
921
922 static void
llvmpipe_destroy_screen(struct pipe_screen * _screen)923 llvmpipe_destroy_screen(struct pipe_screen *_screen)
924 {
925 struct llvmpipe_screen *screen = llvmpipe_screen(_screen);
926
927 if (screen->cs_tpool)
928 lp_cs_tpool_destroy(screen->cs_tpool);
929
930 if (screen->rast)
931 lp_rast_destroy(screen->rast);
932
933 lp_jit_screen_cleanup(screen);
934
935 disk_cache_destroy(screen->disk_shader_cache);
936
937 glsl_type_singleton_decref();
938
939 #ifdef HAVE_LIBDRM
940 close(screen->udmabuf_fd);
941 #endif
942
943 #if DETECT_OS_LINUX
944 util_vma_heap_finish(&screen->mem_heap);
945
946 close(screen->fd_mem_alloc);
947 mtx_destroy(&screen->mem_mutex);
948 #endif
949 mtx_destroy(&screen->rast_mutex);
950 mtx_destroy(&screen->cs_mutex);
951 FREE(screen);
952 }
953
954
955 /**
956 * Fence reference counting.
957 */
958 static void
llvmpipe_fence_reference(struct pipe_screen * screen,struct pipe_fence_handle ** ptr,struct pipe_fence_handle * fence)959 llvmpipe_fence_reference(struct pipe_screen *screen,
960 struct pipe_fence_handle **ptr,
961 struct pipe_fence_handle *fence)
962 {
963 struct lp_fence **old = (struct lp_fence **) ptr;
964 struct lp_fence *f = (struct lp_fence *) fence;
965
966 lp_fence_reference(old, f);
967 }
968
969
970 /**
971 * Wait for the fence to finish.
972 */
973 static bool
llvmpipe_fence_finish(struct pipe_screen * screen,struct pipe_context * ctx,struct pipe_fence_handle * fence_handle,uint64_t timeout)974 llvmpipe_fence_finish(struct pipe_screen *screen,
975 struct pipe_context *ctx,
976 struct pipe_fence_handle *fence_handle,
977 uint64_t timeout)
978 {
979 struct lp_fence *f = (struct lp_fence *) fence_handle;
980
981 if (!timeout)
982 return lp_fence_signalled(f);
983
984 if (!lp_fence_signalled(f)) {
985 if (timeout != OS_TIMEOUT_INFINITE)
986 return lp_fence_timedwait(f, timeout);
987
988 lp_fence_wait(f);
989 }
990 return true;
991 }
992
993
994 static void
update_cache_sha1_cpu(struct mesa_sha1 * ctx)995 update_cache_sha1_cpu(struct mesa_sha1 *ctx)
996 {
997 const struct util_cpu_caps_t *cpu_caps = util_get_cpu_caps();
998 /*
999 * Don't need the cpu cache affinity stuff. The rest
1000 * is contained in first 6 dwords.
1001 */
1002 STATIC_ASSERT(offsetof(struct util_cpu_caps_t, num_L3_caches)
1003 == 6 * sizeof(uint32_t));
1004 _mesa_sha1_update(ctx, cpu_caps, 6 * sizeof(uint32_t));
1005 }
1006
1007
1008 static void
lp_disk_cache_create(struct llvmpipe_screen * screen)1009 lp_disk_cache_create(struct llvmpipe_screen *screen)
1010 {
1011 struct mesa_sha1 ctx;
1012 unsigned gallivm_perf = gallivm_get_perf_flags();
1013 unsigned char sha1[20];
1014 char cache_id[20 * 2 + 1];
1015 _mesa_sha1_init(&ctx);
1016
1017 if (!disk_cache_get_function_identifier(lp_disk_cache_create, &ctx) ||
1018 !disk_cache_get_function_identifier(LLVMLinkInMCJIT, &ctx))
1019 return;
1020
1021 _mesa_sha1_update(&ctx, &gallivm_perf, sizeof(gallivm_perf));
1022 update_cache_sha1_cpu(&ctx);
1023 _mesa_sha1_final(&ctx, sha1);
1024 mesa_bytes_to_hex(cache_id, sha1, 20);
1025
1026 screen->disk_shader_cache = disk_cache_create("llvmpipe", cache_id, 0);
1027 }
1028
1029
1030 static struct disk_cache *
lp_get_disk_shader_cache(struct pipe_screen * _screen)1031 lp_get_disk_shader_cache(struct pipe_screen *_screen)
1032 {
1033 struct llvmpipe_screen *screen = llvmpipe_screen(_screen);
1034
1035 return screen->disk_shader_cache;
1036 }
1037
1038 static int
llvmpipe_screen_get_fd(struct pipe_screen * _screen)1039 llvmpipe_screen_get_fd(struct pipe_screen *_screen)
1040 {
1041 struct llvmpipe_screen *screen = llvmpipe_screen(_screen);
1042 struct sw_winsys *winsys = screen->winsys;
1043
1044 if (winsys->get_fd)
1045 return winsys->get_fd(winsys);
1046 else
1047 return -1;
1048 }
1049
1050
1051 void
lp_disk_cache_find_shader(struct llvmpipe_screen * screen,struct lp_cached_code * cache,unsigned char ir_sha1_cache_key[20])1052 lp_disk_cache_find_shader(struct llvmpipe_screen *screen,
1053 struct lp_cached_code *cache,
1054 unsigned char ir_sha1_cache_key[20])
1055 {
1056 unsigned char sha1[CACHE_KEY_SIZE];
1057
1058 if (!screen->disk_shader_cache)
1059 return;
1060 disk_cache_compute_key(screen->disk_shader_cache, ir_sha1_cache_key,
1061 20, sha1);
1062
1063 size_t binary_size;
1064 uint8_t *buffer = disk_cache_get(screen->disk_shader_cache,
1065 sha1, &binary_size);
1066 if (!buffer) {
1067 cache->data_size = 0;
1068 return;
1069 }
1070 cache->data_size = binary_size;
1071 cache->data = buffer;
1072 }
1073
1074
1075 void
lp_disk_cache_insert_shader(struct llvmpipe_screen * screen,struct lp_cached_code * cache,unsigned char ir_sha1_cache_key[20])1076 lp_disk_cache_insert_shader(struct llvmpipe_screen *screen,
1077 struct lp_cached_code *cache,
1078 unsigned char ir_sha1_cache_key[20])
1079 {
1080 unsigned char sha1[CACHE_KEY_SIZE];
1081
1082 if (!screen->disk_shader_cache || !cache->data_size || cache->dont_cache)
1083 return;
1084 disk_cache_compute_key(screen->disk_shader_cache, ir_sha1_cache_key,
1085 20, sha1);
1086 disk_cache_put(screen->disk_shader_cache, sha1, cache->data,
1087 cache->data_size, NULL);
1088 }
1089
1090
1091 bool
llvmpipe_screen_late_init(struct llvmpipe_screen * screen)1092 llvmpipe_screen_late_init(struct llvmpipe_screen *screen)
1093 {
1094 bool ret = true;
1095 mtx_lock(&screen->late_mutex);
1096
1097 if (screen->late_init_done)
1098 goto out;
1099
1100 screen->rast = lp_rast_create(screen->num_threads);
1101 if (!screen->rast) {
1102 ret = false;
1103 goto out;
1104 }
1105
1106 screen->cs_tpool = lp_cs_tpool_create(screen->num_threads);
1107 if (!screen->cs_tpool) {
1108 lp_rast_destroy(screen->rast);
1109 ret = false;
1110 goto out;
1111 }
1112
1113 if (!lp_jit_screen_init(screen)) {
1114 ret = false;
1115 goto out;
1116 }
1117
1118 lp_build_init(); /* get lp_native_vector_width initialised */
1119
1120 lp_disk_cache_create(screen);
1121 screen->late_init_done = true;
1122 out:
1123 mtx_unlock(&screen->late_mutex);
1124 return ret;
1125 }
1126
1127
1128 /**
1129 * Create a new pipe_screen object
1130 * Note: we're not presently subclassing pipe_screen (no llvmpipe_screen).
1131 */
1132 struct pipe_screen *
llvmpipe_create_screen(struct sw_winsys * winsys)1133 llvmpipe_create_screen(struct sw_winsys *winsys)
1134 {
1135 struct llvmpipe_screen *screen;
1136
1137 glsl_type_singleton_init_or_ref();
1138
1139 LP_DEBUG = debug_get_flags_option("LP_DEBUG", lp_debug_flags, 0 );
1140
1141 LP_PERF = debug_get_flags_option("LP_PERF", lp_perf_flags, 0 );
1142
1143 screen = CALLOC_STRUCT(llvmpipe_screen);
1144 if (!screen)
1145 return NULL;
1146
1147 screen->winsys = winsys;
1148
1149 screen->base.destroy = llvmpipe_destroy_screen;
1150
1151 screen->base.get_name = llvmpipe_get_name;
1152 screen->base.get_vendor = llvmpipe_get_vendor;
1153 screen->base.get_device_vendor = llvmpipe_get_vendor; // TODO should be the CPU vendor
1154 screen->base.get_screen_fd = llvmpipe_screen_get_fd;
1155 screen->base.get_param = llvmpipe_get_param;
1156 screen->base.get_shader_param = llvmpipe_get_shader_param;
1157 screen->base.get_compute_param = llvmpipe_get_compute_param;
1158 screen->base.get_paramf = llvmpipe_get_paramf;
1159 screen->base.get_compiler_options = llvmpipe_get_compiler_options;
1160 screen->base.is_format_supported = llvmpipe_is_format_supported;
1161
1162 screen->base.context_create = llvmpipe_create_context;
1163 screen->base.flush_frontbuffer = llvmpipe_flush_frontbuffer;
1164 screen->base.fence_reference = llvmpipe_fence_reference;
1165 screen->base.fence_finish = llvmpipe_fence_finish;
1166
1167 screen->base.get_timestamp = u_default_get_timestamp;
1168
1169 screen->base.query_memory_info = util_sw_query_memory_info;
1170
1171 screen->base.get_driver_uuid = llvmpipe_get_driver_uuid;
1172 screen->base.get_device_uuid = llvmpipe_get_device_uuid;
1173
1174 screen->base.finalize_nir = llvmpipe_finalize_nir;
1175
1176 screen->base.get_disk_shader_cache = lp_get_disk_shader_cache;
1177 llvmpipe_init_screen_resource_funcs(&screen->base);
1178
1179 screen->allow_cl = !!getenv("LP_CL");
1180 screen->num_threads = util_get_cpu_caps()->nr_cpus > 1
1181 ? util_get_cpu_caps()->nr_cpus : 0;
1182 screen->num_threads = debug_get_num_option("LP_NUM_THREADS",
1183 screen->num_threads);
1184 screen->num_threads = MIN2(screen->num_threads, LP_MAX_THREADS);
1185
1186 #if defined(HAVE_LIBDRM) && defined(HAVE_LINUX_UDMABUF_H)
1187 screen->udmabuf_fd = open("/dev/udmabuf", O_RDWR);
1188 llvmpipe_init_screen_fence_funcs(&screen->base);
1189 #endif
1190
1191 uint64_t alignment;
1192 if (!os_get_page_size(&alignment))
1193 alignment = 256;
1194
1195 #if DETECT_OS_LINUX
1196 (void) mtx_init(&screen->mem_mutex, mtx_plain);
1197
1198 util_vma_heap_init(&screen->mem_heap, alignment, UINT64_MAX - alignment);
1199 screen->mem_heap.alloc_high = false;
1200 screen->fd_mem_alloc = os_create_anonymous_file(0, "allocation fd");
1201 #endif
1202
1203 snprintf(screen->renderer_string, sizeof(screen->renderer_string),
1204 "llvmpipe (LLVM " MESA_LLVM_VERSION_STRING ", %u bits)",
1205 lp_build_init_native_width() );
1206
1207 list_inithead(&screen->ctx_list);
1208 (void) mtx_init(&screen->ctx_mutex, mtx_plain);
1209 (void) mtx_init(&screen->cs_mutex, mtx_plain);
1210 (void) mtx_init(&screen->rast_mutex, mtx_plain);
1211
1212 (void) mtx_init(&screen->late_mutex, mtx_plain);
1213
1214 return &screen->base;
1215 }
1216