diff options
| author | Marek Olšák <[email protected]> | 2019-12-03 20:38:14 -0500 |
|---|---|---|
| committer | Marek Olšák <[email protected]> | 2020-05-13 13:47:27 -0400 |
| commit | 8c9b9aac7d09e65195dca6681d59c10e4ef713d9 (patch) | |
| tree | 4b419e23b0fb2e78eaadaefd31d5923d9c277fb0 | |
| parent | d6287a94b697ffe12a4e576a38943cdf4e90cdb0 (diff) | |
gallium: change comments to remove 'state tracker'
Acked-by: Eric Anholt <[email protected]>
Acked-by: Alyssa Rosenzweig <[email protected]>
Acked-by: Pierre-Eric Pelloux-Prayer <[email protected]>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/4902>
97 files changed, 188 insertions, 193 deletions
diff --git a/docs/envvars.html b/docs/envvars.html index 0bf95a12843..a642daf59c2 100644 --- a/docs/envvars.html +++ b/docs/envvars.html @@ -430,7 +430,7 @@ Mesa EGL supports different sets of environment variables. See the options.</dd> </dl> -<h3>Clover state tracker environment variables</h3> +<h3>Clover environment variables</h3> <dl> <dt><code>CLOVER_EXTRA_BUILD_OPTIONS</code></dt> @@ -507,7 +507,7 @@ Mesa EGL supports different sets of environment variables. See the <code>wglSwapIntervalEXT()</code> will have no effect.</dd> </dl> -<h3>VA-API state tracker environment variables</h3> +<h3>VA-API environment variables</h3> <dl> <dt><code>VAAPI_MPEG4_ENABLED</code></dt> <dd>enable MPEG4 for VA-API, disabled by default.</dd> diff --git a/meson_options.txt b/meson_options.txt index ab43150669b..f5609cacc51 100644 --- a/meson_options.txt +++ b/meson_options.txt @@ -76,7 +76,7 @@ option( type : 'combo', value : 'auto', choices : ['auto', 'true', 'false'], - description : 'enable gallium vdpau state tracker.', + description : 'enable gallium vdpau frontend.', ) option( 'vdpau-libs-path', @@ -89,7 +89,7 @@ option( type : 'combo', value : 'auto', choices : ['auto', 'true', 'false'], - description : 'enable gallium xvmc state tracker.', + description : 'enable gallium xvmc frontend.', ) option( 'xvmc-libs-path', @@ -102,7 +102,7 @@ option( type : 'combo', value : 'auto', choices : ['auto', 'disabled', 'bellagio', 'tizonia'], - description : 'enable gallium omx state tracker.', + description : 'enable gallium omx frontend.', ) option( 'omx-libs-path', @@ -115,7 +115,7 @@ option( type : 'combo', value : 'auto', choices : ['auto', 'true', 'false'], - description : 'enable gallium va state tracker.', + description : 'enable gallium va frontend.', ) option( 'va-libs-path', @@ -128,26 +128,26 @@ option( type : 'combo', value : 'auto', choices : ['auto', 'true', 'false'], - description : 'enable gallium xa state tracker.', + description : 'enable gallium xa frontend.', ) option( 'gallium-nine', type : 'boolean', value : false, - description : 'build gallium "nine" Direct3D 9.x state tracker.', + description : 'build gallium "nine" Direct3D 9.x frontend.', ) option( 'gallium-opencl', type : 'combo', choices : ['icd', 'standalone', 'disabled'], value : 'disabled', - description : 'build gallium "clover" OpenCL state tracker.', + description : 'build gallium "clover" OpenCL frontend.', ) option( 'opencl-spirv', type : 'boolean', value : false, - description : 'build gallium "clover" OpenCL state tracker with SPIR-V binary support.', + description : 'build gallium "clover" OpenCL frontend with SPIR-V binary support.', ) option( 'd3d-drivers-path', diff --git a/src/gallium/README.portability b/src/gallium/README.portability index cf6cc36afbb..9fbec4c5f5c 100644 --- a/src/gallium/README.portability +++ b/src/gallium/README.portability @@ -3,7 +3,7 @@ = General Considerations = -The state tracker and winsys driver support a rather limited number of +The frontend and winsys driver support a rather limited number of platforms. However, the pipe drivers are meant to run in a wide number of platforms. Hence the pipe drivers, the auxiliary modules, and all public headers in general, should strictly follow these guidelines to ensure diff --git a/src/gallium/SConscript b/src/gallium/SConscript index 5017d5fe247..98ba88588d5 100644 --- a/src/gallium/SConscript +++ b/src/gallium/SConscript @@ -39,7 +39,7 @@ if env['platform'] == 'windows': # -# State trackers and targets +# Frontends and targets # if not env['embedded']: diff --git a/src/gallium/auxiliary/cso_cache/cso_context.h b/src/gallium/auxiliary/cso_cache/cso_context.h index ce64568a6da..95df3c169d7 100644 --- a/src/gallium/auxiliary/cso_cache/cso_context.h +++ b/src/gallium/auxiliary/cso_cache/cso_context.h @@ -71,7 +71,7 @@ cso_set_samplers(struct cso_context *cso, const struct pipe_sampler_state **states); -/* Alternate interface to support state trackers that like to modify +/* Alternate interface to support gallium frontends that like to modify * samplers one at a time: */ void @@ -100,7 +100,7 @@ void cso_set_stream_outputs(struct cso_context *ctx, * We don't provide shader caching in CSO. Most of the time the api provides * object semantics for shaders anyway, and the cases where it doesn't * (eg mesa's internally-generated texenv programs), it will be up to - * the state tracker to implement their own specialized caching. + * gallium frontends to implement their own specialized caching. */ void cso_set_fragment_shader_handle(struct cso_context *ctx, void *handle); diff --git a/src/gallium/auxiliary/draw/draw_pipe_aaline.c b/src/gallium/auxiliary/draw/draw_pipe_aaline.c index cd4be6d967f..d380b4295d4 100644 --- a/src/gallium/auxiliary/draw/draw_pipe_aaline.c +++ b/src/gallium/auxiliary/draw/draw_pipe_aaline.c @@ -633,7 +633,7 @@ aaline_stage_from_pipe(struct pipe_context *pipe) /** * This function overrides the driver's create_fs_state() function and - * will typically be called by the state tracker. + * will typically be called by the gallium frontend. */ static void * aaline_create_fs_state(struct pipe_context *pipe, diff --git a/src/gallium/auxiliary/draw/draw_pipe_aapoint.c b/src/gallium/auxiliary/draw/draw_pipe_aapoint.c index 2ee2bc17faa..2df5bf1a6f3 100644 --- a/src/gallium/auxiliary/draw/draw_pipe_aapoint.c +++ b/src/gallium/auxiliary/draw/draw_pipe_aapoint.c @@ -734,7 +734,7 @@ aapoint_stage_from_pipe(struct pipe_context *pipe) /** * This function overrides the driver's create_fs_state() function and - * will typically be called by the state tracker. + * will typically be called by the gallium frontend. */ static void * aapoint_create_fs_state(struct pipe_context *pipe, diff --git a/src/gallium/auxiliary/draw/draw_pipe_pstipple.c b/src/gallium/auxiliary/draw/draw_pipe_pstipple.c index bd74cb42ada..dbb0545a9ac 100644 --- a/src/gallium/auxiliary/draw/draw_pipe_pstipple.c +++ b/src/gallium/auxiliary/draw/draw_pipe_pstipple.c @@ -334,7 +334,7 @@ pstip_stage_from_pipe(struct pipe_context *pipe) /** * This function overrides the driver's create_fs_state() function and - * will typically be called by the state tracker. + * will typically be called by the gallium frontend. */ static void * pstip_create_fs_state(struct pipe_context *pipe, diff --git a/src/gallium/auxiliary/draw/draw_pipe_wide_point.c b/src/gallium/auxiliary/draw/draw_pipe_wide_point.c index e9bbb67a958..2f2c1072540 100644 --- a/src/gallium/auxiliary/draw/draw_pipe_wide_point.c +++ b/src/gallium/auxiliary/draw/draw_pipe_wide_point.c @@ -47,7 +47,7 @@ * that varies .x from 0 to 1 horizontally across the point and varies .y * vertically from 0 to 1 down the sprite. * - * With geometry shaders, the state tracker could create a GS to do + * With geometry shaders, the gallium frontends could create a GS to do * most/all of this. */ diff --git a/src/gallium/auxiliary/draw/draw_pt.c b/src/gallium/auxiliary/draw/draw_pt.c index 986f87e0152..0ea1f14c1e0 100644 --- a/src/gallium/auxiliary/draw/draw_pt.c +++ b/src/gallium/auxiliary/draw/draw_pt.c @@ -425,7 +425,7 @@ draw_pt_arrays_restart(struct draw_context *draw, } else { /* Non-indexed prims (draw_arrays). - * Primitive restart should have been handled in the state tracker. + * Primitive restart should have been handled in gallium frontends. */ draw_pt_arrays(draw, prim, start, count); } @@ -556,7 +556,7 @@ draw_vbo(struct draw_context *draw, /* * TODO: We could use draw->pt.max_index to further narrow - * the min_index/max_index hints given by the state tracker. + * the min_index/max_index hints given by gallium frontends. */ for (instance = 0; instance < info->instance_count; instance++) { diff --git a/src/gallium/auxiliary/gallivm/lp_bld_limits.h b/src/gallium/auxiliary/gallivm/lp_bld_limits.h index 9d0a5ca92d1..dea0c72c8a6 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_limits.h +++ b/src/gallium/auxiliary/gallivm/lp_bld_limits.h @@ -40,7 +40,7 @@ * TGSI translation limits. * * Some are slightly above SM 3.0 requirements to give some wiggle room to - * the state trackers. + * the gallium frontends. */ #define LP_MAX_TGSI_TEMPS 4096 diff --git a/src/gallium/auxiliary/gallivm/lp_bld_misc.cpp b/src/gallium/auxiliary/gallivm/lp_bld_misc.cpp index df7196190c5..b079b96b6de 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_misc.cpp +++ b/src/gallium/auxiliary/gallivm/lp_bld_misc.cpp @@ -143,11 +143,11 @@ static void init_native_targets() extern "C" void lp_set_target_options(void) { - /* The llvm target registry is not thread-safe, so drivers and state-trackers + /* The llvm target registry is not thread-safe, so drivers and gallium frontends * that want to initialize targets should use the lp_set_target_options() * function to safely initialize targets. * - * LLVM targets should be initialized before the driver or state-tracker tries + * LLVM targets should be initialized before the driver or gallium frontend tries * to access the registry. */ call_once(&init_native_targets_once_flag, init_native_targets); diff --git a/src/gallium/auxiliary/gallivm/lp_bld_sample.c b/src/gallium/auxiliary/gallivm/lp_bld_sample.c index fa145e1c3b2..8e453580b16 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_sample.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_sample.c @@ -179,7 +179,7 @@ lp_sampler_static_sampler_state(struct lp_static_sampler_state *state, * spurious recompiles, as the sampler static state is part of the shader * key. * - * Ideally the state tracker or cso_cache module would make all state + * Ideally gallium frontends or cso_cache module would make all state * canonical, but until that happens it's better to be safe than sorry here. * * XXX: Actually there's much more than can be done here, especially diff --git a/src/gallium/auxiliary/gallivm/lp_bld_sample_soa.c b/src/gallium/auxiliary/gallivm/lp_bld_sample_soa.c index 5b623eda26b..79f569baf93 100644 --- a/src/gallium/auxiliary/gallivm/lp_bld_sample_soa.c +++ b/src/gallium/auxiliary/gallivm/lp_bld_sample_soa.c @@ -3124,7 +3124,7 @@ lp_build_sample_soa_code(struct gallivm_state *gallivm, * here which would say it's pure int despite such formats should sample * the depth component). * In GL such filters make the texture incomplete, this makes it robust - * against state trackers which set this up regardless (we'd crash in the + * against gallium frontends which set this up regardless (we'd crash in the * lerp later otherwise). * At least in some apis it may be legal to use such filters with lod * queries and/or gather (at least for gather d3d10 says only the wrap diff --git a/src/gallium/auxiliary/hud/hud_context.c b/src/gallium/auxiliary/hud/hud_context.c index 1e2b948e348..0cd3307a1a5 100644 --- a/src/gallium/auxiliary/hud/hud_context.c +++ b/src/gallium/auxiliary/hud/hud_context.c @@ -27,7 +27,7 @@ /* This head-up display module can draw transparent graphs on top of what * the app is rendering, visualizing various data like framerate, cpu load, - * performance counters, etc. It can be hook up into any state tracker. + * performance counters, etc. It can be hook up into any gallium frontend. * * The HUD is controlled with the GALLIUM_HUD environment variable. * Set GALLIUM_HUD=help for more info. diff --git a/src/gallium/auxiliary/util/u_draw.c b/src/gallium/auxiliary/util/u_draw.c index a43938774bb..f4ac2b107a9 100644 --- a/src/gallium/auxiliary/util/u_draw.c +++ b/src/gallium/auxiliary/util/u_draw.c @@ -107,7 +107,7 @@ util_draw_max_index( max_index = MIN2(max_index, buffer_max_index); } else { - /* Per-instance data. Simply make sure the state tracker didn't + /* Per-instance data. Simply make sure gallium frontends didn't * request more instances than those that fit in the buffer */ if ((info->start_instance + info->instance_count)/element->instance_divisor > (buffer_max_index + 1)) { diff --git a/src/gallium/auxiliary/util/u_helpers.c b/src/gallium/auxiliary/util/u_helpers.c index 31b7d533952..6fa3f1a1fcd 100644 --- a/src/gallium/auxiliary/util/u_helpers.c +++ b/src/gallium/auxiliary/util/u_helpers.c @@ -165,7 +165,7 @@ util_upload_index_buffer(struct pipe_context *pipe, * CPU cores that share the same L3 cache. This is needed for good multi- * threading performance on AMD Zen CPUs. * - * \param upper_thread thread in the state tracker that also needs to be + * \param upper_thread thread in gallium frontends that also needs to be * pinned. */ void diff --git a/src/gallium/auxiliary/util/u_screen.c b/src/gallium/auxiliary/util/u_screen.c index a7fb85ca27b..6b0a106a637 100644 --- a/src/gallium/auxiliary/util/u_screen.c +++ b/src/gallium/auxiliary/util/u_screen.c @@ -111,7 +111,7 @@ u_pipe_screen_get_param_defaults(struct pipe_screen *pscreen, return 120; case PIPE_CAP_ESSL_FEATURE_LEVEL: - /* Tell state-tracker to fallback to PIPE_CAP_GLSL_FEATURE_LEVEL */ + /* Tell gallium frontend to fallback to PIPE_CAP_GLSL_FEATURE_LEVEL */ return 0; case PIPE_CAP_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION: diff --git a/src/gallium/auxiliary/util/u_threaded_context.c b/src/gallium/auxiliary/util/u_threaded_context.c index d8536af77be..9e835867ef3 100644 --- a/src/gallium/auxiliary/util/u_threaded_context.c +++ b/src/gallium/auxiliary/util/u_threaded_context.c @@ -238,7 +238,7 @@ threaded_context_flush(struct pipe_context *_pipe, { struct threaded_context *tc = threaded_context(_pipe); - /* This is called from the state-tracker / application thread. */ + /* This is called from the gallium frontend / application thread. */ if (token->tc && token->tc == tc) { struct tc_batch *last = &tc->batch_slots[tc->last]; diff --git a/src/gallium/auxiliary/util/u_tile.c b/src/gallium/auxiliary/util/u_tile.c index d954301a961..add92ed8139 100644 --- a/src/gallium/auxiliary/util/u_tile.c +++ b/src/gallium/auxiliary/util/u_tile.c @@ -27,7 +27,7 @@ /** * RGBA/float tile get/put functions. - * Usable both by drivers and state trackers. + * Usable both by drivers and gallium frontends. */ diff --git a/src/gallium/auxiliary/util/u_transfer_helper.h b/src/gallium/auxiliary/util/u_transfer_helper.h index 9e5f889f9d8..e27c3570499 100644 --- a/src/gallium/auxiliary/util/u_transfer_helper.h +++ b/src/gallium/auxiliary/util/u_transfer_helper.h @@ -82,7 +82,7 @@ struct u_transfer_vtbl { * Must be implemented if separate stencil or fake_rgtc is used. The * internal_format is the format the resource was created with. In * the case of separate stencil or fake_rgtc, prsc->format is set back - * to the state tracker visible format (e.g. Z32_FLOAT_S8X24_UINT or + * to the gallium-frontend-visible format (e.g. Z32_FLOAT_S8X24_UINT or * PIPE_FORMAT_{RTGC,LATC}* after the resource is created. */ enum pipe_format (*get_internal_format)(struct pipe_resource *prsc); diff --git a/src/gallium/docs/source/context.rst b/src/gallium/docs/source/context.rst index 06d30bfb38b..7f8111b2316 100644 --- a/src/gallium/docs/source/context.rst +++ b/src/gallium/docs/source/context.rst @@ -382,7 +382,7 @@ Queries ^^^^^^^ Queries gather some statistic from the 3D pipeline over one or more -draws. Queries may be nested, though not all state trackers exercise this. +draws. Queries may be nested, though not all gallium frontends exercise this. Queries can be created with ``create_query`` and deleted with ``destroy_query``. To start a query, use ``begin_query``, and when finished, @@ -856,7 +856,7 @@ for particular texture types or formats. Device resets ^^^^^^^^^^^^^ -The state tracker can query or request notifications of when the GPU +Gallium frontends can query or request notifications of when the GPU is reset for whatever reason (application error, driver error). When a GPU reset happens, the context becomes unusable and all related state should be considered lost and undefined. Despite that, context diff --git a/src/gallium/docs/source/cso/rasterizer.rst b/src/gallium/docs/source/cso/rasterizer.rst index 4dabcc032f5..064360079e3 100644 --- a/src/gallium/docs/source/cso/rasterizer.rst +++ b/src/gallium/docs/source/cso/rasterizer.rst @@ -21,7 +21,7 @@ OpenGL: glClampColor(GL_CLAMP_VERTEX_COLOR) in GL 3.0 or GL_ARB_color_buffer_flo D3D11: seems always disabled Note the PIPE_CAP_VERTEX_COLOR_CLAMPED query indicates whether or not the -driver supports this control. If it's not supported, the state tracker may +driver supports this control. If it's not supported, gallium frontends may have to insert extra clamping code. @@ -36,7 +36,7 @@ OpenGL: glClampColor(GL_CLAMP_FRAGMENT_COLOR) in GL 3.0 or ARB_color_buffer_floa D3D11: seems always disabled Note the PIPE_CAP_FRAGMENT_COLOR_CLAMPED query indicates whether or not the -driver supports this control. If it's not supported, the state tracker may +driver supports this control. If it's not supported, gallium frontends may have to insert extra clamping code. @@ -184,7 +184,7 @@ the state of 'sprite_coord_mode' (see below). If any bit is set, then point_smooth MUST be disabled (there are no round sprites) and point_quad_rasterization MUST be true (sprites are always rasterized as quads). Any mismatch between these states should -be considered a bug in the state-tracker. +be considered a bug in the gallium frontend. This feature is implemented in the :ref:`Draw` module but may also be implemented natively by GPUs or implemented with a geometry shader. diff --git a/src/gallium/docs/source/debugging.rst b/src/gallium/docs/source/debugging.rst index 8e96a6e4874..6e97de70de5 100644 --- a/src/gallium/docs/source/debugging.rst +++ b/src/gallium/docs/source/debugging.rst @@ -46,8 +46,8 @@ the shader sanity checker prints its warnings and errors to stderr. Whether the :ref:`Draw` module will attempt to use LLVM for vertex and geometry shaders. -State tracker-specific -"""""""""""""""""""""" +GL State tracker-specific +""""""""""""""""""""""""" .. envvar:: ST_DEBUG <flags> (0x0) diff --git a/src/gallium/docs/source/distro.rst b/src/gallium/docs/source/distro.rst index 15468b6eebd..d745025d26d 100644 --- a/src/gallium/docs/source/distro.rst +++ b/src/gallium/docs/source/distro.rst @@ -1,7 +1,7 @@ Distribution ============ -Along with the interface definitions, the following drivers, state trackers, +Along with the interface definitions, the following drivers, gallium frontends, and auxiliary modules are shipped in the standard Gallium distribution. Drivers @@ -78,8 +78,8 @@ Rbug Wrapper driver. :ref:`rbug` driver used with stand alone rbug-gui. -State Trackers --------------- +Gallium frontends +----------------- Clover ^^^^^^ @@ -101,9 +101,9 @@ GLX MesaGL ^^^^^^ -Tracker implementing a GL state machine. Not usable as a standalone tracker; -Mesa should be built with another state tracker, such as :ref:`DRI` or -:ref:`EGL`. +The gallium frontend implementing a GL state machine. Not usable as +a standalone frontend; Mesa should be built with another gallium frontend, +such as :ref:`DRI` or :ref:`EGL`. VDPAU ^^^^^ diff --git a/src/gallium/docs/source/screen.rst b/src/gallium/docs/source/screen.rst index 6832b999357..e1dfaccec68 100644 --- a/src/gallium/docs/source/screen.rst +++ b/src/gallium/docs/source/screen.rst @@ -85,7 +85,7 @@ The integer capabilities: per-instance vertex attribs. * ``PIPE_CAP_FRAGMENT_COLOR_CLAMPED``: Whether fragment color clamping is supported. That is, is the pipe_rasterizer_state::clamp_fragment_color - flag supported by the driver? If not, the state tracker will insert + flag supported by the driver? If not, gallium frontends will insert clamping code into the fragment shaders when needed. * ``PIPE_CAP_MIXED_COLORBUFFER_FORMATS``: Whether mixed colorbuffer formats are @@ -99,7 +99,7 @@ The integer capabilities: the vertex colors are never clamped. This is the default for DX10 hardware. If both clamped and unclamped CAPs are supported, the clamping can be controlled through pipe_rasterizer_state. If the driver cannot do vertex - color clamping, the state tracker may insert clamping code into the vertex + color clamping, gallium frontends may insert clamping code into the vertex shader. * ``PIPE_CAP_GLSL_FEATURE_LEVEL``: Whether the driver supports features equivalent to a specific GLSL version. E.g. for GLSL 1.3, report 130. @@ -121,7 +121,7 @@ The integer capabilities: * ``PIPE_CAP_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION``: Whether quads adhere to the flatshade_first setting in ``pipe_rasterizer_state``. * ``PIPE_CAP_USER_VERTEX_BUFFERS``: Whether the driver supports user vertex - buffers. If not, the state tracker must upload all data which is not in hw + buffers. If not, gallium frontends must upload all data which is not in hw resources. If user-space buffers are supported, the driver must also still accept HW resource buffers. * ``PIPE_CAP_VERTEX_BUFFER_OFFSET_4BYTE_ALIGNED_ONLY``: This CAP describes a hw @@ -164,7 +164,7 @@ The integer capabilities: input that will always be replaced with sprite coordinates. * ``PIPE_CAP_PREFER_BLIT_BASED_TEXTURE_TRANSFER``: Whether it is preferable to use a blit to implement a texture transfer which needs format conversions - and swizzling in state trackers. Generally, all hardware drivers with + and swizzling in gallium frontends. Generally, all hardware drivers with dedicated memory should return 1 and all software rasterizers should return 0. * ``PIPE_CAP_QUERY_PIPELINE_STATISTICS``: Whether PIPE_QUERY_PIPELINE_STATISTICS is supported. @@ -256,7 +256,7 @@ The integer capabilities: for enabling ARB_clip_control. * ``PIPE_CAP_VERTEXID_NOBASE``: If true, the driver only supports TGSI_SEMANTIC_VERTEXID_NOBASE (and not TGSI_SEMANTIC_VERTEXID). This means - state trackers for APIs whose vertexIDs are offset by basevertex (such as GL) + gallium frontends for APIs whose vertexIDs are offset by basevertex (such as GL) will need to lower TGSI_SEMANTIC_VERTEXID to TGSI_SEMANTIC_VERTEXID_NOBASE and TGSI_SEMANTIC_BASEVERTEX, so drivers setting this must handle both these semantics. Only relevant if geometry shaders are supported. @@ -310,11 +310,11 @@ The integer capabilities: supported in vertex shaders. * ``PIPE_CAP_TGSI_PACK_HALF_FLOAT``: Whether the ``UP2H`` and ``PK2H`` TGSI opcodes are supported. -* ``PIPE_CAP_TGSI_FS_POSITION_IS_SYSVAL``: If state trackers should use +* ``PIPE_CAP_TGSI_FS_POSITION_IS_SYSVAL``: If gallium frontends should use a system value for the POSITION fragment shader input. -* ``PIPE_CAP_TGSI_FS_POINT_IS_SYSVAL``: If state trackers should use +* ``PIPE_CAP_TGSI_FS_POINT_IS_SYSVAL``: If gallium frontends should use a system value for the POINT fragment shader input. -* ``PIPE_CAP_TGSI_FS_FACE_IS_INTEGER_SYSVAL``: If state trackers should use +* ``PIPE_CAP_TGSI_FS_FACE_IS_INTEGER_SYSVAL``: If gallium frontends should use a system value for the FACE fragment shader input. Also, the FACE system value is integer, not float. * ``PIPE_CAP_SHADER_BUFFER_OFFSET_ALIGNMENT``: Describes the required @@ -528,7 +528,7 @@ The integer capabilities: A driver might rely on the input mapping that was defined with the original GLSL code. * ``PIPE_CAP_IMAGE_LOAD_FORMATTED``: True if a format for image loads does not need to be specified in the shader IR -* ``PIPE_CAP_THROTTLE``: Whether or not state trackers should throttle pipe_context +* ``PIPE_CAP_THROTTLE``: Whether or not gallium frontends should throttle pipe_context execution. 0 = throttling is disabled. * ``PIPE_CAP_DMABUF``: Whether Linux DMABUF handles are supported by resource_from_handle and resource_get_handle. @@ -537,7 +537,7 @@ The integer capabilities: * ``PIPE_CAP_FRAGMENT_SHADER_INTERLOCK``: True if fragment shader interlock functionality is supported. * ``PIPE_CAP_CS_DERIVED_SYSTEM_VALUES_SUPPORTED``: True if driver handles - gl_LocalInvocationIndex and gl_GlobalInvocationID. Otherwise, state tracker will + gl_LocalInvocationIndex and gl_GlobalInvocationID. Otherwise, gallium frontends will lower those system values. * ``PIPE_CAP_ATOMIC_FLOAT_MINMAX``: Atomic float point minimum, maximum, exchange and compare-and-swap support to buffer and shared variables. @@ -552,7 +552,7 @@ The integer capabilities: types with texture functions having interaction with LOD of texture lookup. * ``PIPE_CAP_SHADER_SAMPLES_IDENTICAL``: True if the driver supports a shader query to tell whether all samples of a multisampled surface are definitely identical. * ``PIPE_CAP_TGSI_ATOMINC_WRAP``: Atomic increment/decrement + wrap around are supported. -* ``PIPE_CAP_PREFER_IMM_ARRAYS_AS_CONSTBUF``: True if the state tracker should +* ``PIPE_CAP_PREFER_IMM_ARRAYS_AS_CONSTBUF``: True if gallium frontends should turn arrays whose contents can be deduced at compile time into constant buffer loads, or false if the driver can handle such arrays itself in a more efficient manner. @@ -667,7 +667,7 @@ MOV OUT[0], CONST[0][3] # copy vector 3 of constbuf 0 ignore tgsi_declaration_range::Last for shader inputs and outputs. * ``PIPE_SHADER_CAP_MAX_UNROLL_ITERATIONS_HINT``: This is the maximum number of iterations that loops are allowed to have to be unrolled. It is only - a hint to state trackers. Whether any loops will be unrolled is not + a hint to gallium frontends. Whether any loops will be unrolled is not guaranteed. * ``PIPE_SHADER_CAP_MAX_SHADER_BUFFERS``: Maximum number of memory buffers (also used to implement atomic counters). Having this be non-0 also @@ -677,7 +677,7 @@ MOV OUT[0], CONST[0][3] # copy vector 3 of constbuf 0 program. It should be a mask of ``pipe_shader_ir`` bits. * ``PIPE_SHADER_CAP_MAX_SHADER_IMAGES``: Maximum number of image units. * ``PIPE_SHADER_CAP_LOWER_IF_THRESHOLD``: IF and ELSE branches with a lower - cost than this value should be lowered by the state tracker for better + cost than this value should be lowered by gallium frontends for better performance. This is a tunable for the GLSL compiler and the behavior is specific to the compiler. * ``PIPE_SHADER_CAP_TGSI_SKIP_MERGE_REGISTERS``: Whether the merge registers diff --git a/src/gallium/docs/source/tgsi.rst b/src/gallium/docs/source/tgsi.rst index fbf6869f885..79d10076918 100644 --- a/src/gallium/docs/source/tgsi.rst +++ b/src/gallium/docs/source/tgsi.rst @@ -2506,7 +2506,7 @@ after lookup. If per-sample shading is not in effect or the source resource or render target is not multisampled, the result is (0.5, 0.5, undef, undef). - NOTE: no driver has implemented this opcode yet (and no state tracker + NOTE: no driver has implemented this opcode yet (and no gallium frontend emits it). This information is subject to change. .. opcode:: SAMPLE_INFO @@ -2525,7 +2525,7 @@ after lookup. If per-sample shading is not in effect or the source resource or render target is not multisampled, the result is (1, 0, 0, 0). - NOTE: no driver has implemented this opcode yet (and no state tracker + NOTE: no driver has implemented this opcode yet (and no gallium frontend emits it). This information is subject to change. .. opcode:: LOD - level of detail diff --git a/src/gallium/drivers/etnaviv/etnaviv_context.c b/src/gallium/drivers/etnaviv/etnaviv_context.c index 67c68f9eb4d..a9c34171281 100644 --- a/src/gallium/drivers/etnaviv/etnaviv_context.c +++ b/src/gallium/drivers/etnaviv/etnaviv_context.c @@ -574,7 +574,7 @@ etna_context_create(struct pipe_screen *pscreen, void *priv, unsigned flags) /* context ctxate setup */ ctx->screen = screen; - /* need some sane default in case state tracker doesn't set some state: */ + /* need some sane default in case gallium frontends don't set some state: */ ctx->sample_mask = 0xffff; /* Set sensible defaults for state */ diff --git a/src/gallium/drivers/etnaviv/etnaviv_state.c b/src/gallium/drivers/etnaviv/etnaviv_state.c index 5559cc54f0b..efafd1238c7 100644 --- a/src/gallium/drivers/etnaviv/etnaviv_state.c +++ b/src/gallium/drivers/etnaviv/etnaviv_state.c @@ -90,7 +90,7 @@ etna_set_constant_buffer(struct pipe_context *pctx, util_copy_constant_buffer(&so->cb[index], cb); - /* Note that the state tracker can unbind constant buffers by + /* Note that the gallium frontends can unbind constant buffers by * passing NULL here. */ if (unlikely(!cb || (!cb->buffer && !cb->user_buffer))) { so->enabled_mask &= ~(1 << index); diff --git a/src/gallium/drivers/freedreno/freedreno_context.c b/src/gallium/drivers/freedreno/freedreno_context.c index 17a40a9fa6a..9a27a95e2c3 100644 --- a/src/gallium/drivers/freedreno/freedreno_context.c +++ b/src/gallium/drivers/freedreno/freedreno_context.c @@ -380,7 +380,7 @@ fd_context_init(struct fd_context *ctx, struct pipe_screen *pscreen, (void) mtx_init(&ctx->gmem_lock, mtx_plain); - /* need some sane default in case state tracker doesn't + /* need some sane default in case gallium frontends don't * set some state: */ ctx->sample_mask = 0xffff; diff --git a/src/gallium/drivers/freedreno/freedreno_resource.c b/src/gallium/drivers/freedreno/freedreno_resource.c index 0586271fe6f..cf81a0c3b90 100644 --- a/src/gallium/drivers/freedreno/freedreno_resource.c +++ b/src/gallium/drivers/freedreno/freedreno_resource.c @@ -380,7 +380,7 @@ fd_try_shadow_resource(struct fd_context *ctx, struct fd_resource *rsc, * Uncompress an UBWC compressed buffer "in place". This works basically * like resource shadowing, creating a new resource, and doing an uncompress * blit, and swapping the state between shadow and original resource so it - * appears to the state tracker as if nothing changed. + * appears to the gallium frontends as if nothing changed. */ void fd_resource_uncompress(struct fd_context *ctx, struct fd_resource *rsc) diff --git a/src/gallium/drivers/freedreno/freedreno_state.c b/src/gallium/drivers/freedreno/freedreno_state.c index a72958a1bc8..2049e381cc0 100644 --- a/src/gallium/drivers/freedreno/freedreno_state.c +++ b/src/gallium/drivers/freedreno/freedreno_state.c @@ -104,7 +104,7 @@ fd_set_constant_buffer(struct pipe_context *pctx, util_copy_constant_buffer(&so->cb[index], cb); - /* Note that the state tracker can unbind constant buffers by + /* Note that gallium frontends can unbind constant buffers by * passing NULL here. */ if (unlikely(!cb)) { diff --git a/src/gallium/drivers/i915/i915_state.c b/src/gallium/drivers/i915/i915_state.c index e90f2dc7574..d8a5edfebf4 100644 --- a/src/gallium/drivers/i915/i915_state.c +++ b/src/gallium/drivers/i915/i915_state.c @@ -888,7 +888,7 @@ static void i915_set_clip_state( struct pipe_context *pipe, -/* Called when driver state tracker notices changes to the viewport +/* Called when gallium frontends notice changes to the viewport * matrix: */ static void i915_set_viewport_states( struct pipe_context *pipe, diff --git a/src/gallium/drivers/iris/iris_batch.c b/src/gallium/drivers/iris/iris_batch.c index 6533e11349d..c23e281bdce 100644 --- a/src/gallium/drivers/iris/iris_batch.c +++ b/src/gallium/drivers/iris/iris_batch.c @@ -731,7 +731,7 @@ _iris_batch_flush(struct iris_batch *batch, const char *file, int line) */ if (ret == -EIO && replace_hw_ctx(batch)) { if (batch->reset->reset) { - /* Tell the state tracker the device is lost and it was our fault. */ + /* Tell gallium frontends the device is lost and it was our fault. */ batch->reset->reset(batch->reset->data, PIPE_GUILTY_CONTEXT_RESET); } diff --git a/src/gallium/drivers/iris/iris_formats.c b/src/gallium/drivers/iris/iris_formats.c index dc497c161bd..03d8c0bbc0e 100644 --- a/src/gallium/drivers/iris/iris_formats.c +++ b/src/gallium/drivers/iris/iris_formats.c @@ -189,7 +189,7 @@ iris_is_format_supported(struct pipe_screen *pscreen, /* Don't advertise 3-component RGB formats for non-buffer textures. * This ensures that they are renderable from an API perspective since - * the state tracker will fall back to RGBA or RGBX, which are + * gallium frontends will fall back to RGBA or RGBX, which are * renderable. We want to render internally for copies and blits, * even if the application doesn't. * diff --git a/src/gallium/drivers/iris/iris_state.c b/src/gallium/drivers/iris/iris_state.c index ee643c2ce84..284d9d69e77 100644 --- a/src/gallium/drivers/iris/iris_state.c +++ b/src/gallium/drivers/iris/iris_state.c @@ -1334,7 +1334,7 @@ iris_create_zsa_state(struct pipe_context *ctx, state->stencil[0].writemask != 0 || (two_sided_stencil && state->stencil[1].writemask != 0); - /* The state tracker needs to optimize away EQUAL writes for us. */ + /* gallium frontends need to optimize away EQUAL writes for us. */ assert(!(state->depth.func == PIPE_FUNC_EQUAL && state->depth.writemask)); iris_pack_command(GENX(3DSTATE_WM_DEPTH_STENCIL), cso->wmds, wmds) { @@ -1987,7 +1987,7 @@ iris_upload_sampler_states(struct iris_context *ice, gl_shader_stage stage) struct iris_shader_state *shs = &ice->state.shaders[stage]; const struct shader_info *info = iris_get_shader_info(ice, stage); - /* We assume the state tracker will call pipe->bind_sampler_states() + /* We assume gallium frontends will call pipe->bind_sampler_states() * if the program's number of textures changes. */ unsigned count = info ? util_last_bit(info->textures_used) : 0; @@ -2586,7 +2586,7 @@ iris_create_surface(struct pipe_context *ctx, * texture, the tile offsets may be anything and we can't rely on * X/Y Offset. * - * Return NULL to force the state tracker to take fallback paths. + * Return NULL to force gallium frontends to take fallback paths. */ if (view->array_len > 1 || GEN_GEN == 8) return NULL; diff --git a/src/gallium/drivers/llvmpipe/lp_setup.c b/src/gallium/drivers/llvmpipe/lp_setup.c index d7ec3591c6e..0d8bc463263 100644 --- a/src/gallium/drivers/llvmpipe/lp_setup.c +++ b/src/gallium/drivers/llvmpipe/lp_setup.c @@ -440,7 +440,7 @@ lp_setup_try_clear_color_buffer(struct lp_setup_context *setup, else { /* Put ourselves into the 'pre-clear' state, specifically to try * and accumulate multiple clears to color and depth_stencil - * buffers which the app or state-tracker might issue + * buffers which the app or gallium frontend might issue * separately. */ set_scene_state( setup, SETUP_CLEARED, __FUNCTION__ ); @@ -504,7 +504,7 @@ lp_setup_try_clear_zs(struct lp_setup_context *setup, else { /* Put ourselves into the 'pre-clear' state, specifically to try * and accumulate multiple clears to color and depth_stencil - * buffers which the app or state-tracker might issue + * buffers which the app or gallium frontend might issue * separately. */ set_scene_state( setup, SETUP_CLEARED, __FUNCTION__ ); diff --git a/src/gallium/drivers/llvmpipe/lp_state_derived.c b/src/gallium/drivers/llvmpipe/lp_state_derived.c index 5d51736964a..a0f6e2485d2 100644 --- a/src/gallium/drivers/llvmpipe/lp_state_derived.c +++ b/src/gallium/drivers/llvmpipe/lp_state_derived.c @@ -178,7 +178,7 @@ compute_vertex_info(struct llvmpipe_context *llvmpipe) * Called just prior to drawing anything (pipe::draw_arrays(), etc). * * Hopefully this will remain quite simple, otherwise need to pull in - * something like the state tracker mechanism. + * something like the gallium frontend mechanism. */ void llvmpipe_update_derived( struct llvmpipe_context *llvmpipe ) { diff --git a/src/gallium/drivers/llvmpipe/lp_state_sampler.c b/src/gallium/drivers/llvmpipe/lp_state_sampler.c index 6c5511e3e81..5bebc10ea21 100644 --- a/src/gallium/drivers/llvmpipe/lp_state_sampler.c +++ b/src/gallium/drivers/llvmpipe/lp_state_sampler.c @@ -191,7 +191,7 @@ llvmpipe_create_sampler_view(struct pipe_context *pipe, #ifdef DEBUG /* * This is possibly too lenient, but the primary reason is just - * to catch state trackers which forget to initialize this, so + * to catch gallium frontends which forget to initialize this, so * it only catches clearly impossible view targets. */ if (view->target != texture->target) { diff --git a/src/gallium/drivers/llvmpipe/lp_texture.c b/src/gallium/drivers/llvmpipe/lp_texture.c index cbeaf3fd0ba..efcfbed80d5 100644 --- a/src/gallium/drivers/llvmpipe/lp_texture.c +++ b/src/gallium/drivers/llvmpipe/lp_texture.c @@ -545,7 +545,7 @@ llvmpipe_transfer_map_ms( struct pipe_context *pipe, do_not_block, __FUNCTION__)) { /* - * It would have blocked, but state tracker requested no to. + * It would have blocked, but gallium frontend requested no to. */ assert(do_not_block); return NULL; diff --git a/src/gallium/drivers/nouveau/nvc0/nvc0_screen.c b/src/gallium/drivers/nouveau/nvc0/nvc0_screen.c index 7abbf762af2..d1390aa32ad 100644 --- a/src/gallium/drivers/nouveau/nvc0/nvc0_screen.c +++ b/src/gallium/drivers/nouveau/nvc0/nvc0_screen.c @@ -57,7 +57,7 @@ nvc0_screen_is_format_supported(struct pipe_screen *pscreen, if (MAX2(1, sample_count) != MAX2(1, storage_sample_count)) return false; - /* Short-circuit the rest of the logic -- this is used by the state tracker + /* Short-circuit the rest of the logic -- this is used by the gallium frontend * to determine valid MS levels in a no-attachments scenario. */ if (format == PIPE_FORMAT_NONE && bindings & PIPE_BIND_RENDER_TARGET) diff --git a/src/gallium/drivers/panfrost/pan_job.c b/src/gallium/drivers/panfrost/pan_job.c index 5b02701392a..51c625554a5 100644 --- a/src/gallium/drivers/panfrost/pan_job.c +++ b/src/gallium/drivers/panfrost/pan_job.c @@ -1313,7 +1313,7 @@ panfrost_batch_clear(struct panfrost_batch *batch, /* Clearing affects the entire framebuffer (by definition -- this is * the Gallium clear callback, which clears the whole framebuffer. If - * the scissor test were enabled from the GL side, the state tracker + * the scissor test were enabled from the GL side, the gallium frontend * would emit a quad instead and we wouldn't go down this code path) */ panfrost_batch_union_scissor(batch, 0, 0, diff --git a/src/gallium/drivers/panfrost/pan_mfbd.c b/src/gallium/drivers/panfrost/pan_mfbd.c index 1350e17485a..131f396b21d 100644 --- a/src/gallium/drivers/panfrost/pan_mfbd.c +++ b/src/gallium/drivers/panfrost/pan_mfbd.c @@ -254,7 +254,7 @@ panfrost_mfbd_set_zsbuf( if (rsrc->layout == MALI_TEXTURE_AFBC) { /* The only Z/S format we can compress is Z24S8 or variants - * thereof (handled by the state tracker) */ + * thereof (handled by the gallium frontend) */ assert(panfrost_is_z24s8_variant(surf->format)); unsigned header_size = rsrc->slices[level].header_size; diff --git a/src/gallium/drivers/panfrost/pan_resource.c b/src/gallium/drivers/panfrost/pan_resource.c index 2ccbe6d7acd..9443f93e666 100644 --- a/src/gallium/drivers/panfrost/pan_resource.c +++ b/src/gallium/drivers/panfrost/pan_resource.c @@ -817,7 +817,7 @@ panfrost_generate_mipmap( PIPE_TEX_FILTER_LINEAR); /* If the blit was successful, flush once more. If it wasn't, well, let - * the state tracker deal with it. */ + * the gallium frontend deal with it. */ if (blit_res) { panfrost_flush_batches_accessing_bo(ctx, rsrc->bo, PAN_BO_ACCESS_WRITE); diff --git a/src/gallium/drivers/panfrost/pan_screen.c b/src/gallium/drivers/panfrost/pan_screen.c index ecfac6cddb0..c422625409e 100644 --- a/src/gallium/drivers/panfrost/pan_screen.c +++ b/src/gallium/drivers/panfrost/pan_screen.c @@ -506,7 +506,7 @@ panfrost_is_format_supported( struct pipe_screen *screen, * and then in the off-chance there's a CPU read we blit back to * staging. * - * ...alternatively, we can make the state tracker deal with that. */ + * ...alternatively, we can make the gallium frontend deal with that. */ if (bind & PIPE_BIND_DEPTH_STENCIL) { switch (format) { diff --git a/src/gallium/drivers/r300/r300_context.c b/src/gallium/drivers/r300/r300_context.c index 0a68d37b806..114f74ead24 100644 --- a/src/gallium/drivers/r300/r300_context.c +++ b/src/gallium/drivers/r300/r300_context.c @@ -262,7 +262,7 @@ static boolean r300_setup_atoms(struct r300_context* r300) return TRUE; } -/* Not every state tracker calls every driver function before the first draw +/* Not every gallium frontend calls every driver function before the first draw * call and we must initialize the command buffers somehow. */ static void r300_init_states(struct pipe_context *pipe) { diff --git a/src/gallium/drivers/r300/r300_context.h b/src/gallium/drivers/r300/r300_context.h index 667d3fd3306..e63beee26b0 100644 --- a/src/gallium/drivers/r300/r300_context.h +++ b/src/gallium/drivers/r300/r300_context.h @@ -280,7 +280,7 @@ struct r300_constant_buffer { * This is not a subclass of pipe_query because pipe_query is never * actually fully defined. So, rather than have it as a member, and do * subclass-style casting, we treat pipe_query as an opaque, and just - * trust that our state tracker does not ever mess up query objects. + * trust that our gallium frontend does not ever mess up query objects. */ struct r300_query { /* The kind of query. Currently only OQ is supported. */ diff --git a/src/gallium/drivers/r300/r300_render.c b/src/gallium/drivers/r300/r300_render.c index 9c21023481c..18e3e3b4579 100644 --- a/src/gallium/drivers/r300/r300_render.c +++ b/src/gallium/drivers/r300/r300_render.c @@ -324,7 +324,7 @@ static boolean immd_is_good_idea(struct r300_context *r300, } /* Buffers can only be used for read by r300 (except query buffers, but - * those can't be bound by a state tracker as vertex buffers). */ + * those can't be bound by an gallium frontend as vertex buffers). */ return TRUE; } diff --git a/src/gallium/drivers/r600/r600_pipe_common.c b/src/gallium/drivers/r600/r600_pipe_common.c index 931f7c697b6..ac59ae55389 100644 --- a/src/gallium/drivers/r600/r600_pipe_common.c +++ b/src/gallium/drivers/r600/r600_pipe_common.c @@ -356,9 +356,9 @@ static void r600_flush_from_st(struct pipe_context *ctx, ws->cs_sync_flush(rctx->gfx.cs); } else { /* Instead of flushing, create a deferred fence. Constraints: - * - The state tracker must allow a deferred flush. - * - The state tracker must request a fence. - * Thread safety in fence_finish must be ensured by the state tracker. + * - the gallium frontend must allow a deferred flush. + * - the gallium frontend must request a fence. + * Thread safety in fence_finish must be ensured by the gallium frontend. */ if (flags & PIPE_FLUSH_DEFERRED && fence) { gfx_fence = rctx->ws->cs_get_next_fence(rctx->gfx.cs); diff --git a/src/gallium/drivers/r600/r600_state_common.c b/src/gallium/drivers/r600/r600_state_common.c index 5deb905c630..590d4946727 100644 --- a/src/gallium/drivers/r600/r600_state_common.c +++ b/src/gallium/drivers/r600/r600_state_common.c @@ -1191,7 +1191,7 @@ static void r600_set_constant_buffer(struct pipe_context *ctx, struct pipe_constant_buffer *cb; const uint8_t *ptr; - /* Note that the state tracker can unbind constant buffers by + /* Note that the gallium frontend can unbind constant buffers by * passing NULL here. */ if (unlikely(!input || (!input->buffer && !input->user_buffer))) { @@ -1871,7 +1871,7 @@ static bool r600_update_derived_state(struct r600_context *rctx) * to LS slots and won't reflect what is dirty as VS stage even if the * TES didn't overwrite it. The story for re-enabled TES is similar. * In any case, we're not allowed to submit any TES state when - * TES is disabled (the state tracker may not do this but this looks + * TES is disabled (the gallium frontend may not do this but this looks * like an optimization to me, not something which can be relied on). */ diff --git a/src/gallium/drivers/radeonsi/si_fence.c b/src/gallium/drivers/radeonsi/si_fence.c index 91d1bed505d..f6505ecf26c 100644 --- a/src/gallium/drivers/radeonsi/si_fence.c +++ b/src/gallium/drivers/radeonsi/si_fence.c @@ -490,10 +490,10 @@ static void si_flush_from_st(struct pipe_context *ctx, struct pipe_fence_handle ws->cs_sync_flush(sctx->gfx_cs); } else { /* Instead of flushing, create a deferred fence. Constraints: - * - The state tracker must allow a deferred flush. - * - The state tracker must request a fence. + * - the gallium frontend must allow a deferred flush. + * - the gallium frontend must request a fence. * - fence_get_fd is not allowed. - * Thread safety in fence_finish must be ensured by the state tracker. + * Thread safety in fence_finish must be ensured by the gallium frontend. */ if (flags & PIPE_FLUSH_DEFERRED && !(flags & PIPE_FLUSH_FENCE_FD) && fence) { gfx_fence = sctx->ws->cs_get_next_fence(sctx->gfx_cs); diff --git a/src/gallium/drivers/radeonsi/si_gfx_cs.c b/src/gallium/drivers/radeonsi/si_gfx_cs.c index 087df67d61d..d6baf1ec9d4 100644 --- a/src/gallium/drivers/radeonsi/si_gfx_cs.c +++ b/src/gallium/drivers/radeonsi/si_gfx_cs.c @@ -112,7 +112,7 @@ void si_flush_gfx_cs(struct si_context *ctx, unsigned flags, struct pipe_fence_h ctx->gfx_flush_in_progress = true; - /* If the state tracker is flushing the GFX IB, si_flush_from_st is + /* If the gallium frontend is flushing the GFX IB, si_flush_from_st is * responsible for flushing the DMA IB and merging the fences from both. * If the driver flushes the GFX IB internally, and it should never ask * for a fence handle. diff --git a/src/gallium/drivers/radeonsi/si_pipe.c b/src/gallium/drivers/radeonsi/si_pipe.c index f3457924e77..832799de0d0 100644 --- a/src/gallium/drivers/radeonsi/si_pipe.c +++ b/src/gallium/drivers/radeonsi/si_pipe.c @@ -322,7 +322,7 @@ static enum pipe_reset_status si_get_reset_status(struct pipe_context *ctx) enum pipe_reset_status status = sctx->ws->ctx_query_reset_status(sctx->ctx); if (status != PIPE_NO_RESET) { - /* Call the state tracker to set a no-op API dispatch. */ + /* Call the gallium frontend to set a no-op API dispatch. */ if (sctx->device_reset_callback.reset) { sctx->device_reset_callback.reset(sctx->device_reset_callback.data, status); } diff --git a/src/gallium/drivers/radeonsi/si_shader_nir.c b/src/gallium/drivers/radeonsi/si_shader_nir.c index ddbb5c5c9c7..07be19f4206 100644 --- a/src/gallium/drivers/radeonsi/si_shader_nir.c +++ b/src/gallium/drivers/radeonsi/si_shader_nir.c @@ -870,7 +870,7 @@ static void si_nir_lower_ps_inputs(struct nir_shader *nir) void si_nir_adjust_driver_locations(struct nir_shader *nir) { - /* Adjust the driver location of inputs and outputs. The state tracker + /* Adjust the driver location of inputs and outputs. the gallium frontend * interprets them as slots, while the ac/nir backend interprets them * as individual components. */ diff --git a/src/gallium/drivers/radeonsi/si_state.c b/src/gallium/drivers/radeonsi/si_state.c index b20a59de1a1..b9fea68ba02 100644 --- a/src/gallium/drivers/radeonsi/si_state.c +++ b/src/gallium/drivers/radeonsi/si_state.c @@ -4284,7 +4284,7 @@ struct pipe_sampler_view *si_create_sampler_view_custom(struct pipe_context *ctx depth = u_minify(depth, force_level); } - /* This is not needed if state trackers set last_layer correctly. */ + /* This is not needed if gallium frontends set last_layer correctly. */ if (state->target == PIPE_TEXTURE_1D || state->target == PIPE_TEXTURE_2D || state->target == PIPE_TEXTURE_RECT || state->target == PIPE_TEXTURE_CUBE) last_layer = state->u.tex.first_layer; @@ -4554,7 +4554,7 @@ static void si_emit_sample_mask(struct si_context *sctx) unsigned mask = sctx->sample_mask; /* Needed for line and polygon smoothing as well as for the Polaris - * small primitive filter. We expect the state tracker to take care of + * small primitive filter. We expect the gallium frontend to take care of * this for us. */ assert(mask == 0xffff || sctx->framebuffer.nr_samples > 1 || diff --git a/src/gallium/drivers/radeonsi/si_texture.c b/src/gallium/drivers/radeonsi/si_texture.c index edb5944aec3..328587c9565 100644 --- a/src/gallium/drivers/radeonsi/si_texture.c +++ b/src/gallium/drivers/radeonsi/si_texture.c @@ -1283,7 +1283,7 @@ struct pipe_resource *si_texture_create(struct pipe_screen *screen, if (templ->nr_samples >= 2) { /* This is hackish (overwriting the const pipe_resource template), - * but should be harmless and state trackers can also see + * but should be harmless and gallium frontends can also see * the overriden number of samples in the created pipe_resource. */ if (is_zs && sscreen->eqaa_force_z_samples) { diff --git a/src/gallium/drivers/softpipe/sp_context.h b/src/gallium/drivers/softpipe/sp_context.h index bfa547df187..21b867ad1b7 100644 --- a/src/gallium/drivers/softpipe/sp_context.h +++ b/src/gallium/drivers/softpipe/sp_context.h @@ -132,7 +132,7 @@ struct softpipe_context { /** Which vertex shader output slot contains layer */ int8_t layer_slot; - /** The reduced version of the primitive supplied by the state tracker */ + /** The reduced version of the primitive supplied by the gallium frontend */ unsigned reduced_api_prim; /** Derived information about which winding orders to cull */ diff --git a/src/gallium/drivers/softpipe/sp_screen.c b/src/gallium/drivers/softpipe/sp_screen.c index f9d43bd6ea8..b2ce4cee4aa 100644 --- a/src/gallium/drivers/softpipe/sp_screen.c +++ b/src/gallium/drivers/softpipe/sp_screen.c @@ -451,7 +451,7 @@ softpipe_is_format_supported( struct pipe_screen *screen, /* * Although possible, it is unnatural to render into compressed or YUV * surfaces. So disable these here to avoid going into weird paths - * inside the state trackers. + * inside gallium frontends. */ if (format_desc->block.width != 1 || format_desc->block.height != 1) diff --git a/src/gallium/drivers/softpipe/sp_state_derived.c b/src/gallium/drivers/softpipe/sp_state_derived.c index f34997ab3d0..b4f87e02666 100644 --- a/src/gallium/drivers/softpipe/sp_state_derived.c +++ b/src/gallium/drivers/softpipe/sp_state_derived.c @@ -428,7 +428,7 @@ update_polygon_stipple_enable(struct softpipe_context *softpipe, unsigned prim) /* Hopefully this will remain quite simple, otherwise need to pull in - * something like the state tracker mechanism. + * something like the gallium frontend mechanism. */ void softpipe_update_derived(struct softpipe_context *softpipe, unsigned prim) diff --git a/src/gallium/drivers/softpipe/sp_tex_sample.c b/src/gallium/drivers/softpipe/sp_tex_sample.c index 5a0ec40d9c8..ab7f73e92bd 100644 --- a/src/gallium/drivers/softpipe/sp_tex_sample.c +++ b/src/gallium/drivers/softpipe/sp_tex_sample.c @@ -3599,7 +3599,7 @@ softpipe_create_sampler_view(struct pipe_context *pipe, #ifdef DEBUG /* * This is possibly too lenient, but the primary reason is just - * to catch state trackers which forget to initialize this, so + * to catch gallium frontends which forget to initialize this, so * it only catches clearly impossible view targets. */ if (view->target != resource->target) { diff --git a/src/gallium/drivers/svga/svga_context.h b/src/gallium/drivers/svga/svga_context.h index 60afb2b6740..eef8b88f594 100644 --- a/src/gallium/drivers/svga/svga_context.h +++ b/src/gallium/drivers/svga/svga_context.h @@ -452,7 +452,7 @@ struct svga_context boolean no_line_width; boolean force_hw_line_stipple; - /** To report perf/conformance/etc issues to the state tracker */ + /** To report perf/conformance/etc issues to the gallium frontend */ struct pipe_debug_callback callback; } debug; @@ -507,7 +507,7 @@ struct svga_context struct svga_hw_clear_state hw_clear; } state; - struct svga_state curr; /* state from the state tracker */ + struct svga_state curr; /* state from the gallium frontend */ unsigned dirty; /* statechanges since last update_state() */ union { diff --git a/src/gallium/drivers/svga/svga_pipe_blit.c b/src/gallium/drivers/svga/svga_pipe_blit.c index d889d4a13a8..31806ceb1e1 100644 --- a/src/gallium/drivers/svga/svga_pipe_blit.c +++ b/src/gallium/drivers/svga/svga_pipe_blit.c @@ -382,7 +382,7 @@ can_blit_via_intra_surface_copy(struct svga_context *svga, /** - * The state tracker implements some resource copies with blits (for + * the gallium frontend implements some resource copies with blits (for * GL_ARB_copy_image). This function checks if we should really do the blit * with a VGPU10 CopyRegion command or software fallback (for incompatible * src/dst formats). diff --git a/src/gallium/drivers/svga/svga_pipe_misc.c b/src/gallium/drivers/svga/svga_pipe_misc.c index 04707f61d2a..e0d1e51f412 100644 --- a/src/gallium/drivers/svga/svga_pipe_misc.c +++ b/src/gallium/drivers/svga/svga_pipe_misc.c @@ -208,7 +208,7 @@ svga_set_viewport_states(struct pipe_context *pipe, /** * Called by state tracker to specify a callback function the driver - * can use to report info back to the state tracker. + * can use to report info back to the gallium frontend. */ static void svga_set_debug_callback(struct pipe_context *pipe, diff --git a/src/gallium/drivers/svga/svga_resource_buffer.c b/src/gallium/drivers/svga/svga_resource_buffer.c index 1362ffed2b8..6629a8cc14d 100644 --- a/src/gallium/drivers/svga/svga_resource_buffer.c +++ b/src/gallium/drivers/svga/svga_resource_buffer.c @@ -62,7 +62,7 @@ svga_buffer_needs_hw_storage(const struct svga_screen *ss, */ bind_mask |= PIPE_BIND_CUSTOM; /* Uniform buffer objects. - * Make sure we don't create hardware storage for state-tracker + * Make sure we don't create hardware storage for gallium frontend * const0 buffers, because we frequently map them for reading. * They are distinguished by having PIPE_USAGE_STREAM, but not * PIPE_BIND_CUSTOM. @@ -217,7 +217,7 @@ svga_buffer_transfer_map(struct pipe_context *pipe, /* * We have a pending DMA upload from a hardware buffer, therefore * we need to ensure that the host finishes processing that DMA - * command before the state tracker can start overwriting the + * command before the gallium frontend can start overwriting the * hardware buffer. * * XXX: This could be avoided by tying the hardware buffer to @@ -464,7 +464,7 @@ svga_buffer_create(struct pipe_screen *screen, /* If the buffer is not used for constant buffer, set * the vertex/index bind flags as well so that the buffer will be * accepted for those uses. - * Note that the PIPE_BIND_ flags we get from the state tracker are + * Note that the PIPE_BIND_ flags we get from the gallium frontend are * just a hint about how the buffer may be used. And OpenGL buffer * object may be used for many different things. * Also note that we do not unconditionally set the streamout diff --git a/src/gallium/drivers/svga/svga_resource_texture.c b/src/gallium/drivers/svga/svga_resource_texture.c index 2385da2e999..2aa4e52faa7 100644 --- a/src/gallium/drivers/svga/svga_resource_texture.c +++ b/src/gallium/drivers/svga/svga_resource_texture.c @@ -937,7 +937,7 @@ svga_texture_create(struct pipe_screen *screen, /* Verify the number of mipmap levels isn't impossibly large. For example, * if the base 2D image is 16x16, we can't have 8 mipmap levels. - * The state tracker should never ask us to create a resource with invalid + * the gallium frontend should never ask us to create a resource with invalid * parameters. */ { @@ -1119,7 +1119,7 @@ svga_texture_create(struct pipe_screen *screen, * and it always requests PIPE_BIND_RENDER_TARGET, therefore * passing the SVGA3D_SURFACE_HINT_RENDERTARGET here defeats its purpose. * - * However, this was changed since other state trackers + * However, this was changed since other gallium frontends * (XA for example) uses it accurately and certain device versions * relies on it in certain situations to render correctly. */ diff --git a/src/gallium/drivers/svga/svga_screen.c b/src/gallium/drivers/svga/svga_screen.c index dc521cf3f9c..c8db3947e08 100644 --- a/src/gallium/drivers/svga/svga_screen.c +++ b/src/gallium/drivers/svga/svga_screen.c @@ -534,8 +534,8 @@ vgpu9_get_shader_param(struct pipe_screen *screen, /* * Although PS 3.0 has some addressing abilities it can only represent * loops that can be statically determined and unrolled. Given we can - * only handle a subset of the cases that the state tracker already - * does it is better to defer loop unrolling to the state tracker. + * only handle a subset of the cases that the gallium frontend already + * does it is better to defer loop unrolling to the gallium frontend. */ return 0; case PIPE_SHADER_CAP_TGSI_CONT_SUPPORTED: diff --git a/src/gallium/drivers/svga/svga_winsys.h b/src/gallium/drivers/svga/svga_winsys.h index 20096c036c9..e489acd078b 100644 --- a/src/gallium/drivers/svga/svga_winsys.h +++ b/src/gallium/drivers/svga/svga_winsys.h @@ -449,7 +449,7 @@ struct svga_winsys_context struct svga_winsys_gb_shader *shader, unsigned flags); - /** To report perf/conformance/etc issues to the state tracker */ + /** To report perf/conformance/etc issues to the gallium frontend */ struct pipe_debug_callback *debug_callback; /** The more recent command issued to command buffer */ diff --git a/src/gallium/drivers/swr/swr_screen.cpp b/src/gallium/drivers/swr/swr_screen.cpp index 2939637f1c5..9e8ee45bfb5 100644 --- a/src/gallium/drivers/swr/swr_screen.cpp +++ b/src/gallium/drivers/swr/swr_screen.cpp @@ -127,7 +127,7 @@ swr_is_format_supported(struct pipe_screen *_screen, /* * Although possible, it is unnatural to render into compressed or YUV * surfaces. So disable these here to avoid going into weird paths - * inside the state trackers. + * inside gallium frontends. */ if (format_desc->block.width != 1 || format_desc->block.height != 1) return false; diff --git a/src/gallium/drivers/v3d/v3dx_state.c b/src/gallium/drivers/v3d/v3dx_state.c index 8e58468006c..ee41b9fa75e 100644 --- a/src/gallium/drivers/v3d/v3dx_state.c +++ b/src/gallium/drivers/v3d/v3dx_state.c @@ -453,7 +453,7 @@ v3d_set_constant_buffer(struct pipe_context *pctx, uint shader, uint index, util_copy_constant_buffer(&so->cb[index], cb); - /* Note that the state tracker can unbind constant buffers by + /* Note that the gallium frontend can unbind constant buffers by * passing NULL here. */ if (unlikely(!cb)) { diff --git a/src/gallium/drivers/vc4/vc4_state.c b/src/gallium/drivers/vc4/vc4_state.c index 1e4657a7922..77431e4557c 100644 --- a/src/gallium/drivers/vc4/vc4_state.c +++ b/src/gallium/drivers/vc4/vc4_state.c @@ -387,7 +387,7 @@ vc4_set_constant_buffer(struct pipe_context *pctx, struct vc4_context *vc4 = vc4_context(pctx); struct vc4_constbuf_stateobj *so = &vc4->constbuf[shader]; - /* Note that the state tracker can unbind constant buffers by + /* Note that the gallium frontend can unbind constant buffers by * passing NULL here. */ if (unlikely(!cb)) { diff --git a/src/gallium/drivers/virgl/virgl_screen.c b/src/gallium/drivers/virgl/virgl_screen.c index 6ce08b764ec..4cbca21ac96 100644 --- a/src/gallium/drivers/virgl/virgl_screen.c +++ b/src/gallium/drivers/virgl/virgl_screen.c @@ -725,7 +725,7 @@ virgl_is_format_supported( struct pipe_screen *screen, /* * Although possible, it is unnatural to render into compressed or YUV * surfaces. So disable these here to avoid going into weird paths - * inside the state trackers. + * inside gallium frontends. */ if (format_desc->block.width != 1 || format_desc->block.height != 1) diff --git a/src/gallium/frontends/clover/core/object.hpp b/src/gallium/frontends/clover/core/object.hpp index 8fc2175d236..4f233425145 100644 --- a/src/gallium/frontends/clover/core/object.hpp +++ b/src/gallium/frontends/clover/core/object.hpp @@ -35,7 +35,7 @@ #include "util/macros.h" /// -/// Main namespace of the CL state tracker. +/// Main namespace of the CL gallium frontend. /// namespace clover { /// diff --git a/src/gallium/frontends/dri/dri2.c b/src/gallium/frontends/dri/dri2.c index 334934b85c7..bfbaa1bd84a 100644 --- a/src/gallium/frontends/dri/dri2.c +++ b/src/gallium/frontends/dri/dri2.c @@ -594,10 +594,10 @@ dri2_allocate_textures(struct dri_context *ctx, * such that they contain the same data as the single-sample * resources we just got from the X server. * - * The reason for this is that the state tracker (and + * The reason for this is that the gallium frontend (and * therefore the app) can access the MSAA resources only. * The single-sample resources are not exposed - * to the state tracker. + * to the gallium frontend. * */ dri_pipe_blit(ctx->st->pipe, @@ -748,7 +748,7 @@ dri2_create_image_from_winsys(__DRIscreen *_screen, tex_usage |= PIPE_BIND_SAMPLER_VIEW; if (!tex_usage && util_format_is_yuv(map->pipe_format)) { - /* YUV format sampling can be emulated by the Mesa state tracker by + /* YUV format sampling can be emulated by the GL gallium frontend by * using multiple samplers of varying formats. * If no tex_usage is set and we detect a YUV format, * test for support of all planes' sampler formats and diff --git a/src/gallium/frontends/dri/dri_drawable.c b/src/gallium/frontends/dri/dri_drawable.c index 2ee4f185537..5ef0a2ca077 100644 --- a/src/gallium/frontends/dri/dri_drawable.c +++ b/src/gallium/frontends/dri/dri_drawable.c @@ -107,7 +107,7 @@ dri_st_framebuffer_validate(struct st_context_iface *stctx, if (!out) return true; - /* Set the window-system buffers for the state tracker. */ + /* Set the window-system buffers for the gallium frontend. */ for (i = 0; i < count; i++) pipe_resource_reference(&out[i], textures[statts[i]]); @@ -130,7 +130,7 @@ dri_st_framebuffer_flush_front(struct st_context_iface *stctx, } /** - * The state tracker framebuffer interface flush_swapbuffers callback + * The gallium frontend framebuffer interface flush_swapbuffers callback */ static bool dri_st_framebuffer_flush_swapbuffers(struct st_context_iface *stctx, @@ -552,8 +552,8 @@ dri_flush(__DRIcontext *cPriv, drawable->msaa_textures[ST_ATTACHMENT_BACK_LEFT]; drawable->msaa_textures[ST_ATTACHMENT_BACK_LEFT] = tmp; - /* Now that we have swapped the buffers, this tells the state - * tracker to revalidate the framebuffer. + /* Now that we have swapped the buffers, this tells the gallium + * frontend to revalidate the framebuffer. */ p_atomic_inc(&drawable->base.stamp); } diff --git a/src/gallium/frontends/dri/dri_screen.c b/src/gallium/frontends/dri/dri_screen.c index fee392bba31..a6ba68eaec3 100644 --- a/src/gallium/frontends/dri/dri_screen.c +++ b/src/gallium/frontends/dri/dri_screen.c @@ -451,7 +451,7 @@ dri_fill_st_visual(struct st_visual *stvis, if (mode->depthBits > 0 || mode->stencilBits > 0) stvis->buffer_mask |= ST_ATTACHMENT_DEPTH_STENCIL_MASK; - /* let the state tracker allocate the accum buffer */ + /* let the gallium frontend allocate the accum buffer */ } static bool diff --git a/src/gallium/frontends/glx/xlib/xm_public.h b/src/gallium/frontends/glx/xlib/xm_public.h index 9afc5f5d7cf..05fa7848e10 100644 --- a/src/gallium/frontends/glx/xlib/xm_public.h +++ b/src/gallium/frontends/glx/xlib/xm_public.h @@ -34,7 +34,7 @@ struct pipe_screen; struct st_api; -/* This is the driver interface required by the glx/xlib state tracker. +/* This is the driver interface required by the glx/xlib frontends. */ struct xm_driver { struct pipe_screen *(*create_pipe_screen)( Display *display ); diff --git a/src/gallium/frontends/hgl/hgl_context.h b/src/gallium/frontends/hgl/hgl_context.h index 26a61f069a4..4cb452657ae 100644 --- a/src/gallium/frontends/hgl/hgl_context.h +++ b/src/gallium/frontends/hgl/hgl_context.h @@ -55,13 +55,13 @@ struct hgl_buffer struct hgl_context { struct st_api* api; - // State Tracker API + // API struct st_manager* manager; - // State Tracker Manager + // Manager struct st_context_iface* st; - // State Tracker Interface Object + // Interface Object struct st_visual* stVisual; - // State Tracker Visual + // Visual struct pipe_screen* screen; diff --git a/src/gallium/frontends/nine/swapchain9.c b/src/gallium/frontends/nine/swapchain9.c index e3426b481cd..9faf83f3418 100644 --- a/src/gallium/frontends/nine/swapchain9.c +++ b/src/gallium/frontends/nine/swapchain9.c @@ -453,7 +453,7 @@ NineSwapChain9_Resize( struct NineSwapChain9 *This, return D3D_OK; } -/* Throttling: code adapted from the dri state tracker */ +/* Throttling: code adapted from the dri frontend */ /** * swap_fences_pop_front - pull a fence from the throttle queue diff --git a/src/gallium/frontends/osmesa/osmesa.c b/src/gallium/frontends/osmesa/osmesa.c index 8689c1113a3..23537c3602e 100644 --- a/src/gallium/frontends/osmesa/osmesa.c +++ b/src/gallium/frontends/osmesa/osmesa.c @@ -23,7 +23,7 @@ /* * Off-Screen rendering into client memory. - * State tracker for gallium (for softpipe and llvmpipe) + * OpenGL gallium frontend for softpipe and llvmpipe. * * Notes: * diff --git a/src/gallium/frontends/vdpau/surface.c b/src/gallium/frontends/vdpau/surface.c index bce4400b0ee..799c2cb1f1b 100644 --- a/src/gallium/frontends/vdpau/surface.c +++ b/src/gallium/frontends/vdpau/surface.c @@ -461,7 +461,7 @@ vlVdpVideoSurfaceClear(vlVdpSurface *vlsurf) } /** - * Interop to mesa state tracker + * Interop for the GL gallium frontend */ struct pipe_video_buffer *vlVdpVideoSurfaceGallium(VdpVideoSurface surface) { diff --git a/src/gallium/frontends/vdpau/vdpau_private.h b/src/gallium/frontends/vdpau/vdpau_private.h index 1f46f31a549..f69458445c2 100644 --- a/src/gallium/frontends/vdpau/vdpau_private.h +++ b/src/gallium/frontends/vdpau/vdpau_private.h @@ -546,7 +546,7 @@ VdpGenerateCSCMatrix vlVdpGenerateCSCMatrix; VdpPresentationQueueTargetCreateX11 vlVdpPresentationQueueTargetCreateX11; -/* interop to mesa state tracker */ +/* interop for GL gallium frontend */ VdpVideoSurfaceGallium vlVdpVideoSurfaceGallium; VdpOutputSurfaceGallium vlVdpOutputSurfaceGallium; VdpVideoSurfaceDMABuf vlVdpVideoSurfaceDMABuf; diff --git a/src/gallium/frontends/wgl/stw_pixelformat.c b/src/gallium/frontends/wgl/stw_pixelformat.c index 8696300f3e0..c4f8ff194ea 100644 --- a/src/gallium/frontends/wgl/stw_pixelformat.c +++ b/src/gallium/frontends/wgl/stw_pixelformat.c @@ -190,7 +190,7 @@ stw_pixelformat_add(struct stw_device *stw_dev, pfi->pfd.dwDamageMask = 0; /* - * since state trackers can allocate depth/stencil/accum buffers, we provide + * since gallium frontend can allocate depth/stencil/accum buffers, we provide * only color buffers here */ pfi->stvis.buffer_mask = ST_ATTACHMENT_FRONT_LEFT_MASK; diff --git a/src/gallium/frontends/wgl/stw_st.c b/src/gallium/frontends/wgl/stw_st.c index e173c816c7c..44bc60c45eb 100644 --- a/src/gallium/frontends/wgl/stw_st.c +++ b/src/gallium/frontends/wgl/stw_st.c @@ -385,7 +385,7 @@ stw_get_framebuffer_resource(struct st_framebuffer_iface *stfb, /** - * Create an st_api of the state tracker. + * Create an st_api of the gallium frontend. */ struct st_api * stw_st_create_api(void) diff --git a/src/gallium/frontends/wgl/stw_wgl.c b/src/gallium/frontends/wgl/stw_wgl.c index 9103c750ea9..bbb3beaf9e5 100644 --- a/src/gallium/frontends/wgl/stw_wgl.c +++ b/src/gallium/frontends/wgl/stw_wgl.c @@ -28,7 +28,7 @@ /** * @file * - * Fake WGL API implementation. + * Fake WGL gallium frontend. * * These functions implement the WGL API, on top of the ICD DDI, so that the * resulting DLL can be used as a drop-in replacement for the system's diff --git a/src/gallium/include/frontend/api.h b/src/gallium/include/frontend/api.h index 5bcb8d9fea6..a7e602c874f 100644 --- a/src/gallium/include/frontend/api.h +++ b/src/gallium/include/frontend/api.h @@ -30,19 +30,15 @@ #include "pipe/p_format.h" /** - * \file API for communication between state trackers and state tracker - * managers. + * \file API for communication between gallium frontends and supporting + * frontends such as DRI. * - * While both are state tackers, we use the term state tracker for rendering - * APIs such as OpenGL or OpenVG, and state tracker manager for window system - * APIs such as EGL or GLX in this file. - * - * This file defines an API to be implemented by both state trackers and state - * tracker managers. + * This file defines an API to be implemented by both gallium frontends and + * their managers. */ /** - * The supported rendering API of a state tracker. + * The supported rendering API. */ enum st_api_type { ST_API_OPENGL, @@ -69,7 +65,7 @@ enum st_profile_type #define ST_PROFILE_OPENGL_ES2_MASK (1 << ST_PROFILE_OPENGL_ES2) /** - * Optional API/state tracker features. + * Optional API features. */ enum st_api_feature { @@ -155,10 +151,10 @@ enum st_attachment_type { */ enum st_manager_param { /** - * The dri state tracker on old libGL's doesn't do the right thing + * The DRI frontend on old libGL's doesn't do the right thing * with regards to invalidating the framebuffers. * - * For the mesa state tracker that means that it needs to invalidate + * For the GL gallium frontend that means that it needs to invalidate * the framebuffer in glViewport itself. */ ST_MANAGER_BROKEN_INVALIDATE @@ -274,11 +270,11 @@ struct st_manager; /** * Represent a windowing system drawable. * - * The framebuffer is implemented by the state tracker manager and - * used by the state trackers. + * The framebuffer is implemented by the frontend manager and + * used by gallium frontends. * - * Instead of the winsys poking into the API context to figure - * out what buffers that might be needed in the future by the API + * Instead of the winsys poking into the frontend context to figure + * out what buffers that might be needed in the future by the frontend * context, it calls into the framebuffer to get the textures. * * This structure along with the notify_invalid_framebuffer @@ -303,12 +299,12 @@ struct st_framebuffer_iface uint32_t ID; /** - * The state tracker manager that manages this object. + * The frontend manager that manages this object. */ struct st_manager *state_manager; /** - * Available for the state tracker manager to use. + * Available for the frontend manager to use. */ void *st_manager_private; @@ -330,7 +326,7 @@ struct st_framebuffer_iface enum st_attachment_type statt); /** - * The state tracker asks for the textures it needs. + * the gallium frontend asks for the textures it needs. * * It should try to only ask for attachments that it currently renders * to, thus allowing the winsys to delay the allocation of textures not @@ -358,18 +354,18 @@ struct st_framebuffer_iface /** * Represent a rendering context. * - * This entity is created from st_api and used by the state tracker manager. + * This entity is created from st_api and used by the frontend manager. */ struct st_context_iface { /** - * Available for the state tracker and the manager to use. + * Available for the gallium frontend and the manager to use. */ void *st_context_private; void *st_manager_private; /** - * The state tracker manager that manages this object. + * The frontend manager that manages this object. */ struct st_manager *state_manager; @@ -435,9 +431,9 @@ struct st_context_iface /** - * Represent a state tracker manager. + * Represent a frontend manager. * - * This interface is implemented by the state tracker manager. It corresponds + * This interface is implemented by the frontend manager. It corresponds * to a "display" in the window system. */ struct st_manager @@ -477,12 +473,12 @@ struct st_manager struct util_queue_monitoring *queue_info); /** - * Destroy any private data used by the state tracker manager. + * Destroy any private data used by the frontend manager. */ void (*destroy)(struct st_manager *smapi); /** - * Available for the state tracker manager to use. + * Available for the frontend manager to use. */ void *st_manager_private; }; @@ -490,7 +486,7 @@ struct st_manager /** * Represent a rendering API such as OpenGL or OpenVG. * - * Implemented by the state tracker and used by the state tracker manager. + * Implemented by the gallium frontend and used by the frontend manager. */ struct st_api { diff --git a/src/gallium/include/frontend/xlibsw_api.h b/src/gallium/include/frontend/xlibsw_api.h index 49ffa5df13f..ad5119ba8e4 100644 --- a/src/gallium/include/frontend/xlibsw_api.h +++ b/src/gallium/include/frontend/xlibsw_api.h @@ -8,7 +8,7 @@ /* This is what the xlib software winsys expects to find in the * "private" field of flush_frontbuffers(). * - * Xlib-based state trackers somehow need to know this. + * Xlib-based gallium frontends somehow need to know this. */ struct xlib_drawable { Visual *visual; diff --git a/src/gallium/include/pipe/p_context.h b/src/gallium/include/pipe/p_context.h index 37957466ded..1869d22ad47 100644 --- a/src/gallium/include/pipe/p_context.h +++ b/src/gallium/include/pipe/p_context.h @@ -91,7 +91,7 @@ struct pipe_context { void *draw; /**< private, for draw module (temporary?) */ /** - * Stream uploaders created by the driver. All drivers, state trackers, and + * Stream uploaders created by the driver. All drivers, gallium frontends, and * modules should use them. * * Use u_upload_alloc or u_upload_data as many times as you want. diff --git a/src/gallium/include/pipe/p_defines.h b/src/gallium/include/pipe/p_defines.h index 723e328a32b..c805d3a78a7 100644 --- a/src/gallium/include/pipe/p_defines.h +++ b/src/gallium/include/pipe/p_defines.h @@ -255,10 +255,10 @@ enum pipe_transfer_usage /** * The transfer should map the texture storage directly. The driver may - * return NULL if that isn't possible, and the state tracker needs to cope + * return NULL if that isn't possible, and the gallium frontend needs to cope * with that and use an alternative path without this flag. * - * E.g. the state tracker could have a simpler path which maps textures and + * E.g. the gallium frontend could have a simpler path which maps textures and * does read/modify/write cycles on them directly, and a more complicated * path which uses minimal read and write transfers. * @@ -448,7 +448,7 @@ enum pipe_flush_flags #define PIPE_TEXTURE_BARRIER_FRAMEBUFFER (1 << 1) /** - * Resource binding flags -- state tracker must specify in advance all + * Resource binding flags -- gallium frontends must specify in advance all * the ways a resource might be used. */ #define PIPE_BIND_DEPTH_STENCIL (1 << 0) /* create_surface */ @@ -462,7 +462,7 @@ enum pipe_flush_flags /* gap */ #define PIPE_BIND_STREAM_OUTPUT (1 << 10) /* set_stream_output_buffers */ #define PIPE_BIND_CURSOR (1 << 11) /* mouse cursor */ -#define PIPE_BIND_CUSTOM (1 << 12) /* state-tracker/winsys usages */ +#define PIPE_BIND_CUSTOM (1 << 12) /* gallium frontend/winsys usages */ #define PIPE_BIND_GLOBAL (1 << 13) /* set_global_binding */ #define PIPE_BIND_SHADER_BUFFER (1 << 14) /* set_shader_buffers */ #define PIPE_BIND_SHADER_IMAGE (1 << 15) /* set_shader_images */ @@ -477,10 +477,9 @@ enum pipe_flush_flags * below do not fit within that and probably need to be migrated to some * other place. * - * It seems like scanout is used by the Xorg state tracker to ask for - * a texture suitable for actual scanout (hence the name), which - * implies extra layout constraints on some hardware. It may also - * have some special meaning regarding mouse cursor images. + * Scanout is used to ask for a texture suitable for actual scanout (hence + * the name), which implies extra layout constraints on some hardware. + * It may also have some special meaning regarding mouse cursor images. * * The shared flag is quite underspecified, but certainly isn't a * binding flag - it seems more like a message to the winsys to create @@ -504,7 +503,7 @@ enum pipe_flush_flags #define PIPE_RESOURCE_FLAG_SINGLE_THREAD_USE (1 << 4) #define PIPE_RESOURCE_FLAG_ENCRYPTED (1 << 5) #define PIPE_RESOURCE_FLAG_DRV_PRIV (1 << 8) /* driver/winsys private */ -#define PIPE_RESOURCE_FLAG_ST_PRIV (1 << 24) /* state-tracker/winsys private */ +#define PIPE_RESOURCE_FLAG_ST_PRIV (1 << 24) /* gallium frontend/winsys private */ /** * Hint about the expected lifecycle of a resource. @@ -1044,7 +1043,7 @@ enum pipe_shader_cap * get TGSI. * * Note that PIPE_SHADER_IR_TGSI should be zero for backwards compat with - * state trackers that only understand TGSI. + * gallium frontends that only understand TGSI. */ enum pipe_shader_ir { diff --git a/src/gallium/include/pipe/p_screen.h b/src/gallium/include/pipe/p_screen.h index 0f2831b6eda..a4b07c8ee25 100644 --- a/src/gallium/include/pipe/p_screen.h +++ b/src/gallium/include/pipe/p_screen.h @@ -223,7 +223,7 @@ struct pipe_screen { void *user_memory); /** - * Unlike pipe_resource::bind, which describes what state trackers want, + * Unlike pipe_resource::bind, which describes what gallium frontends want, * resources can have much greater capabilities in practice, often implied * by the tiling layout or memory placement. This function allows querying * whether a capability is supported beyond what was requested by state @@ -504,7 +504,7 @@ struct pipe_screen { /** * Run driver-specific NIR lowering and optimization passes. * - * State trackers should call this before passing shaders to drivers, + * gallium frontends should call this before passing shaders to drivers, * and ideally also before shader caching. * * \param optimize Whether the input shader hasn't been optimized and diff --git a/src/gallium/include/pipe/p_state.h b/src/gallium/include/pipe/p_state.h index 2a14b9a4359..b75906d148f 100644 --- a/src/gallium/include/pipe/p_state.h +++ b/src/gallium/include/pipe/p_state.h @@ -276,7 +276,7 @@ struct pipe_stream_output_info * * NOTE: since it is expected that the consumer will want to perform * additional passes on the nir_shader, the driver takes ownership of - * the nir_shader. If state trackers need to hang on to the IR (for + * the nir_shader. If gallium frontends need to hang on to the IR (for * example, variant management), it should use nir_shader_clone(). */ struct pipe_shader_state @@ -904,7 +904,7 @@ struct pipe_compute_state /** * Structure that contains a callback for debug messages from the driver back - * to the state tracker. + * to the gallium frontend. */ struct pipe_debug_callback { @@ -916,7 +916,7 @@ struct pipe_debug_callback /** * Callback for the driver to report debug/performance/etc information back - * to the state tracker. + * to the gallium frontend. * * \param data user-supplied data pointer * \param id message type identifier, if pointed value is 0, then a @@ -935,7 +935,7 @@ struct pipe_debug_callback /** * Structure that contains a callback for device reset messages from the driver - * back to the state tracker. + * back to the gallium frontend. * * The callback must not be called from driver-created threads. */ diff --git a/src/gallium/include/pipe/p_video_codec.h b/src/gallium/include/pipe/p_video_codec.h index 38255048d94..5ca587a6eb0 100644 --- a/src/gallium/include/pipe/p_video_codec.h +++ b/src/gallium/include/pipe/p_video_codec.h @@ -104,7 +104,7 @@ struct pipe_video_codec /** * flush any outstanding command buffers to the hardware - * should be called before a video_buffer is acessed by the state tracker again + * should be called before a video_buffer is acessed by the gallium frontend again */ void (*flush)(struct pipe_video_codec *codec); diff --git a/src/gallium/targets/libgl-gdi/libgl_gdi.c b/src/gallium/targets/libgl-gdi/libgl_gdi.c index 40e77354e9a..fd7b0aee3ef 100644 --- a/src/gallium/targets/libgl-gdi/libgl_gdi.c +++ b/src/gallium/targets/libgl-gdi/libgl_gdi.c @@ -118,7 +118,7 @@ gdi_present(struct pipe_screen *screen, HDC hDC) { /* This will fail if any interposing layer (trace, debug, etc) has - * been introduced between the state-trackers and the pipe driver. + * been introduced between the gallium frontends and the pipe driver. * * Ideally this would get replaced with a call to * pipe_screen::flush_frontbuffer(). diff --git a/src/gallium/tools/trace/README.txt b/src/gallium/tools/trace/README.txt index 830cd150fab..cb2b9f83a3a 100644 --- a/src/gallium/tools/trace/README.txt +++ b/src/gallium/tools/trace/README.txt @@ -2,7 +2,7 @@ These directory contains tools for manipulating traces produced by the trace pipe driver. -Most debug builds of state trackers already load the trace driver by default. +Most debug builds of gallium frontends already load the trace driver by default. To produce a trace do export GALLIUM_TRACE=foo.gtrace @@ -34,6 +34,6 @@ You can compare two JSON files by doing ./diff_state.py foo.json boo.json | less -If you're investigating a regression in a state tracker, you can obtain a good +If you're investigating a regression in an gallium frontend, you can obtain a good and bad trace, dump respective state in JSON, and then compare the states to identify the problem. diff --git a/src/mesa/state_tracker/st_cb_viewport.c b/src/mesa/state_tracker/st_cb_viewport.c index 8b50350fabb..315564b6fca 100644 --- a/src/mesa/state_tracker/st_cb_viewport.c +++ b/src/mesa/state_tracker/st_cb_viewport.c @@ -45,8 +45,8 @@ static void st_viewport(struct gl_context *ctx) return; /* - * Normally we'd want the state tracker manager to mark the drawables - * invalid only when needed. This will force the state tracker manager + * Normally we'd want the frontend manager to mark the drawables + * invalid only when needed. This will force the frontend manager * to revalidate the drawable, rather than just update the context with * the latest cached drawable info. */ diff --git a/src/mesa/state_tracker/st_manager.c b/src/mesa/state_tracker/st_manager.c index cc1572bcc31..ab2bfbc1f39 100644 --- a/src/mesa/state_tracker/st_manager.c +++ b/src/mesa/state_tracker/st_manager.c @@ -1248,7 +1248,7 @@ st_manager_add_color_renderbuffer(struct st_context *st, st_framebuffer_update_attachments(stfb); /* - * Force a call to the state tracker manager to validate the + * Force a call to the frontend manager to validate the * new renderbuffer. It might be that there is a window system * renderbuffer available. */ diff --git a/src/panfrost/encoder/pan_afbc.c b/src/panfrost/encoder/pan_afbc.c index f29020e15b8..cb429e4f8c0 100644 --- a/src/panfrost/encoder/pan_afbc.c +++ b/src/panfrost/encoder/pan_afbc.c @@ -94,7 +94,7 @@ panfrost_format_supports_afbc(enum pipe_format format) /* Z32/Z16/S8 are all compressible as well, but they are implemented as * Z24S8 with wasted bits. So Z24S8 is the only format we actually need - * to handle compressed, and we can make the state tracker deal with + * to handle compressed, and we can make the gallium frontend deal with * the rest. */ if (format == PIPE_FORMAT_Z24_UNORM_S8_UINT) diff --git a/src/util/merge_driinfo.py b/src/util/merge_driinfo.py index a09218a3902..0e071e5d7bf 100644 --- a/src/util/merge_driinfo.py +++ b/src/util/merge_driinfo.py @@ -25,7 +25,7 @@ usage: merge_driinfo.py <list of input files> Generates a source file which contains the DRI_CONF_xxx macros for generating the driinfo XML that describes the available DriConf options for a driver and -its supported state trackers, based on the merged information from the input +its supported gallium frontends, based on the merged information from the input files. """ |