kc3-lang/angle/src/tests/compiler_tests/ConstantFolding_test.cpp

• Show log

  Commit

• Hash : 2decb4b1
  Author :
  Date : 2015-05-25T19:20:26
  

  Add constant folding support for geometric built-ins
  
  This change adds constant folding support for following geometric
  built-ins:
      - length, distance, dot, cross, normalize, faceforward,
        reflect and refract.
  
  BUG=angleproject:913
  TEST=angle_unittests, dEQP Tests
  dEQP-GLES3.functional.shaders.constant_expressions.builtin_functions.geometric.*
  (56 tests started passing with this change)
  
  Change-Id: I973689554bb8c30ee3ebdf71f1b8a051ceb5e0cf
  Reviewed-on: https://chromium-review.googlesource.com/273097
  Reviewed-by: Zhenyao Mo <zmo@chromium.org>
  Tested-by: Olli Etuaho <oetuaho@nvidia.com>
  

Download

• src/tests/compiler_tests/ConstantFolding_test.cpp

• //
  // Copyright (c) 2015 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  // ConstantFolding_test.cpp:
  //   Tests for constant folding
  //
  
  #include "angle_gl.h"
  #include "gtest/gtest.h"
  #include "GLSLANG/ShaderLang.h"
  #include "compiler/translator/PoolAlloc.h"
  #include "compiler/translator/TranslatorESSL.h"
  
  #include <vector>
  
  template <typename T>
  class ConstantFinder : public TIntermTraverser
  {
    public:
      ConstantFinder(const std::vector<T> &constantVector)
          : mConstantVector(constantVector),
            mFound(false)
      {}
  
      ConstantFinder(const T &value)
          : mConstantVector(std::vector<T>{value}),
            mFound(false)
      {}
  
      virtual void visitConstantUnion(TIntermConstantUnion *node)
      {
          if (node->getType().getObjectSize() == mConstantVector.size())
          {
              bool found = true;
              for (size_t i = 0; i < mConstantVector.size(); i++)
              {
                  if (node->getUnionArrayPointer()[i] != mConstantVector[i])
                  {
                      found = false;
                      break;
                  }
              }
              if (found)
              {
                  mFound = found;
              }
          }
      }
  
      bool found() const { return mFound; }
  
    private:
      std::vector<T> mConstantVector;
      bool mFound;
  };
  
  class ConstantFoldingTest : public testing::Test
  {
    public:
      ConstantFoldingTest() {}
  
    protected:
      virtual void SetUp()
      {
          allocator.push();
          SetGlobalPoolAllocator(&allocator);
          ShBuiltInResources resources;
          ShInitBuiltInResources(&resources);
  
          mTranslatorESSL = new TranslatorESSL(GL_FRAGMENT_SHADER, SH_GLES3_SPEC);
          ASSERT_TRUE(mTranslatorESSL->Init(resources));
      }
  
      virtual void TearDown()
      {
          delete mTranslatorESSL;
          SetGlobalPoolAllocator(NULL);
          allocator.pop();
      }
  
      void compile(const std::string& shaderString)
      {
          const char *shaderStrings[] = { shaderString.c_str() };
  
          mASTRoot = mTranslatorESSL->compileTreeForTesting(shaderStrings, 1, SH_OBJECT_CODE);
          if (!mASTRoot)
          {
              TInfoSink &infoSink = mTranslatorESSL->getInfoSink();
              FAIL() << "Shader compilation into ESSL failed " << infoSink.info.c_str();
          }
      }
  
      template <typename T>
      bool constantFoundInAST(T constant)
      {
          ConstantFinder<T> finder(constant);
          mASTRoot->traverse(&finder);
          return finder.found();
      }
  
      template <typename T>
      bool constantVectorFoundInAST(const std::vector<T> &constantVector)
      {
          ConstantFinder<T> finder(constantVector);
          mASTRoot->traverse(&finder);
          return finder.found();
      }
  
    private:
      TranslatorESSL *mTranslatorESSL;
      TIntermNode *mASTRoot;
  
      TPoolAllocator allocator;
  };
  
  TEST_F(ConstantFoldingTest, FoldIntegerAdd)
  {
      const std::string &shaderString =
          "#version 300 es\n"
          "precision mediump float;\n"
          "out int my_Int;\n"
          "void main() {\n"
          "   const int i = 1124 + 5;\n"
          "   my_Int = i;\n"
          "}\n";
      compile(shaderString);
      ASSERT_FALSE(constantFoundInAST(1124));
      ASSERT_FALSE(constantFoundInAST(5));
      ASSERT_TRUE(constantFoundInAST(1129));
  }
  
  TEST_F(ConstantFoldingTest, FoldIntegerSub)
  {
      const std::string &shaderString =
          "#version 300 es\n"
          "precision mediump float;\n"
          "out int my_Int;\n"
          "void main() {\n"
          "   const int i = 1124 - 5;\n"
          "   my_Int = i;\n"
          "}\n";
      compile(shaderString);
      ASSERT_FALSE(constantFoundInAST(1124));
      ASSERT_FALSE(constantFoundInAST(5));
      ASSERT_TRUE(constantFoundInAST(1119));
  }
  
  TEST_F(ConstantFoldingTest, FoldIntegerMul)
  {
      const std::string &shaderString =
          "#version 300 es\n"
          "precision mediump float;\n"
          "out int my_Int;\n"
          "void main() {\n"
          "   const int i = 1124 * 5;\n"
          "   my_Int = i;\n"
          "}\n";
      compile(shaderString);
      ASSERT_FALSE(constantFoundInAST(1124));
      ASSERT_FALSE(constantFoundInAST(5));
      ASSERT_TRUE(constantFoundInAST(5620));
  }
  
  TEST_F(ConstantFoldingTest, FoldIntegerDiv)
  {
      const std::string &shaderString =
          "#version 300 es\n"
          "precision mediump float;\n"
          "out int my_Int;\n"
          "void main() {\n"
          "   const int i = 1124 / 5;\n"
          "   my_Int = i;\n"
          "}\n";
      compile(shaderString);
      ASSERT_FALSE(constantFoundInAST(1124));
      ASSERT_FALSE(constantFoundInAST(5));
      // Rounding mode of division is undefined in the spec but ANGLE can be expected to round down.
      ASSERT_TRUE(constantFoundInAST(224));
  }
  
  TEST_F(ConstantFoldingTest, FoldIntegerModulus)
  {
      const std::string &shaderString =
          "#version 300 es\n"
          "precision mediump float;\n"
          "out int my_Int;\n"
          "void main() {\n"
          "   const int i = 1124 % 5;\n"
          "   my_Int = i;\n"
          "}\n";
      compile(shaderString);
      ASSERT_FALSE(constantFoundInAST(1124));
      ASSERT_FALSE(constantFoundInAST(5));
      ASSERT_TRUE(constantFoundInAST(4));
  }
  
  TEST_F(ConstantFoldingTest, FoldVectorCrossProduct)
  {
      const std::string &shaderString =
          "#version 300 es\n"
          "precision mediump float;\n"
          "out vec3 my_Vec3;"
          "void main() {\n"
          "   const vec3 v3 = cross(vec3(1.0f, 1.0f, 1.0f), vec3(1.0f, -1.0f, 1.0f));\n"
          "   my_Vec3 = v3;\n"
          "}\n";
      compile(shaderString);
      ASSERT_FALSE(constantVectorFoundInAST(std::vector<float>{1.0f, 1.0f, 1.0f}));
      ASSERT_FALSE(constantVectorFoundInAST(std::vector<float>{1.0f, -1.0f, 1.0f}));
      ASSERT_TRUE(constantVectorFoundInAST(std::vector<float>{2.0f, 0.0f, -2.0f}));
  }
  

Download