framework/common/tcuPlatform.hpp

   1 #ifndef _TCUPLATFORM_HPP
   2 #define _TCUPLATFORM_HPP
   3 /*-------------------------------------------------------------------------
   4  * drawElements Quality Program Tester Core
   5  * ----------------------------------------
   6  *
   7  * Copyright 2014 The Android Open Source Project
   8  *
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  *      http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  *//*!
  22  * \file
  23  * \brief Platform (OS) specific services.
  24  *//*--------------------------------------------------------------------*/
  25
  26 #include "tcuDefs.hpp"
  27
  28 namespace glu
  29 {
  30 class Platform;
  31 }
  32
  33 namespace eglu
  34 {
  35 class Platform;
  36 }
  37
  38 namespace vk
  39 {
  40 class Platform;
  41 }
  42
  43 namespace tcu
  44 {
  45
  46 class CommandLine;
  47 class FunctionLibrary;
  48
  49 struct PlatformMemoryLimits
  50 {
  51         // System memory properties
  52         size_t                  totalSystemMemory;                                      // #bytes of system memory (heap + HOST_LOCAL) tests must not exceed
  53
  54         // Device memory properties
  55         std::uint64_t   totalDeviceLocalMemory;                         // #bytes of total DEVICE_LOCAL memory tests must not exceed or 0 if DEVICE_LOCAL counts against system memory
  56         std::uint64_t   deviceMemoryAllocationGranularity;      // VkDeviceMemory allocation granularity (typically page size)
  57
  58         // Device memory page table geometry
  59         std::uint64_t   devicePageSize;                                         // Page size on device (must be rounded up to the nearest POT)
  60         std::uint64_t   devicePageTableEntrySize;                       // Number of bytes per page table size
  61         size_t                  devicePageTableHierarchyLevels;         // Number of levels in device page table hierarchy
  62
  63         PlatformMemoryLimits (void)
  64                 : totalSystemMemory                                     (0)
  65                 , totalDeviceLocalMemory                        (0)
  66                 , deviceMemoryAllocationGranularity     (0)
  67                 , devicePageSize                                        (0)
  68                 , devicePageTableEntrySize                      (0)
  69                 , devicePageTableHierarchyLevels        (0)
  70         {}
  71 };
  72
  73 /*--------------------------------------------------------------------*//*!
  74  * \brief Base class for platform implementation.
  75  *
  76  * This class represents the minimum set of functionality for a platform
  77  * port.
  78  *
  79  * In addition to implementing Platform class, main entry point must be
  80  * created that takes care of parsing command line, creating log and
  81  * executing tcu::App. See tcuMain.cpp for reference on implementing
  82  * application stub.
  83  *
  84  * If the platform uses standard posix-style main() for application entry
  85  * point, tcuMain.cpp can be used as is. In that case you only have to
  86  * implement createPlatform().
  87  *
  88  * API-specific platform interfaces (glu::Platform, eglu::Platform and vk::Platform)
  89  * can be provided by implementing get<API>Platform() functions.
  90  *//*--------------------------------------------------------------------*/
  91 class Platform
  92 {
  93 public:
  94                                                                         Platform                        (void);
  95         virtual                                                 ~Platform                       (void);
  96
  97         /*--------------------------------------------------------------------*//*!
  98          * \brief Process platform-specific events.
  99          *
 100          * Test framework will call this function between test cases and test case
 101          * iterations. Any event handling that must be done periodically should be
 102          * done here.
 103          *
 104          * Test framework will decide whether to continue test execution based on
 105          * return code. For instance if the application receives close event from OS,
 106          * it should communicate that to framework by returning false.
 107          *
 108          * \note Do not do rendering buffer swaps here.
 109          *       Do it in RenderContext::postIterate() instead.
 110          * \return true if test execution should continue, false otherwise.
 111          *//*--------------------------------------------------------------------*/
 112         virtual bool                                    processEvents           (void);
 113
 114         /*--------------------------------------------------------------------*//*!
 115          * \brief Get GL platform interface
 116          *
 117          * GL-specific platform interface is defined by glu::Platform. If your
 118          * platform port supports OpenGL (ES), you should implement this function.
 119          *
 120          * Default implementation throws tcu::NotSupportedError exception.
 121          *
 122          * \return Reference to GL platform interface.
 123          *//*--------------------------------------------------------------------*/
 124         virtual const glu::Platform&    getGLPlatform           (void) const;
 125
 126         /*--------------------------------------------------------------------*//*!
 127          * \brief Get EGL platform interface
 128          *
 129          * EGL-specific platform interface is defined by eglu::Platform. If your
 130          * platform port supports EGL, you should implement this function.
 131          *
 132          * Default implementation throws tcu::NotSupportedError exception.
 133          *
 134          * \return Reference to EGL platform interface.
 135          *//*--------------------------------------------------------------------*/
 136         virtual const eglu::Platform&   getEGLPlatform          (void) const;
 137
 138         virtual const vk::Platform&             getVulkanPlatform       (void) const;
 139
 140         virtual void                                    getMemoryLimits         (PlatformMemoryLimits& limits) const;
 141 };
 142
 143 inline tcu::PlatformMemoryLimits getMemoryLimits (const tcu::Platform& platform)
 144 {
 145         tcu::PlatformMemoryLimits limits;
 146         platform.getMemoryLimits(limits);
 147         return limits;
 148 }
 149
 150 } // tcu
 151
 152 #endif // _TCUPLATFORM_HPP