1
/**************************************************************************
3
* Copyright 2008 VMware, Inc.
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:
14
* The above copyright notice and this permission notice (including the
15
* next paragraph) shall be included in all copies or substantial portions
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.
26
**************************************************************************/
29
#include "compiler/nir/nir.h"
30
#include "util/u_memory.h"
31
#include "util/format/u_format.h"
32
#include "util/format/u_format_s3tc.h"
33
#include "util/u_screen.h"
34
#include "util/u_video.h"
35
#include "util/os_misc.h"
36
#include "util/os_time.h"
37
#include "pipe/p_defines.h"
38
#include "pipe/p_screen.h"
39
#include "draw/draw_context.h"
41
#include "frontend/sw_winsys.h"
42
#include "tgsi/tgsi_exec.h"
44
#include "sp_texture.h"
45
#include "sp_screen.h"
46
#include "sp_context.h"
48
#include "sp_public.h"
50
static const struct debug_named_value sp_debug_options[] = {
51
{"vs", SP_DBG_VS, "dump vertex shader assembly to stderr"},
52
{"gs", SP_DBG_GS, "dump geometry shader assembly to stderr"},
53
{"fs", SP_DBG_FS, "dump fragment shader assembly to stderr"},
54
{"cs", SP_DBG_CS, "dump compute shader assembly to stderr"},
55
{"no_rast", SP_DBG_NO_RAST, "no-ops rasterization, for profiling purposes"},
56
{"use_llvm", SP_DBG_USE_LLVM, "Use LLVM if available for shaders"},
57
{"use_tgsi", SP_DBG_USE_TGSI, "Request TGSI from the API instead of NIR"},
62
DEBUG_GET_ONCE_FLAGS_OPTION(sp_debug, "SOFTPIPE_DEBUG", sp_debug_options, 0)
65
softpipe_get_vendor(struct pipe_screen *screen)
72
softpipe_get_name(struct pipe_screen *screen)
77
static const nir_shader_compiler_options sp_compiler_options = {
78
.fdot_replicates = true,
81
.lower_extract_byte = true,
82
.lower_extract_word = true,
83
.lower_insert_byte = true,
84
.lower_insert_word = true,
89
.lower_uniforms_to_ubo = true,
90
.lower_vector_cmp = true,
91
.use_interpolated_input_intrinsics = true,
95
softpipe_get_compiler_options(struct pipe_screen *pscreen,
96
enum pipe_shader_ir ir,
97
enum pipe_shader_type shader)
99
assert(ir == PIPE_SHADER_IR_NIR);
100
return &sp_compiler_options;
104
softpipe_get_param(struct pipe_screen *screen, enum pipe_cap param)
106
struct softpipe_screen *sp_screen = softpipe_screen(screen);
108
case PIPE_CAP_NPOT_TEXTURES:
109
case PIPE_CAP_MIXED_FRAMEBUFFER_SIZES:
110
case PIPE_CAP_MIXED_COLOR_DEPTH_BITS:
112
case PIPE_CAP_FRAGMENT_SHADER_TEXTURE_LOD:
113
case PIPE_CAP_FRAGMENT_SHADER_DERIVATIVES:
114
case PIPE_CAP_VERTEX_SHADER_SATURATE:
116
case PIPE_CAP_ANISOTROPIC_FILTER:
118
case PIPE_CAP_POINT_SPRITE:
120
case PIPE_CAP_MAX_RENDER_TARGETS:
121
return PIPE_MAX_COLOR_BUFS;
122
case PIPE_CAP_MAX_DUAL_SOURCE_RENDER_TARGETS:
124
case PIPE_CAP_OCCLUSION_QUERY:
126
case PIPE_CAP_QUERY_TIME_ELAPSED:
128
case PIPE_CAP_QUERY_PIPELINE_STATISTICS:
130
case PIPE_CAP_TEXTURE_MIRROR_CLAMP:
131
case PIPE_CAP_TEXTURE_MIRROR_CLAMP_TO_EDGE:
133
case PIPE_CAP_TEXTURE_SWIZZLE:
135
case PIPE_CAP_MAX_TEXTURE_2D_SIZE:
136
return 1 << (SP_MAX_TEXTURE_2D_LEVELS - 1);
137
case PIPE_CAP_MAX_TEXTURE_3D_LEVELS:
138
return SP_MAX_TEXTURE_3D_LEVELS;
139
case PIPE_CAP_MAX_TEXTURE_CUBE_LEVELS:
140
return SP_MAX_TEXTURE_CUBE_LEVELS;
141
case PIPE_CAP_BLEND_EQUATION_SEPARATE:
142
case PIPE_CAP_RGB_OVERRIDE_DST_ALPHA_BLEND:
144
case PIPE_CAP_INDEP_BLEND_ENABLE:
146
case PIPE_CAP_INDEP_BLEND_FUNC:
148
case PIPE_CAP_FS_COORD_ORIGIN_UPPER_LEFT:
149
case PIPE_CAP_FS_COORD_ORIGIN_LOWER_LEFT:
150
case PIPE_CAP_FS_COORD_PIXEL_CENTER_HALF_INTEGER:
151
case PIPE_CAP_FS_COORD_PIXEL_CENTER_INTEGER:
153
case PIPE_CAP_DEPTH_CLIP_DISABLE:
154
case PIPE_CAP_DEPTH_BOUNDS_TEST:
156
case PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS:
157
return PIPE_MAX_SO_BUFFERS;
158
case PIPE_CAP_MAX_STREAM_OUTPUT_SEPARATE_COMPONENTS:
159
case PIPE_CAP_MAX_STREAM_OUTPUT_INTERLEAVED_COMPONENTS:
161
case PIPE_CAP_MAX_GEOMETRY_OUTPUT_VERTICES:
162
case PIPE_CAP_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS:
164
case PIPE_CAP_MAX_VERTEX_STREAMS:
165
if (sp_screen->use_llvm)
168
return PIPE_MAX_VERTEX_STREAMS;
169
case PIPE_CAP_MAX_VERTEX_ATTRIB_STRIDE:
171
case PIPE_CAP_PRIMITIVE_RESTART:
172
case PIPE_CAP_PRIMITIVE_RESTART_FIXED_INDEX:
174
case PIPE_CAP_SHADER_STENCIL_EXPORT:
176
case PIPE_CAP_IMAGE_ATOMIC_FLOAT_ADD:
177
case PIPE_CAP_VS_INSTANCEID:
178
case PIPE_CAP_VERTEX_ELEMENT_INSTANCE_DIVISOR:
179
case PIPE_CAP_START_INSTANCE:
181
case PIPE_CAP_SEAMLESS_CUBE_MAP:
182
case PIPE_CAP_SEAMLESS_CUBE_MAP_PER_TEXTURE:
184
case PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS:
185
return 256; /* for GL3 */
186
case PIPE_CAP_MIN_TEXEL_OFFSET:
188
case PIPE_CAP_MAX_TEXEL_OFFSET:
190
case PIPE_CAP_CONDITIONAL_RENDER:
191
case PIPE_CAP_FRAGMENT_COLOR_CLAMPED:
192
case PIPE_CAP_VERTEX_COLOR_UNCLAMPED: /* draw module */
193
case PIPE_CAP_VERTEX_COLOR_CLAMPED: /* draw module */
195
case PIPE_CAP_MIXED_COLORBUFFER_FORMATS:
197
case PIPE_CAP_GLSL_FEATURE_LEVEL:
198
case PIPE_CAP_GLSL_FEATURE_LEVEL_COMPATIBILITY:
200
case PIPE_CAP_COMPUTE:
202
case PIPE_CAP_USER_VERTEX_BUFFERS:
203
case PIPE_CAP_STREAM_OUTPUT_PAUSE_RESUME:
204
case PIPE_CAP_STREAM_OUTPUT_INTERLEAVE_BUFFERS:
205
case PIPE_CAP_VS_LAYER_VIEWPORT:
206
case PIPE_CAP_DOUBLES:
208
case PIPE_CAP_INT64_DIVMOD:
209
case PIPE_CAP_TGSI_DIV:
211
case PIPE_CAP_CONSTANT_BUFFER_OFFSET_ALIGNMENT:
213
case PIPE_CAP_MIN_MAP_BUFFER_ALIGNMENT:
215
case PIPE_CAP_QUERY_TIMESTAMP:
216
case PIPE_CAP_CUBE_MAP_ARRAY:
218
case PIPE_CAP_TEXTURE_BUFFER_OBJECTS:
220
case PIPE_CAP_MAX_TEXTURE_BUFFER_SIZE:
222
case PIPE_CAP_TEXTURE_BUFFER_OFFSET_ALIGNMENT:
224
case PIPE_CAP_TEXTURE_TRANSFER_MODES:
226
case PIPE_CAP_MAX_VIEWPORTS:
227
return PIPE_MAX_VIEWPORTS;
228
case PIPE_CAP_ENDIANNESS:
229
return PIPE_ENDIAN_NATIVE;
230
case PIPE_CAP_MAX_TEXTURE_GATHER_COMPONENTS:
232
case PIPE_CAP_TEXTURE_GATHER_SM5:
233
case PIPE_CAP_TEXTURE_QUERY_LOD:
235
case PIPE_CAP_VS_WINDOW_SPACE_POSITION:
237
case PIPE_CAP_FS_FINE_DERIVATIVE:
239
case PIPE_CAP_SAMPLER_VIEW_TARGET:
241
case PIPE_CAP_FAKE_SW_MSAA:
243
case PIPE_CAP_MIN_TEXTURE_GATHER_OFFSET:
245
case PIPE_CAP_MAX_TEXTURE_GATHER_OFFSET:
247
case PIPE_CAP_DRAW_INDIRECT:
249
case PIPE_CAP_QUERY_SO_OVERFLOW:
251
case PIPE_CAP_NIR_IMAGES_AS_DEREF:
254
case PIPE_CAP_SHAREABLE_SHADERS:
255
/* Can't expose shareable shaders because the draw shaders reference the
256
* draw module's state, which is per-context.
260
case PIPE_CAP_VENDOR_ID:
262
case PIPE_CAP_DEVICE_ID:
264
case PIPE_CAP_ACCELERATED:
266
case PIPE_CAP_VIDEO_MEMORY: {
267
/* XXX: Do we want to return the full amount fo system memory ? */
268
uint64_t system_memory;
270
if (!os_get_total_physical_memory(&system_memory))
273
if (sizeof(void *) == 4)
274
/* Cap to 2 GB on 32 bits system. We do this because softpipe does
275
* eat application memory, which is quite limited on 32 bits. App
276
* shouldn't expect too much available memory. */
277
system_memory = MIN2(system_memory, 2048 << 20);
279
return (int)(system_memory >> 20);
283
case PIPE_CAP_CONDITIONAL_RENDER_INVERTED:
285
case PIPE_CAP_CLIP_HALFZ:
286
case PIPE_CAP_TEXTURE_FLOAT_LINEAR:
287
case PIPE_CAP_TEXTURE_HALF_FLOAT_LINEAR:
289
case PIPE_CAP_FRAMEBUFFER_NO_ATTACHMENT:
290
case PIPE_CAP_CULL_DISTANCE:
291
case PIPE_CAP_COPY_BETWEEN_COMPRESSED_AND_PLAIN_FORMATS:
292
case PIPE_CAP_SHADER_ARRAY_COMPONENTS:
293
case PIPE_CAP_TGSI_TEXCOORD:
295
case PIPE_CAP_CLEAR_TEXTURE:
297
case PIPE_CAP_MAX_VARYINGS:
298
return TGSI_EXEC_MAX_INPUT_ATTRIBS;
299
case PIPE_CAP_PCI_GROUP:
300
case PIPE_CAP_PCI_BUS:
301
case PIPE_CAP_PCI_DEVICE:
302
case PIPE_CAP_PCI_FUNCTION:
304
case PIPE_CAP_MAX_GS_INVOCATIONS:
306
case PIPE_CAP_MAX_SHADER_BUFFER_SIZE:
308
case PIPE_CAP_SHADER_BUFFER_OFFSET_ALIGNMENT:
310
case PIPE_CAP_IMAGE_STORE_FORMATTED:
313
return u_pipe_screen_get_param_defaults(screen, param);
318
softpipe_get_shader_param(struct pipe_screen *screen,
319
enum pipe_shader_type shader,
320
enum pipe_shader_cap param)
322
struct softpipe_screen *sp_screen = softpipe_screen(screen);
325
case PIPE_SHADER_CAP_PREFERRED_IR:
326
return (sp_debug & SP_DBG_USE_TGSI) ? PIPE_SHADER_IR_TGSI : PIPE_SHADER_IR_NIR;
327
case PIPE_SHADER_CAP_SUPPORTED_IRS:
328
return (1 << PIPE_SHADER_IR_NIR) | (1 << PIPE_SHADER_IR_TGSI);
335
case PIPE_SHADER_FRAGMENT:
336
return tgsi_exec_get_shader_param(param);
337
case PIPE_SHADER_COMPUTE:
338
return tgsi_exec_get_shader_param(param);
339
case PIPE_SHADER_VERTEX:
340
case PIPE_SHADER_GEOMETRY:
341
if (sp_screen->use_llvm)
342
return draw_get_shader_param(shader, param);
344
return draw_get_shader_param_no_llvm(shader, param);
351
softpipe_get_paramf(struct pipe_screen *screen, enum pipe_capf param)
354
case PIPE_CAPF_MIN_LINE_WIDTH:
355
case PIPE_CAPF_MIN_LINE_WIDTH_AA:
356
case PIPE_CAPF_MIN_POINT_SIZE:
357
case PIPE_CAPF_MIN_POINT_SIZE_AA:
359
case PIPE_CAPF_POINT_SIZE_GRANULARITY:
360
case PIPE_CAPF_LINE_WIDTH_GRANULARITY:
362
case PIPE_CAPF_MAX_LINE_WIDTH:
364
case PIPE_CAPF_MAX_LINE_WIDTH_AA:
365
return 255.0; /* arbitrary */
366
case PIPE_CAPF_MAX_POINT_SIZE:
368
case PIPE_CAPF_MAX_POINT_SIZE_AA:
369
return 255.0; /* arbitrary */
370
case PIPE_CAPF_MAX_TEXTURE_ANISOTROPY:
372
case PIPE_CAPF_MAX_TEXTURE_LOD_BIAS:
373
return 16.0; /* arbitrary */
374
case PIPE_CAPF_MIN_CONSERVATIVE_RASTER_DILATE:
376
case PIPE_CAPF_MAX_CONSERVATIVE_RASTER_DILATE:
378
case PIPE_CAPF_CONSERVATIVE_RASTER_DILATE_GRANULARITY:
381
/* should only get here on unhandled cases */
382
debug_printf("Unexpected PIPE_CAPF %d query\n", param);
387
* Query format support for creating a texture, drawing surface, etc.
388
* \param format the format to test
389
* \param type one of PIPE_TEXTURE, PIPE_SURFACE
392
softpipe_is_format_supported( struct pipe_screen *screen,
393
enum pipe_format format,
394
enum pipe_texture_target target,
395
unsigned sample_count,
396
unsigned storage_sample_count,
399
struct sw_winsys *winsys = softpipe_screen(screen)->winsys;
400
const struct util_format_description *format_desc;
402
assert(target == PIPE_BUFFER ||
403
target == PIPE_TEXTURE_1D ||
404
target == PIPE_TEXTURE_1D_ARRAY ||
405
target == PIPE_TEXTURE_2D ||
406
target == PIPE_TEXTURE_2D_ARRAY ||
407
target == PIPE_TEXTURE_RECT ||
408
target == PIPE_TEXTURE_3D ||
409
target == PIPE_TEXTURE_CUBE ||
410
target == PIPE_TEXTURE_CUBE_ARRAY);
412
if (MAX2(1, sample_count) != MAX2(1, storage_sample_count))
415
format_desc = util_format_description(format);
419
if (sample_count > 1)
422
if (bind & (PIPE_BIND_DISPLAY_TARGET |
425
if(!winsys->is_displaytarget_format_supported(winsys, bind, format))
429
if (bind & PIPE_BIND_RENDER_TARGET) {
430
if (format_desc->colorspace == UTIL_FORMAT_COLORSPACE_ZS)
434
* Although possible, it is unnatural to render into compressed or YUV
435
* surfaces. So disable these here to avoid going into weird paths
436
* inside gallium frontends.
438
if (format_desc->block.width != 1 ||
439
format_desc->block.height != 1)
443
if (bind & PIPE_BIND_DEPTH_STENCIL) {
444
if (format_desc->colorspace != UTIL_FORMAT_COLORSPACE_ZS)
448
if (format_desc->layout == UTIL_FORMAT_LAYOUT_ASTC ||
449
format_desc->layout == UTIL_FORMAT_LAYOUT_ATC) {
450
/* Software decoding is not hooked up. */
454
if ((bind & (PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW)) &&
455
((bind & PIPE_BIND_DISPLAY_TARGET) == 0) &&
456
target != PIPE_BUFFER) {
457
const struct util_format_description *desc =
458
util_format_description(format);
459
if (desc->nr_channels == 3 && desc->is_array) {
460
/* Don't support any 3-component formats for rendering/texturing
461
* since we don't support the corresponding 8-bit 3 channel UNORM
462
* formats. This allows us to support GL_ARB_copy_image between
463
* GL_RGB8 and GL_RGB8UI, for example. Otherwise, we may be asked to
464
* do a resource copy between PIPE_FORMAT_R8G8B8_UINT and
465
* PIPE_FORMAT_R8G8B8X8_UNORM, for example, which will not work
472
if (format_desc->layout == UTIL_FORMAT_LAYOUT_ETC &&
473
format != PIPE_FORMAT_ETC1_RGB8)
477
* All other operations (sampling, transfer, etc).
481
* Everything else should be supported by u_format.
488
softpipe_destroy_screen( struct pipe_screen *screen )
490
struct softpipe_screen *sp_screen = softpipe_screen(screen);
491
struct sw_winsys *winsys = sp_screen->winsys;
494
winsys->destroy(winsys);
500
/* This is often overriden by the co-state tracker.
503
softpipe_flush_frontbuffer(struct pipe_screen *_screen,
504
struct pipe_context *pipe,
505
struct pipe_resource *resource,
506
unsigned level, unsigned layer,
507
void *context_private,
508
struct pipe_box *sub_box)
510
struct softpipe_screen *screen = softpipe_screen(_screen);
511
struct sw_winsys *winsys = screen->winsys;
512
struct softpipe_resource *texture = softpipe_resource(resource);
516
winsys->displaytarget_display(winsys, texture->dt, context_private, sub_box);
520
softpipe_get_timestamp(struct pipe_screen *_screen)
522
return os_time_get_nano();
526
softpipe_get_compute_param(struct pipe_screen *_screen,
527
enum pipe_shader_ir ir_type,
528
enum pipe_compute_cap param,
532
case PIPE_COMPUTE_CAP_IR_TARGET:
534
case PIPE_COMPUTE_CAP_MAX_GRID_SIZE:
536
uint64_t *grid_size = ret;
537
grid_size[0] = 65535;
538
grid_size[1] = 65535;
539
grid_size[2] = 65535;
541
return 3 * sizeof(uint64_t) ;
542
case PIPE_COMPUTE_CAP_MAX_BLOCK_SIZE:
544
uint64_t *block_size = ret;
545
block_size[0] = 1024;
546
block_size[1] = 1024;
547
block_size[2] = 1024;
549
return 3 * sizeof(uint64_t);
550
case PIPE_COMPUTE_CAP_MAX_THREADS_PER_BLOCK:
552
uint64_t *max_threads_per_block = ret;
553
*max_threads_per_block = 1024;
555
return sizeof(uint64_t);
556
case PIPE_COMPUTE_CAP_MAX_LOCAL_SIZE:
558
uint64_t *max_local_size = ret;
559
*max_local_size = 32768;
561
return sizeof(uint64_t);
562
case PIPE_COMPUTE_CAP_GRID_DIMENSION:
563
case PIPE_COMPUTE_CAP_MAX_GLOBAL_SIZE:
564
case PIPE_COMPUTE_CAP_MAX_PRIVATE_SIZE:
565
case PIPE_COMPUTE_CAP_MAX_INPUT_SIZE:
566
case PIPE_COMPUTE_CAP_MAX_MEM_ALLOC_SIZE:
567
case PIPE_COMPUTE_CAP_MAX_CLOCK_FREQUENCY:
568
case PIPE_COMPUTE_CAP_MAX_COMPUTE_UNITS:
569
case PIPE_COMPUTE_CAP_IMAGES_SUPPORTED:
570
case PIPE_COMPUTE_CAP_SUBGROUP_SIZE:
571
case PIPE_COMPUTE_CAP_ADDRESS_BITS:
572
case PIPE_COMPUTE_CAP_MAX_VARIABLE_THREADS_PER_BLOCK:
579
* Create a new pipe_screen object
580
* Note: we're not presently subclassing pipe_screen (no softpipe_screen).
583
softpipe_create_screen(struct sw_winsys *winsys)
585
struct softpipe_screen *screen = CALLOC_STRUCT(softpipe_screen);
590
sp_debug = debug_get_option_sp_debug();
592
screen->winsys = winsys;
594
screen->base.destroy = softpipe_destroy_screen;
596
screen->base.get_name = softpipe_get_name;
597
screen->base.get_vendor = softpipe_get_vendor;
598
screen->base.get_device_vendor = softpipe_get_vendor; // TODO should be the CPU vendor
599
screen->base.get_param = softpipe_get_param;
600
screen->base.get_shader_param = softpipe_get_shader_param;
601
screen->base.get_paramf = softpipe_get_paramf;
602
screen->base.get_timestamp = softpipe_get_timestamp;
603
screen->base.is_format_supported = softpipe_is_format_supported;
604
screen->base.context_create = softpipe_create_context;
605
screen->base.flush_frontbuffer = softpipe_flush_frontbuffer;
606
screen->base.get_compute_param = softpipe_get_compute_param;
607
screen->base.get_compiler_options = softpipe_get_compiler_options;
608
screen->use_llvm = sp_debug & SP_DBG_USE_LLVM;
610
softpipe_init_screen_texture_funcs(&screen->base);
611
softpipe_init_screen_fence_funcs(&screen->base);
613
return &screen->base;