external/vulkancts/modules/vulkan/vktInfoTests.cpp

   1 /*-------------------------------------------------------------------------
   2  * Vulkan Conformance Tests
   3  * ------------------------
   4  *
   5  * Copyright (c) 2016 Google Inc.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  *//*!
  20  * \file
  21  * \brief Build and Device Tests
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "vktInfoTests.hpp"
  25 #include "vktTestCaseUtil.hpp"
  26 #include "vkPlatform.hpp"
  27 #include "vkApiVersion.hpp"
  28 #include "tcuTestLog.hpp"
  29 #include "tcuFormatUtil.hpp"
  30 #include "tcuCommandLine.hpp"
  31 #include "tcuPlatform.hpp"
  32 #include "deDefs.h"
  33 #include "deStringUtil.hpp"
  34 #include "vktApiFeatureInfo.hpp"
  35
  36 #include <iomanip>
  37
  38 namespace vkt
  39 {
  40
  41 namespace
  42 {
  43
  44 using tcu::TestLog;
  45 using std::string;
  46
  47 std::string getOsName (int os)
  48 {
  49         switch (os)
  50         {
  51                 case DE_OS_VANILLA:             return "DE_OS_VANILLA";
  52                 case DE_OS_WIN32:               return "DE_OS_WIN32";
  53                 case DE_OS_UNIX:                return "DE_OS_UNIX";
  54                 case DE_OS_WINCE:               return "DE_OS_WINCE";
  55                 case DE_OS_OSX:                 return "DE_OS_OSX";
  56                 case DE_OS_ANDROID:             return "DE_OS_ANDROID";
  57                 case DE_OS_SYMBIAN:             return "DE_OS_SYMBIAN";
  58                 case DE_OS_IOS:                 return "DE_OS_IOS";
  59                 default:
  60                         return de::toString(os);
  61         }
  62 }
  63
  64 std::string getCompilerName (int compiler)
  65 {
  66         switch (compiler)
  67         {
  68                 case DE_COMPILER_VANILLA:       return "DE_COMPILER_VANILLA";
  69                 case DE_COMPILER_MSC:           return "DE_COMPILER_MSC";
  70                 case DE_COMPILER_GCC:           return "DE_COMPILER_GCC";
  71                 case DE_COMPILER_CLANG:         return "DE_COMPILER_CLANG";
  72                 default:
  73                         return de::toString(compiler);
  74         }
  75 }
  76
  77 std::string getCpuName (int cpu)
  78 {
  79         switch (cpu)
  80         {
  81                 case DE_CPU_VANILLA:    return "DE_CPU_VANILLA";
  82                 case DE_CPU_ARM:                return "DE_CPU_ARM";
  83                 case DE_CPU_X86:                return "DE_CPU_X86";
  84                 case DE_CPU_X86_64:             return "DE_CPU_X86_64";
  85                 case DE_CPU_ARM_64:             return "DE_CPU_ARM_64";
  86                 case DE_CPU_MIPS:               return "DE_CPU_MIPS";
  87                 case DE_CPU_MIPS_64:    return "DE_CPU_MIPS_64";
  88                 case DE_CPU_RISCV_32:   return "DE_CPU_RISCV_32";
  89                 case DE_CPU_RISCV_64:   return "DE_CPU_RISCV_64";
  90                 default:
  91                         return de::toString(cpu);
  92         }
  93 }
  94
  95 std::string getEndiannessName (int endianness)
  96 {
  97         switch (endianness)
  98         {
  99                 case DE_BIG_ENDIAN:             return "DE_BIG_ENDIAN";
 100                 case DE_LITTLE_ENDIAN:  return "DE_LITTLE_ENDIAN";
 101                 default:
 102                         return de::toString(endianness);
 103         }
 104 }
 105
 106 tcu::TestStatus logBuildInfo (Context& context)
 107 {
 108 #if defined(DE_DEBUG)
 109         const bool      isDebug = true;
 110 #else
 111         const bool      isDebug = false;
 112 #endif
 113
 114         context.getTestContext().getLog()
 115                 << TestLog::Message
 116                 << "DE_OS: " << getOsName(DE_OS) << "\n"
 117                 << "DE_CPU: " << getCpuName(DE_CPU) << "\n"
 118                 << "DE_PTR_SIZE: " << DE_PTR_SIZE << "\n"
 119                 << "DE_ENDIANNESS: " << getEndiannessName(DE_ENDIANNESS) << "\n"
 120                 << "DE_COMPILER: " << getCompilerName(DE_COMPILER) << "\n"
 121                 << "DE_DEBUG: " << (isDebug ? "true" : "false") << "\n"
 122                 << TestLog::EndMessage;
 123
 124         return tcu::TestStatus::pass("Not validated");
 125 }
 126
 127 tcu::TestStatus logDeviceInfo (Context& context)
 128 {
 129         TestLog&                                                                log                     = context.getTestContext().getLog();
 130         const vk::VkPhysicalDeviceProperties&   properties      = context.getDeviceProperties();
 131
 132         log << TestLog::Message
 133                 << "Using --deqp-vk-device-id="
 134                 << context.getTestContext().getCommandLine().getVKDeviceId()
 135                 << TestLog::EndMessage;
 136
 137         log << TestLog::Message
 138                 << "apiVersion: " << vk::unpackVersion(properties.apiVersion) << "\n"
 139                 << "driverVersion: " << tcu::toHex(properties.driverVersion) << "\n"
 140                 << "deviceName: " << (const char*)properties.deviceName << "\n"
 141                 << "vendorID: " << tcu::toHex(properties.vendorID) << "\n"
 142                 << "deviceID: " << tcu::toHex(properties.deviceID) << "\n"
 143                 << TestLog::EndMessage;
 144
 145         return tcu::TestStatus::pass("Not validated");
 146 }
 147
 148 tcu::TestStatus logPlatformInfo (Context& context)
 149 {
 150         std::ostringstream details;
 151
 152         context.getTestContext().getPlatform().getVulkanPlatform().describePlatform(details);
 153
 154         context.getTestContext().getLog()
 155                 << TestLog::Message
 156                 << details.str()
 157                 << TestLog::EndMessage;
 158
 159         return tcu::TestStatus::pass("Not validated");
 160 }
 161
 162 template<typename SizeType>
 163 struct PrettySize
 164 {
 165         SizeType        value;
 166         int                     precision;
 167
 168         PrettySize (SizeType value_, int precision_)
 169                 : value         (value_)
 170                 , precision     (precision_)
 171         {}
 172 };
 173
 174 struct SizeUnit
 175 {
 176         const char*             name;
 177         deUint64                value;
 178 };
 179
 180 const SizeUnit* getBestSizeUnit (deUint64 value)
 181 {
 182         static const SizeUnit s_units[]         =
 183         {
 184                 // \note Must be ordered from largest to smallest
 185                 { "TiB",        1ull<<40ull             },
 186                 { "GiB",        1ull<<30ull             },
 187                 { "MiB",        1ull<<20ull             },
 188                 { "KiB",        1ull<<10ull             },
 189         };
 190         static const SizeUnit s_defaultUnit     = { "B", 1u };
 191
 192         for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_units); ++ndx)
 193         {
 194                 DE_ASSERT(ndx == DE_LENGTH_OF_ARRAY(s_units) ||
 195                           s_units[ndx].value > s_units[ndx + 1].value);
 196                 if (value >= s_units[ndx].value)
 197                         return &s_units[ndx];
 198         }
 199
 200         return &s_defaultUnit;
 201 }
 202
 203 template<typename SizeType>
 204 std::ostream& operator<< (std::ostream& str, const PrettySize<SizeType>& size)
 205 {
 206         const SizeUnit*         unit = getBestSizeUnit(deUint64(size.value));
 207         std::ostringstream      tmp;
 208
 209         tmp << std::fixed << std::setprecision(size.precision)
 210                 << (double(size.value) / double(unit->value))
 211                 << " " << unit->name;
 212
 213         return str << tmp.str();
 214 }
 215
 216 template<typename SizeType>
 217 PrettySize<SizeType> prettySize (SizeType value, int precision = 2)
 218 {
 219         return PrettySize<SizeType>(value, precision);
 220 }
 221
 222 tcu::TestStatus logPlatformMemoryLimits (Context& context)
 223 {
 224         TestLog&                                        log                     = context.getTestContext().getLog();
 225         tcu::PlatformMemoryLimits       limits;
 226
 227         context.getTestContext().getPlatform().getMemoryLimits(limits);
 228
 229         log << TestLog::Message << "totalSystemMemory = " << prettySize(limits.totalSystemMemory) << " (" << limits.totalSystemMemory << ")\n"
 230                                                         << "totalDeviceLocalMemory = " << prettySize(limits.totalDeviceLocalMemory) << " (" << limits.totalDeviceLocalMemory << ")\n"
 231                                                         << "deviceMemoryAllocationGranularity = " << limits.deviceMemoryAllocationGranularity << "\n"
 232                                                         << "devicePageSize = " << limits.devicePageSize << "\n"
 233                                                         << "devicePageTableEntrySize = " << limits.devicePageTableEntrySize << "\n"
 234                                                         << "devicePageTableHierarchyLevels = " << limits.devicePageTableHierarchyLevels << "\n"
 235                 << TestLog::EndMessage;
 236
 237         TCU_CHECK(limits.totalSystemMemory > 0);
 238         TCU_CHECK(limits.deviceMemoryAllocationGranularity > 0);
 239         TCU_CHECK(deIsPowerOfTwo64(limits.devicePageSize));
 240
 241         return tcu::TestStatus::pass("Pass");
 242 }
 243
 244 } // anonymous
 245
 246 void createInfoTests (tcu::TestCaseGroup* testGroup)
 247 {
 248         addFunctionCase(testGroup, "build",                     "Build Info",                           logBuildInfo);
 249         addFunctionCase(testGroup, "device",            "Device Info",                          logDeviceInfo);
 250         addFunctionCase(testGroup, "platform",          "Platform Info",                        logPlatformInfo);
 251         addFunctionCase(testGroup, "memory_limits",     "Platform Memory Limits",       logPlatformMemoryLimits);
 252
 253         api::createFeatureInfoInstanceTests             (testGroup);
 254         api::createFeatureInfoDeviceTests               (testGroup);
 255         api::createFeatureInfoDeviceGroupTests  (testGroup);
 256 }
 257
 258 } // vkt