src/compiler/nir/tests/serialize_tests.cpp

   1 /*
   2  * Copyright © 2019 Red Hat, Inc
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  21  * DEALINGS IN THE SOFTWARE.
  22  */
  23
  24 #include <gtest/gtest.h>
  25
  26 #include "nir.h"
  27 #include "nir_builder.h"
  28 #include "nir_serialize.h"
  29
  30 namespace {
  31
  32 class nir_serialize_test : public ::testing::TestWithParam<int> {
  33 protected:
  34    nir_serialize_test();
  35    ~nir_serialize_test();
  36
  37    void serialize();
  38    nir_alu_instr *get_last_alu(nir_shader *);
  39    void ASSERT_SWIZZLE_EQ(nir_alu_instr *, nir_alu_instr *, unsigned count, unsigned src);
  40
  41    void *mem_ctx;
  42    nir_builder *b;
  43    nir_shader *dup;
  44    const nir_shader_compiler_options options;
  45 };
  46
  47 nir_serialize_test::nir_serialize_test()
  48 :  options()
  49 {
  50    glsl_type_singleton_init_or_ref();
  51
  52    mem_ctx = ralloc_context(NULL);
  53
  54    b = rzalloc(mem_ctx, nir_builder);
  55    nir_builder_init_simple_shader(b, mem_ctx, MESA_SHADER_COMPUTE, &options);
  56 }
  57
  58 nir_serialize_test::~nir_serialize_test()
  59 {
  60    if (HasFailure()) {
  61       printf("\nShader from the failed test\n\n");
  62       printf("original Shader:\n");
  63       nir_print_shader(b->shader, stdout);
  64       printf("serialized Shader:\n");
  65       nir_print_shader(dup, stdout);
  66    }
  67
  68    ralloc_free(mem_ctx);
  69
  70    glsl_type_singleton_decref();
  71 }
  72
  73 void
  74 nir_serialize_test::serialize() {
  75    struct blob blob;
  76    struct blob_reader reader;
  77
  78    blob_init(&blob);
  79
  80    nir_serialize(&blob, b->shader, false);
  81    blob_reader_init(&reader, blob.data, blob.size);
  82    nir_shader *cloned = nir_deserialize(mem_ctx, &options, &reader);
  83    blob_finish(&blob);
  84
  85    dup = cloned;
  86
  87    nir_validate_shader(b->shader, "original");
  88    nir_validate_shader(b->shader, "cloned");
  89 }
  90
  91 nir_alu_instr *
  92 nir_serialize_test::get_last_alu(nir_shader *nir)
  93 {
  94    nir_function_impl *impl = nir_shader_get_entrypoint(nir);
  95    return nir_instr_as_alu(nir_block_last_instr(nir_impl_last_block(impl)));
  96 }
  97
  98 void
  99 nir_serialize_test::ASSERT_SWIZZLE_EQ(nir_alu_instr *a, nir_alu_instr *b, unsigned c, unsigned s)
 100 {
 101    ASSERT_EQ(memcmp(a->src[s].swizzle, b->src[s].swizzle, c), 0);
 102 }
 103
 104 class nir_serialize_all_test : public nir_serialize_test {};
 105 class nir_serialize_all_but_one_test : public nir_serialize_test {};
 106
 107 } // namespace
 108
 109 #if NIR_MAX_VEC_COMPONENTS == 16
 110 #define COMPONENTS 2, 3, 4, 8, 16
 111 #else
 112 #define COMPONENTS 2, 3, 4
 113 #endif
 114
 115
 116 INSTANTIATE_TEST_CASE_P(
 117    nir_serialize_all_test,
 118    nir_serialize_all_test,
 119    ::testing::Values(1, COMPONENTS)
 120 );
 121
 122 INSTANTIATE_TEST_CASE_P(
 123    nir_serialize_all_but_one_test,
 124    nir_serialize_all_but_one_test,
 125    ::testing::Values(COMPONENTS)
 126 );
 127
 128 TEST_P(nir_serialize_all_test, alu_single_value_src_swizzle)
 129 {
 130    nir_ssa_def *zero = nir_imm_zero(b, GetParam(), 32);
 131    nir_ssa_def *fmax = nir_fmax(b, zero, zero);
 132
 133    nir_alu_instr *fmax_alu = nir_instr_as_alu(fmax->parent_instr);
 134
 135    memset(fmax_alu->src[0].swizzle, GetParam() - 1, NIR_MAX_VEC_COMPONENTS);
 136    memset(fmax_alu->src[1].swizzle, GetParam() - 1, NIR_MAX_VEC_COMPONENTS);
 137
 138    serialize();
 139
 140    nir_alu_instr *fmax_alu_dup = get_last_alu(dup);
 141
 142    ASSERT_SWIZZLE_EQ(fmax_alu, fmax_alu_dup, GetParam(), 0);
 143    ASSERT_SWIZZLE_EQ(fmax_alu, fmax_alu_dup, GetParam(), 1);
 144 }
 145
 146 TEST_P(nir_serialize_all_test, alu_vec)
 147 {
 148    nir_ssa_def *undef = nir_ssa_undef(b, GetParam(), 32);
 149    nir_ssa_def *undefs[] = {
 150       undef, undef, undef, undef,
 151       undef, undef, undef, undef,
 152       undef, undef, undef, undef,
 153       undef, undef, undef, undef,
 154    };
 155
 156    nir_ssa_def *vec = nir_vec(b, undefs, GetParam());
 157    nir_alu_instr *vec_alu = nir_instr_as_alu(vec->parent_instr);
 158    for (int i = 0; i < GetParam(); i++)
 159       vec_alu->src[i].swizzle[0] = (GetParam() - 1) - i;
 160
 161    serialize();
 162
 163    nir_alu_instr *vec_alu_dup = get_last_alu(dup);
 164
 165    ASSERT_SWIZZLE_EQ(vec_alu, vec_alu_dup, 1, 0);
 166 }
 167
 168 TEST_P(nir_serialize_all_test, alu_two_components_full_swizzle)
 169 {
 170    nir_ssa_def *undef = nir_ssa_undef(b, 2, 32);
 171    nir_ssa_def *fma = nir_ffma(b, undef, undef, undef);
 172    nir_alu_instr *fma_alu = nir_instr_as_alu(fma->parent_instr);
 173
 174    fma->num_components = GetParam();
 175    fma_alu->dest.write_mask = (1 << GetParam()) - 1;
 176
 177    memset(fma_alu->src[0].swizzle, 1, GetParam());
 178    memset(fma_alu->src[1].swizzle, 1, GetParam());
 179    memset(fma_alu->src[2].swizzle, 1, GetParam());
 180
 181    serialize();
 182
 183    nir_alu_instr *fma_alu_dup = get_last_alu(dup);
 184
 185    ASSERT_SWIZZLE_EQ(fma_alu, fma_alu_dup, GetParam(), 0);
 186    ASSERT_SWIZZLE_EQ(fma_alu, fma_alu_dup, GetParam(), 1);
 187    ASSERT_SWIZZLE_EQ(fma_alu, fma_alu_dup, GetParam(), 2);
 188 }
 189
 190 TEST_P(nir_serialize_all_but_one_test, alu_two_components_reg_two_swizzle)
 191 {
 192    nir_ssa_def *undef = nir_ssa_undef(b, 2, 32);
 193    nir_ssa_def *fma = nir_ffma(b, undef, undef, undef);
 194    nir_alu_instr *fma_alu = nir_instr_as_alu(fma->parent_instr);
 195
 196    memset(fma_alu->src[0].swizzle, 1, GetParam());
 197    memset(fma_alu->src[1].swizzle, 1, GetParam());
 198    memset(fma_alu->src[2].swizzle, 1, GetParam());
 199
 200    ASSERT_TRUE(nir_convert_from_ssa(b->shader, false));
 201
 202    fma_alu = get_last_alu(b->shader);
 203    ASSERT_FALSE(fma_alu->dest.dest.is_ssa);
 204    fma_alu->dest.dest.reg.reg->num_components = GetParam();
 205    fma_alu->dest.write_mask = 1 | (1 << (GetParam() - 1));
 206
 207    serialize();
 208
 209    nir_alu_instr *fma_alu_dup = get_last_alu(dup);
 210
 211    ASSERT_EQ(fma_alu->src[0].swizzle[0], fma_alu_dup->src[0].swizzle[0]);
 212    ASSERT_EQ(fma_alu->src[0].swizzle[GetParam() - 1], fma_alu_dup->src[0].swizzle[GetParam() - 1]);
 213    ASSERT_EQ(fma_alu->src[1].swizzle[0], fma_alu_dup->src[1].swizzle[0]);
 214    ASSERT_EQ(fma_alu->src[1].swizzle[GetParam() - 1], fma_alu_dup->src[1].swizzle[GetParam() - 1]);
 215    ASSERT_EQ(fma_alu->src[2].swizzle[0], fma_alu_dup->src[2].swizzle[0]);
 216    ASSERT_EQ(fma_alu->src[2].swizzle[GetParam() - 1], fma_alu_dup->src[2].swizzle[GetParam() - 1]);
 217 }
 218
 219 TEST_P(nir_serialize_all_but_one_test, alu_full_width_reg_two_swizzle)
 220 {
 221    nir_ssa_def *undef = nir_ssa_undef(b, GetParam(), 32);
 222    nir_ssa_def *fma = nir_ffma(b, undef, undef, undef);
 223    nir_alu_instr *fma_alu = nir_instr_as_alu(fma->parent_instr);
 224
 225    memset(fma_alu->src[0].swizzle, GetParam() - 1, GetParam());
 226    memset(fma_alu->src[1].swizzle, GetParam() - 1, GetParam());
 227    memset(fma_alu->src[2].swizzle, GetParam() - 1, GetParam());
 228
 229    ASSERT_TRUE(nir_convert_from_ssa(b->shader, false));
 230
 231    fma_alu = get_last_alu(b->shader);
 232    ASSERT_FALSE(fma_alu->dest.dest.is_ssa);
 233    fma_alu->dest.write_mask = 1 | (1 << (GetParam() - 1));
 234
 235    serialize();
 236
 237    nir_alu_instr *fma_alu_dup = get_last_alu(dup);
 238
 239    ASSERT_EQ(fma_alu->src[0].swizzle[0], fma_alu_dup->src[0].swizzle[0]);
 240    ASSERT_EQ(fma_alu->src[0].swizzle[GetParam() - 1], fma_alu_dup->src[0].swizzle[GetParam() - 1]);
 241    ASSERT_EQ(fma_alu->src[1].swizzle[0], fma_alu_dup->src[1].swizzle[0]);
 242    ASSERT_EQ(fma_alu->src[1].swizzle[GetParam() - 1], fma_alu_dup->src[1].swizzle[GetParam() - 1]);
 243    ASSERT_EQ(fma_alu->src[2].swizzle[0], fma_alu_dup->src[2].swizzle[0]);
 244    ASSERT_EQ(fma_alu->src[2].swizzle[GetParam() - 1], fma_alu_dup->src[2].swizzle[GetParam() - 1]);
 245 }
 246
 247 TEST_P(nir_serialize_all_but_one_test, alu_two_component_reg_full_src)
 248 {
 249    nir_ssa_def *undef = nir_ssa_undef(b, GetParam(), 32);
 250    nir_ssa_def *fma = nir_ffma(b, undef, undef, undef);
 251    nir_alu_instr *fma_alu = nir_instr_as_alu(fma->parent_instr);
 252
 253    memset(fma_alu->src[0].swizzle, 1, GetParam());
 254    memset(fma_alu->src[1].swizzle, 1, GetParam());
 255    memset(fma_alu->src[2].swizzle, 1, GetParam());
 256
 257    ASSERT_TRUE(nir_convert_from_ssa(b->shader, false));
 258
 259    fma_alu = get_last_alu(b->shader);
 260    ASSERT_FALSE(fma_alu->dest.dest.is_ssa);
 261    fma_alu->dest.dest.reg.reg->num_components = 2;
 262    fma_alu->dest.write_mask = 0x3;
 263
 264    serialize();
 265
 266    nir_alu_instr *fma_alu_dup = get_last_alu(dup);
 267
 268    ASSERT_SWIZZLE_EQ(fma_alu, fma_alu_dup, 2, 0);
 269    ASSERT_SWIZZLE_EQ(fma_alu, fma_alu_dup, 2, 1);
 270    ASSERT_SWIZZLE_EQ(fma_alu, fma_alu_dup, 2, 2);
 271 }
 272
 273 TEST_P(nir_serialize_all_but_one_test, single_channel)
 274 {
 275    nir_ssa_def *zero = nir_ssa_undef(b, GetParam(), 32);
 276    nir_ssa_def *vec = nir_channel(b, zero, GetParam() - 1);
 277    nir_alu_instr *vec_alu = nir_instr_as_alu(vec->parent_instr);
 278
 279    serialize();
 280
 281    nir_alu_instr *vec_alu_dup = get_last_alu(dup);
 282
 283    ASSERT_SWIZZLE_EQ(vec_alu, vec_alu_dup, 1, 0);
 284 }