fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2025-12-23 15:30:14 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions 1
mesa/src/intel/compiler/elk/elk_test_simd_selection.cpp
Caio Oliveira 6648e0ebd3 intel/elk: Rename symbols 
Either replace the BRW prefix with ELK or add an extra ELK prefix.  Used
the following sed script to perform the renames in this patch:

```
    # Simple prefix changes.
    s/\<BRW_/ELK_/g
    s/\<brw_/elk_/g
    s/nir_to_brw/nir_to_elk/g
    s/\<as_brw_reg\>/as_elk_reg/g
    s/\<_brw_/_elk_/g

    # Add prefix to various symbols.
    #
    # Initially I've considered using C++ namespaces here, but in various
    # cases the structs or functions had to be also visible from C code.
    # So added explicit prefix instead.
    s/\<backend_instruction/elk_\0/g
    s/\<backend_reg/elk_\0/g
    s/\<backend_shader/elk_\0/g
    s/\<bblock_t\>/elk_\0/g
    s/\<bblock_link\>/elk_\0/g
    s/\<cfg_t\>/elk_\0/g
    s/\<fs_visitor\>/elk_\0/g
    s/\<fs_reg\>/elk_\0/g
    s/\<fs_instruction_scheduler\>/elk_\0/g
    s/\<vec4_instruction_scheduler\>/elk_\0/g
    s/\<instruction_scheduler\>/elk_\0/g
    s/\<schedule_node\>/elk_\0/g
    s/\<schedule_node_child\>/elk_\0/g
    s/\<\([a-z]*_\)\?thread_payload\>/elk_\1thread_payload/g
    s/\<fs_generator\>/elk_\0/g
    s/\<fs_inst\>/elk_\0/g
    s/\<fs_reg_alloc\>/elk_\0/g
    s/\<disasm_info\>/elk_\0/g
    s/\<gfx._math\>/elk_\0/g
    s/\<gfx7_block_read_scratch\>/elk_\0/g
    s/\<gfx6_IF\>/elk_\0/g
    s/\<gfx9_fb_READ\>/elk_\0/g
    s/\<gfx6_resolve_implied_move\>/elk_\0/g

    # Opcodes.
    s/\<opcode op\>/elk_\0/g
    s/\<opcode mov_op\>/elk_\0/g
    s/\<opcode opcode\>/elk_\0/g
    s/enum opcode\>/enum elk_opcode/g
    s/static opcode\>/static elk_opcode/g
    s/\<opcode elk_op/elk_opcode elk_op/g
    s/struct opcode_desc/struct elk_opcode_desc/g
    s/NUM_BRW_OPCODES/NUM_ELK_OPCODES/g
    s/\<.._OPCODE_/ELK_\0/g
    s/\<T.._OPCODE_/ELK_\0/g
    s/\<VEC4_OPCODE_/ELK_\0/g
    s/\<VEC4_...\?_OPCODE_/ELK_\0/g
    s/\<SHADER_OPCODE_/ELK_\0/g

    # Remaining specific cases.
    s/\<wm_prog_data_barycentric_modes\>/elk_\0/g
    s/\<encode_slm_size\>/elk_\0/g
    s/\<intel_calculate_slm_size\>/elk_\0/g
    s/\<gfx6_gather_sampler_wa\>/elk_\0/g
    s/\<is_3src\>/elk_\0/g
    s/\<WA_/ELK_\0/g
    s/\<conditional_modifier\>/elk_\0/g
    s/\<pred_ctrl_align16\>/elk_\0/g
    s/\<shuffle_from_32bit_read\>/elk_\0/g
    s/\<shuffle_src_to_dst\>/elk_\0/g
    s/\<setup_imm_..\?\>/elk_\0/g

    s/\<opt_predicated_break\>/elk_\0/g
    s/\<has_bank_conflict\>/elk_\0/g
    s/\<dead_control_flow_eliminate\>/elk_\0/g

    s/\<disasm_new_inst_group\>/elk_\0/g
    s/\<disasm_initialize\>/elk_\0/g
    s/\<dump_assembly\>/elk_\0/g
    s/\<disasm_insert_error\>/elk_\0/g
    s/\<disasm_annotate\>/elk_\0/g

    s/\<enum lsc_opcode\>/enum elk_lsc_opcode/g
    s/\<lsc_opcode_/elk_lsc_opcode_/g
    s/\<lsc_aop_[a-z_]\+\>/elk_\0/g

    s/\<type_size_vec4\>/elk_\0/g
    s/\<type_size_dvec4\>/elk_\0/g
    s/\<type_size_xvec4\>/elk_\0/g
    s/\<type_size_[a-z4]\+_bytes\>/elk_\0/g

    s/\<gfx12_systolic_depth\>/elk_\0/g
```

Acked-by: Ian Romanick <ian.d.romanick@intel.com>
Reviewed-by: Kenneth Graunke <kenneth@whitecape.org>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/27563>
2024-02-24 00:24:31 +00:00

398 lines
13 KiB
C++
Raw Blame History

/*
* Copyright © 2021 Intel Corporation
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
* IN THE SOFTWARE.
*/
#include "elk_private.h"
#include "compiler/shader_info.h"
#include "intel/dev/intel_debug.h"
#include "intel/dev/intel_device_info.h"
#include "util/ralloc.h"
#include <gtest/gtest.h>
enum {
SIMD8 = 0,
SIMD16 = 1,
SIMD32 = 2,
};
const bool spilled = true;
const bool not_spilled = false;
class SIMDSelectionTest : public ::testing::Test {
protected:
SIMDSelectionTest()
: mem_ctx(ralloc_context(NULL))
, devinfo(rzalloc(mem_ctx, intel_device_info))
, prog_data(rzalloc(mem_ctx, struct elk_cs_prog_data))
, simd_state{
.devinfo = devinfo,
.prog_data = prog_data,
}
{
process_intel_debug_variable();
}
~SIMDSelectionTest() {
ralloc_free(mem_ctx);
};
void *mem_ctx;
intel_device_info *devinfo;
struct elk_cs_prog_data *prog_data;
elk_simd_selection_state simd_state;
};
class SIMDSelectionCS : public SIMDSelectionTest {
protected:
SIMDSelectionCS() {
prog_data->base.stage = MESA_SHADER_COMPUTE;
prog_data->local_size[0] = 32;
prog_data->local_size[1] = 1;
prog_data->local_size[2] = 1;
devinfo->max_cs_workgroup_threads = 64;
}
};
TEST_F(SIMDSelectionCS, DefaultsToSIMD16)
{
ASSERT_TRUE(elk_simd_should_compile(simd_state, SIMD8));
elk_simd_mark_compiled(simd_state, SIMD8, not_spilled);
ASSERT_TRUE(elk_simd_should_compile(simd_state, SIMD16));
elk_simd_mark_compiled(simd_state, SIMD16, not_spilled);
ASSERT_FALSE(elk_simd_should_compile(simd_state, SIMD32));
ASSERT_EQ(elk_simd_select(simd_state), SIMD16);
}
TEST_F(SIMDSelectionCS, TooBigFor16)
{
prog_data->local_size[0] = devinfo->max_cs_workgroup_threads;
prog_data->local_size[1] = 32;
prog_data->local_size[2] = 1;
ASSERT_FALSE(elk_simd_should_compile(simd_state, SIMD8));
ASSERT_FALSE(elk_simd_should_compile(simd_state, SIMD16));
ASSERT_TRUE(elk_simd_should_compile(simd_state, SIMD32));
elk_simd_mark_compiled(simd_state, SIMD32, spilled);
ASSERT_EQ(elk_simd_select(simd_state), SIMD32);
}
TEST_F(SIMDSelectionCS, WorkgroupSize1)
{
prog_data->local_size[0] = 1;
prog_data->local_size[1] = 1;
prog_data->local_size[2] = 1;
ASSERT_TRUE(elk_simd_should_compile(simd_state, SIMD8));
elk_simd_mark_compiled(simd_state, SIMD8, not_spilled);
ASSERT_FALSE(elk_simd_should_compile(simd_state, SIMD16));
ASSERT_FALSE(elk_simd_should_compile(simd_state, SIMD32));
ASSERT_EQ(elk_simd_select(simd_state), SIMD8);
}
TEST_F(SIMDSelectionCS, WorkgroupSize8)
{
prog_data->local_size[0] = 8;
prog_data->local_size[1] = 1;
prog_data->local_size[2] = 1;
ASSERT_TRUE(elk_simd_should_compile(simd_state, SIMD8));
elk_simd_mark_compiled(simd_state, SIMD8, not_spilled);
ASSERT_FALSE(elk_simd_should_compile(simd_state, SIMD16));
ASSERT_FALSE(elk_simd_should_compile(simd_state, SIMD32));
ASSERT_EQ(elk_simd_select(simd_state), SIMD8);
}
TEST_F(SIMDSelectionCS, WorkgroupSizeVariable)
{
prog_data->local_size[0] = 0;
prog_data->local_size[1] = 0;
prog_data->local_size[2] = 0;
ASSERT_TRUE(elk_simd_should_compile(simd_state, SIMD8));
elk_simd_mark_compiled(simd_state, SIMD8, not_spilled);
ASSERT_TRUE(elk_simd_should_compile(simd_state, SIMD16));
elk_simd_mark_compiled(simd_state, SIMD16, not_spilled);
ASSERT_TRUE(elk_simd_should_compile(simd_state, SIMD32));
elk_simd_mark_compiled(simd_state, SIMD32, not_spilled);
ASSERT_EQ(prog_data->prog_mask, 1u << SIMD8 | 1u << SIMD16 | 1u << SIMD32);
const unsigned wg_8_1_1[] = { 8, 1, 1 };
ASSERT_EQ(elk_simd_select_for_workgroup_size(devinfo, prog_data, wg_8_1_1), SIMD8);
const unsigned wg_16_1_1[] = { 16, 1, 1 };
ASSERT_EQ(elk_simd_select_for_workgroup_size(devinfo, prog_data, wg_16_1_1), SIMD16);
const unsigned wg_32_1_1[] = { 32, 1, 1 };
ASSERT_EQ(elk_simd_select_for_workgroup_size(devinfo, prog_data, wg_32_1_1), SIMD16);
}
TEST_F(SIMDSelectionCS, WorkgroupSizeVariableSpilled)
{
prog_data->local_size[0] = 0;
prog_data->local_size[1] = 0;
prog_data->local_size[2] = 0;
ASSERT_TRUE(elk_simd_should_compile(simd_state, SIMD8));
elk_simd_mark_compiled(simd_state, SIMD8, spilled);
ASSERT_TRUE(elk_simd_should_compile(simd_state, SIMD16));
elk_simd_mark_compiled(simd_state, SIMD16, spilled);
ASSERT_TRUE(elk_simd_should_compile(simd_state, SIMD32));
elk_simd_mark_compiled(simd_state, SIMD32, spilled);
ASSERT_EQ(prog_data->prog_mask, 1u << SIMD8 | 1u << SIMD16 | 1u << SIMD32);
const unsigned wg_8_1_1[] = { 8, 1, 1 };
ASSERT_EQ(elk_simd_select_for_workgroup_size(devinfo, prog_data, wg_8_1_1), SIMD8);
const unsigned wg_16_1_1[] = { 16, 1, 1 };
ASSERT_EQ(elk_simd_select_for_workgroup_size(devinfo, prog_data, wg_16_1_1), SIMD8);
const unsigned wg_32_1_1[] = { 32, 1, 1 };
ASSERT_EQ(elk_simd_select_for_workgroup_size(devinfo, prog_data, wg_32_1_1), SIMD8);
}
TEST_F(SIMDSelectionCS, WorkgroupSizeVariableNoSIMD8)
{
prog_data->local_size[0] = 0;
prog_data->local_size[1] = 0;
prog_data->local_size[2] = 0;
ASSERT_TRUE(elk_simd_should_compile(simd_state, SIMD8));
ASSERT_TRUE(elk_simd_should_compile(simd_state, SIMD16));
elk_simd_mark_compiled(simd_state, SIMD16, not_spilled);
ASSERT_TRUE(elk_simd_should_compile(simd_state, SIMD32));
elk_simd_mark_compiled(simd_state, SIMD32, not_spilled);
ASSERT_EQ(prog_data->prog_mask, 1u << SIMD16 | 1u << SIMD32);
const unsigned wg_8_1_1[] = { 8, 1, 1 };
ASSERT_EQ(elk_simd_select_for_workgroup_size(devinfo, prog_data, wg_8_1_1), SIMD16);
const unsigned wg_16_1_1[] = { 16, 1, 1 };
ASSERT_EQ(elk_simd_select_for_workgroup_size(devinfo, prog_data, wg_16_1_1), SIMD16);
const unsigned wg_32_1_1[] = { 32, 1, 1 };
ASSERT_EQ(elk_simd_select_for_workgroup_size(devinfo, prog_data, wg_32_1_1), SIMD16);
}
TEST_F(SIMDSelectionCS, WorkgroupSizeVariableNoSIMD16)
{
prog_data->local_size[0] = 0;
prog_data->local_size[1] = 0;
prog_data->local_size[2] = 0;
ASSERT_TRUE(elk_simd_should_compile(simd_state, SIMD8));
elk_simd_mark_compiled(simd_state, SIMD8, not_spilled);
ASSERT_TRUE(elk_simd_should_compile(simd_state, SIMD16));
ASSERT_TRUE(elk_simd_should_compile(simd_state, SIMD32));
elk_simd_mark_compiled(simd_state, SIMD32, not_spilled);
ASSERT_EQ(prog_data->prog_mask, 1u << SIMD8 | 1u << SIMD32);
const unsigned wg_8_1_1[] = { 8, 1, 1 };
ASSERT_EQ(elk_simd_select_for_workgroup_size(devinfo, prog_data, wg_8_1_1), SIMD8);
const unsigned wg_16_1_1[] = { 16, 1, 1 };
ASSERT_EQ(elk_simd_select_for_workgroup_size(devinfo, prog_data, wg_16_1_1), SIMD8);
const unsigned wg_32_1_1[] = { 32, 1, 1 };
ASSERT_EQ(elk_simd_select_for_workgroup_size(devinfo, prog_data, wg_32_1_1), SIMD8);
}
TEST_F(SIMDSelectionCS, WorkgroupSizeVariableNoSIMD8NoSIMD16)
{
prog_data->local_size[0] = 0;
prog_data->local_size[1] = 0;
prog_data->local_size[2] = 0;
ASSERT_TRUE(elk_simd_should_compile(simd_state, SIMD8));
ASSERT_TRUE(elk_simd_should_compile(simd_state, SIMD16));
ASSERT_TRUE(elk_simd_should_compile(simd_state, SIMD32));
elk_simd_mark_compiled(simd_state, SIMD32, not_spilled);
ASSERT_EQ(prog_data->prog_mask, 1u << SIMD32);
const unsigned wg_8_1_1[] = { 8, 1, 1 };
ASSERT_EQ(elk_simd_select_for_workgroup_size(devinfo, prog_data, wg_8_1_1), SIMD32);
const unsigned wg_16_1_1[] = { 16, 1, 1 };
ASSERT_EQ(elk_simd_select_for_workgroup_size(devinfo, prog_data, wg_16_1_1), SIMD32);
const unsigned wg_32_1_1[] = { 32, 1, 1 };
ASSERT_EQ(elk_simd_select_for_workgroup_size(devinfo, prog_data, wg_32_1_1), SIMD32);
}
TEST_F(SIMDSelectionCS, SpillAtSIMD8)
{
ASSERT_TRUE(elk_simd_should_compile(simd_state, SIMD8));
elk_simd_mark_compiled(simd_state, SIMD8, spilled);
ASSERT_FALSE(elk_simd_should_compile(simd_state, SIMD16));
ASSERT_FALSE(elk_simd_should_compile(simd_state, SIMD32));
ASSERT_EQ(elk_simd_select(simd_state), SIMD8);
}
TEST_F(SIMDSelectionCS, SpillAtSIMD16)
{
ASSERT_TRUE(elk_simd_should_compile(simd_state, SIMD8));
elk_simd_mark_compiled(simd_state, SIMD8, not_spilled);
ASSERT_TRUE(elk_simd_should_compile(simd_state, SIMD16));
elk_simd_mark_compiled(simd_state, SIMD16, spilled);
ASSERT_FALSE(elk_simd_should_compile(simd_state, SIMD32));
ASSERT_EQ(elk_simd_select(simd_state), SIMD8);
}
TEST_F(SIMDSelectionCS, EnvironmentVariable32)
{
intel_debug |= DEBUG_DO32;
ASSERT_TRUE(elk_simd_should_compile(simd_state, SIMD8));
elk_simd_mark_compiled(simd_state, SIMD8, not_spilled);
ASSERT_TRUE(elk_simd_should_compile(simd_state, SIMD16));
elk_simd_mark_compiled(simd_state, SIMD16, not_spilled);
ASSERT_TRUE(elk_simd_should_compile(simd_state, SIMD32));
elk_simd_mark_compiled(simd_state, SIMD32, not_spilled);
ASSERT_EQ(elk_simd_select(simd_state), SIMD32);
}
TEST_F(SIMDSelectionCS, EnvironmentVariable32ButSpills)
{
intel_debug |= DEBUG_DO32;
ASSERT_TRUE(elk_simd_should_compile(simd_state, SIMD8));
elk_simd_mark_compiled(simd_state, SIMD8, not_spilled);
ASSERT_TRUE(elk_simd_should_compile(simd_state, SIMD16));
elk_simd_mark_compiled(simd_state, SIMD16, not_spilled);
ASSERT_TRUE(elk_simd_should_compile(simd_state, SIMD32));
elk_simd_mark_compiled(simd_state, SIMD32, spilled);
ASSERT_EQ(elk_simd_select(simd_state), SIMD16);
}
TEST_F(SIMDSelectionCS, Require8)
{
simd_state.required_width = 8;
ASSERT_TRUE(elk_simd_should_compile(simd_state, SIMD8));
elk_simd_mark_compiled(simd_state, SIMD8, not_spilled);
ASSERT_FALSE(elk_simd_should_compile(simd_state, SIMD16));
ASSERT_FALSE(elk_simd_should_compile(simd_state, SIMD32));
ASSERT_EQ(elk_simd_select(simd_state), SIMD8);
}
TEST_F(SIMDSelectionCS, Require8ErrorWhenNotCompile)
{
simd_state.required_width = 8;
ASSERT_TRUE(elk_simd_should_compile(simd_state, SIMD8));
ASSERT_FALSE(elk_simd_should_compile(simd_state, SIMD16));
ASSERT_FALSE(elk_simd_should_compile(simd_state, SIMD32));
ASSERT_EQ(elk_simd_select(simd_state), -1);
}
TEST_F(SIMDSelectionCS, Require16)
{
simd_state.required_width = 16;
ASSERT_FALSE(elk_simd_should_compile(simd_state, SIMD8));
ASSERT_TRUE(elk_simd_should_compile(simd_state, SIMD16));
elk_simd_mark_compiled(simd_state, SIMD16, not_spilled);
ASSERT_FALSE(elk_simd_should_compile(simd_state, SIMD32));
ASSERT_EQ(elk_simd_select(simd_state), SIMD16);
}
TEST_F(SIMDSelectionCS, Require16ErrorWhenNotCompile)
{
simd_state.required_width = 16;
ASSERT_FALSE(elk_simd_should_compile(simd_state, SIMD8));
ASSERT_TRUE(elk_simd_should_compile(simd_state, SIMD16));
ASSERT_FALSE(elk_simd_should_compile(simd_state, SIMD32));
ASSERT_EQ(elk_simd_select(simd_state), -1);
}
TEST_F(SIMDSelectionCS, Require32)
{
simd_state.required_width = 32;
ASSERT_FALSE(elk_simd_should_compile(simd_state, SIMD8));
ASSERT_FALSE(elk_simd_should_compile(simd_state, SIMD16));
ASSERT_TRUE(elk_simd_should_compile(simd_state, SIMD32));
elk_simd_mark_compiled(simd_state, SIMD32, not_spilled);
ASSERT_EQ(elk_simd_select(simd_state), SIMD32);
}
TEST_F(SIMDSelectionCS, Require32ErrorWhenNotCompile)
{
simd_state.required_width = 32;
ASSERT_FALSE(elk_simd_should_compile(simd_state, SIMD8));
ASSERT_FALSE(elk_simd_should_compile(simd_state, SIMD16));
ASSERT_TRUE(elk_simd_should_compile(simd_state, SIMD32));
ASSERT_EQ(elk_simd_select(simd_state), -1);
}
TEST_F(SIMDSelectionCS, FirstCompiledIsSIMD8)
{
ASSERT_TRUE(elk_simd_should_compile(simd_state, SIMD8));
elk_simd_mark_compiled(simd_state, SIMD8, not_spilled);
ASSERT_TRUE(elk_simd_any_compiled(simd_state));
ASSERT_EQ(elk_simd_first_compiled(simd_state), SIMD8);
}
TEST_F(SIMDSelectionCS, FirstCompiledIsSIMD16)
{
ASSERT_TRUE(elk_simd_should_compile(simd_state, SIMD8));
ASSERT_TRUE(elk_simd_should_compile(simd_state, SIMD16));
elk_simd_mark_compiled(simd_state, SIMD16, not_spilled);
ASSERT_TRUE(elk_simd_any_compiled(simd_state));
ASSERT_EQ(elk_simd_first_compiled(simd_state), SIMD16);
}
TEST_F(SIMDSelectionCS, FirstCompiledIsSIMD32)
{
ASSERT_TRUE(elk_simd_should_compile(simd_state, SIMD8));
ASSERT_TRUE(elk_simd_should_compile(simd_state, SIMD16));
ASSERT_TRUE(elk_simd_should_compile(simd_state, SIMD32));
elk_simd_mark_compiled(simd_state, SIMD32, not_spilled);
ASSERT_TRUE(elk_simd_any_compiled(simd_state));
ASSERT_EQ(elk_simd_first_compiled(simd_state), SIMD32);
}
Reference in a new issue View git blame Copy permalink