| #ifndef _GLSLONGSTRESSCASE_HPP |
| #define _GLSLONGSTRESSCASE_HPP |
| /*------------------------------------------------------------------------- |
| * drawElements Quality Program OpenGL (ES) Module |
| * ----------------------------------------------- |
| * |
| * Copyright 2014 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| *//*! |
| * \file |
| * \brief Parametrized, long-running stress case. |
| *//*--------------------------------------------------------------------*/ |
| |
| #include "tcuDefs.hpp" |
| #include "tcuTestCase.hpp" |
| #include "tcuTexture.hpp" |
| #include "tcuMatrix.hpp" |
| #include "gluRenderContext.hpp" |
| #include "gluShaderUtil.hpp" |
| #include "glsTextureTestUtil.hpp" |
| #include "deRandom.hpp" |
| #include "deSharedPtr.hpp" |
| |
| #include <string> |
| #include <vector> |
| #include <map> |
| |
| namespace deqp |
| { |
| namespace gls |
| { |
| |
| namespace LongStressCaseInternal |
| { |
| |
| template <typename T> |
| class GLObjectManager; |
| class Program; |
| class Buffer; |
| class Texture; |
| class DebugInfoRenderer; |
| |
| } // namespace LongStressCaseInternal |
| |
| struct VarSpec |
| { |
| union Value |
| { |
| float f[4 * 4]; // \note Matrices are stored in column major order. |
| int i[4]; |
| }; |
| |
| std::string name; |
| glu::DataType type; |
| Value minValue; |
| Value maxValue; |
| |
| template <typename T> |
| VarSpec(const std::string &name_, const T &minValue_, const T &maxValue_) : name(name_) |
| { |
| set(minValue_, maxValue_); |
| } |
| |
| template <typename T> |
| VarSpec(const std::string &name_, const T &value) : name(name_) |
| { |
| set(value, value); |
| } |
| |
| void set(float minValue_, float maxValue_) |
| { |
| type = glu::TYPE_FLOAT; |
| minValue.f[0] = minValue_; |
| maxValue.f[0] = maxValue_; |
| } |
| |
| template <int ValSize> |
| void set(const tcu::Vector<float, ValSize> &minValue_, const tcu::Vector<float, ValSize> &maxValue_) |
| { |
| type = glu::getDataTypeFloatVec(ValSize); |
| vecToArr(minValue_, minValue.f); |
| vecToArr(maxValue_, maxValue.f); |
| } |
| |
| template <int ValRows, int ValCols> |
| void set(const tcu::Matrix<float, ValRows, ValCols> &minValue_, |
| const tcu::Matrix<float, ValRows, ValCols> &maxValue_) |
| { |
| type = glu::getDataTypeMatrix(ValCols, ValRows); |
| matToArr(minValue_, minValue.f); |
| matToArr(maxValue_, maxValue.f); |
| } |
| |
| void set(int minValue_, int maxValue_) |
| { |
| type = glu::TYPE_INT; |
| minValue.i[0] = minValue_; |
| maxValue.i[0] = maxValue_; |
| } |
| |
| template <int ValSize> |
| void set(const tcu::Vector<int, ValSize> &minValue_, const tcu::Vector<int, ValSize> &maxValue_) |
| { |
| type = glu::getDataTypeVector(glu::TYPE_INT, ValSize); |
| vecToArr(minValue_, minValue.i); |
| vecToArr(maxValue_, maxValue.i); |
| } |
| |
| private: |
| template <typename T, int SrcSize, int DstSize> |
| static inline void vecToArr(const tcu::Vector<T, SrcSize> &src, T (&dst)[DstSize]) |
| { |
| DE_STATIC_ASSERT(DstSize >= SrcSize); |
| for (int i = 0; i < SrcSize; i++) |
| dst[i] = src[i]; |
| } |
| |
| template <int ValRows, int ValCols, int DstSize> |
| static inline void matToArr(const tcu::Matrix<float, ValRows, ValCols> &src, float (&dst)[DstSize]) |
| { |
| DE_STATIC_ASSERT(DstSize >= ValRows * ValCols); |
| tcu::Array<float, ValRows *ValCols> data = src.getColumnMajorData(); |
| for (int i = 0; i < ValRows * ValCols; i++) |
| dst[i] = data[i]; |
| } |
| }; |
| |
| struct TextureSpec |
| { |
| glu::TextureTestUtil::TextureType textureType; |
| uint32_t textureUnit; |
| int width; |
| int height; |
| uint32_t format; |
| uint32_t dataType; |
| uint32_t internalFormat; |
| bool useMipmap; |
| uint32_t minFilter; |
| uint32_t magFilter; |
| uint32_t sWrap; |
| uint32_t tWrap; |
| tcu::Vec4 minValue; |
| tcu::Vec4 maxValue; |
| |
| TextureSpec(const glu::TextureTestUtil::TextureType texType, const uint32_t unit, const int width_, |
| const int height_, const uint32_t format_, const uint32_t dataType_, const uint32_t internalFormat_, |
| const bool useMipmap_, const uint32_t minFilter_, const uint32_t magFilter_, const uint32_t sWrap_, |
| const uint32_t tWrap_, const tcu::Vec4 &minValue_, const tcu::Vec4 &maxValue_) |
| : textureType(texType) |
| , textureUnit(unit) |
| , width(width_) |
| , height(height_) |
| , format(format_) |
| , dataType(dataType_) |
| , internalFormat(internalFormat_) |
| , useMipmap(useMipmap_) |
| , minFilter(minFilter_) |
| , magFilter(magFilter_) |
| , sWrap(sWrap_) |
| , tWrap(tWrap_) |
| , minValue(minValue_) |
| , maxValue(maxValue_) |
| { |
| } |
| }; |
| |
| /*--------------------------------------------------------------------*//*! |
| * \brief Struct for a shader program sources and related data |
| * |
| * A ProgramContext holds a program's vertex and fragment shader sources |
| * as well as specifications of its attributes, uniforms, and textures. |
| * When given to a StressCase, the string ${NS} is replaced by a magic |
| * number that varies between different compilations of the same program; |
| * the same replacement is done in attributes' and uniforms' names. This |
| * can be used to avoid shader caching by the GL, by e.g. suffixing each |
| * attribute, uniform and varying name with ${NS} in the shader source. |
| *//*--------------------------------------------------------------------*/ |
| struct ProgramContext |
| { |
| std::string vertexSource; |
| std::string fragmentSource; |
| std::vector<VarSpec> attributes; |
| std::vector<VarSpec> uniforms; |
| |
| std::vector<TextureSpec> |
| textureSpecs; //!< \note If multiple textures have same unit, one of them is picked randomly. |
| |
| std::string |
| positionAttrName; //!< \note Position attribute may get a bit more careful handling than just complete random. |
| |
| ProgramContext(const char *const vtxShaderSource_, const char *const fragShaderSource_, |
| const char *const positionAttrName_) |
| : vertexSource(vtxShaderSource_) |
| , fragmentSource(fragShaderSource_) |
| , positionAttrName(positionAttrName_) |
| { |
| } |
| }; |
| |
| class LongStressCase : public tcu::TestCase |
| { |
| public: |
| //! Probabilities for actions that may be taken on each iteration. \note The texture and buffer specific actions are randomized per texture or buffer. |
| struct FeatureProbabilities |
| { |
| float rebuildProgram; //!< Rebuild program, with variable name-mangling. |
| float reuploadTexture; //!< Reupload texture, even if it already exists and has been uploaded. |
| float reuploadBuffer; //!< Reupload buffer, even if it already exists and has been uploaded. |
| float reuploadWithTexImage; //!< Use glTexImage*() when re-uploading texture, not glTexSubImage*(). |
| float reuploadWithBufferData; //!< Use glBufferData() when re-uploading buffer, not glBufferSubData(). |
| float deleteTexture; //!< Delete texture at end of iteration, even if we could re-use it. |
| float deleteBuffer; //!< Delete buffer at end of iteration, even if we could re-use it. |
| float |
| wastefulTextureMemoryUsage; //!< Don't re-use a texture, and don't delete it until given memory limit is hit. |
| float |
| wastefulBufferMemoryUsage; //!< Don't re-use a buffer, and don't delete it until given memory limit is hit. |
| float |
| clientMemoryAttributeData; //!< Use client memory for vertex attribute data when drawing (instead of GL buffers). |
| float clientMemoryIndexData; //!< Use client memory for vertex indices when drawing (instead of GL buffers). |
| float |
| randomBufferUploadTarget; //!< Use a random target when setting buffer data (i.e. not necessarily the one it'll be ultimately bound to). |
| float |
| randomBufferUsage; //!< Use a random buffer usage parameter with glBufferData(), instead of the ones specified as params for the case. |
| float useDrawArrays; //!< Use glDrawArrays() instead of glDrawElements(). |
| float separateAttributeBuffers; //!< Give each vertex attribute its own buffer. |
| |
| // Named parameter idiom: helpers that can be used when making temporaries, e.g. FeatureProbabilities().pReuploadTexture(1.0f).pReuploadWithTexImage(1.0f) |
| FeatureProbabilities &pRebuildProgram(const float prob) |
| { |
| rebuildProgram = prob; |
| return *this; |
| } |
| FeatureProbabilities &pReuploadTexture(const float prob) |
| { |
| reuploadTexture = prob; |
| return *this; |
| } |
| FeatureProbabilities &pReuploadBuffer(const float prob) |
| { |
| reuploadBuffer = prob; |
| return *this; |
| } |
| FeatureProbabilities &pReuploadWithTexImage(const float prob) |
| { |
| reuploadWithTexImage = prob; |
| return *this; |
| } |
| FeatureProbabilities &pReuploadWithBufferData(const float prob) |
| { |
| reuploadWithBufferData = prob; |
| return *this; |
| } |
| FeatureProbabilities &pDeleteTexture(const float prob) |
| { |
| deleteTexture = prob; |
| return *this; |
| } |
| FeatureProbabilities &pDeleteBuffer(const float prob) |
| { |
| deleteBuffer = prob; |
| return *this; |
| } |
| FeatureProbabilities &pWastefulTextureMemoryUsage(const float prob) |
| { |
| wastefulTextureMemoryUsage = prob; |
| return *this; |
| } |
| FeatureProbabilities &pWastefulBufferMemoryUsage(const float prob) |
| { |
| wastefulBufferMemoryUsage = prob; |
| return *this; |
| } |
| FeatureProbabilities &pClientMemoryAttributeData(const float prob) |
| { |
| clientMemoryAttributeData = prob; |
| return *this; |
| } |
| FeatureProbabilities &pClientMemoryIndexData(const float prob) |
| { |
| clientMemoryIndexData = prob; |
| return *this; |
| } |
| FeatureProbabilities &pRandomBufferUploadTarget(const float prob) |
| { |
| randomBufferUploadTarget = prob; |
| return *this; |
| } |
| FeatureProbabilities &pRandomBufferUsage(const float prob) |
| { |
| randomBufferUsage = prob; |
| return *this; |
| } |
| FeatureProbabilities &pUseDrawArrays(const float prob) |
| { |
| useDrawArrays = prob; |
| return *this; |
| } |
| FeatureProbabilities &pSeparateAttribBuffers(const float prob) |
| { |
| separateAttributeBuffers = prob; |
| return *this; |
| } |
| |
| FeatureProbabilities(void) |
| : rebuildProgram(0.0f) |
| , reuploadTexture(0.0f) |
| , reuploadBuffer(0.0f) |
| , reuploadWithTexImage(0.0f) |
| , reuploadWithBufferData(0.0f) |
| , deleteTexture(0.0f) |
| , deleteBuffer(0.0f) |
| , wastefulTextureMemoryUsage(0.0f) |
| , wastefulBufferMemoryUsage(0.0f) |
| , clientMemoryAttributeData(0.0f) |
| , clientMemoryIndexData(0.0f) |
| , randomBufferUploadTarget(0.0f) |
| , randomBufferUsage(0.0f) |
| , useDrawArrays(0.0f) |
| , separateAttributeBuffers(0.0f) |
| { |
| } |
| }; |
| |
| LongStressCase(tcu::TestContext &testCtx, const glu::RenderContext &renderCtx, const char *name, const char *desc, |
| int maxTexMemoryUsageBytes, //!< Approximate upper bound on GL texture memory usage. |
| int maxBufMemoryUsageBytes, //!< Approximate upper bound on GL buffer memory usage. |
| int numDrawCallsPerIteration, int numTrianglesPerDrawCall, |
| const std::vector<ProgramContext> &programContexts, const FeatureProbabilities &probabilities, |
| uint32_t indexBufferUsage, uint32_t attrBufferUsage, int redundantBufferFactor = 1, |
| bool showDebugInfo = false); |
| |
| ~LongStressCase(void); |
| |
| void init(void); |
| void deinit(void); |
| |
| IterateResult iterate(void); |
| |
| private: |
| LongStressCase(const LongStressCase &); |
| LongStressCase &operator=(const LongStressCase &); |
| |
| const glu::RenderContext &m_renderCtx; |
| const int m_maxTexMemoryUsageBytes; |
| const int m_maxBufMemoryUsageBytes; |
| const int m_numDrawCallsPerIteration; |
| const int m_numTrianglesPerDrawCall; |
| const int m_numVerticesPerDrawCall; |
| const std::vector<ProgramContext> m_programContexts; |
| const FeatureProbabilities m_probabilities; |
| const uint32_t m_indexBufferUsage; |
| const uint32_t m_attrBufferUsage; |
| const int |
| m_redundantBufferFactor; //!< By what factor we allocate redundant buffers. Default is 1, i.e. no redundancy. |
| const bool m_showDebugInfo; |
| |
| const int m_numIterations; |
| const bool m_isGLES3; |
| |
| int m_currentIteration; |
| uint64_t m_startTimeSeconds; //!< Set at beginning of first iteration. |
| uint64_t m_lastLogTime; |
| int m_lastLogIteration; |
| int m_currentLogEntryNdx; |
| |
| de::Random m_rnd; |
| LongStressCaseInternal::GLObjectManager<LongStressCaseInternal::Program> *m_programs; |
| LongStressCaseInternal::GLObjectManager<LongStressCaseInternal::Buffer> *m_buffers; |
| LongStressCaseInternal::GLObjectManager<LongStressCaseInternal::Texture> *m_textures; |
| std::vector<uint16_t> m_vertexIndices; |
| |
| struct ProgramResources |
| { |
| std::vector<uint8_t> attrDataBuf; |
| std::vector<int> attrDataOffsets; |
| std::vector<int> attrDataSizes; |
| std::vector<de::SharedPtr<tcu::TextureLevel>> unusedTextures; |
| std::string shaderNameManglingSuffix; |
| }; |
| |
| std::vector<ProgramResources> m_programResources; |
| |
| LongStressCaseInternal::DebugInfoRenderer *m_debugInfoRenderer; |
| }; |
| |
| } // namespace gls |
| } // namespace deqp |
| |
| #endif // _GLSLONGSTRESSCASE_HPP |
