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 "deStringUtil.hpp"
33
34 #include <iomanip>
35
36 namespace vkt
37 {
38
39 namespace
40 {
41
42 using tcu::TestLog;
43 using std::string;
44
getOsName(int os)45 std::string getOsName (int os)
46 {
47 switch (os)
48 {
49 case DE_OS_VANILLA: return "DE_OS_VANILLA";
50 case DE_OS_WIN32: return "DE_OS_WIN32";
51 case DE_OS_UNIX: return "DE_OS_UNIX";
52 case DE_OS_WINCE: return "DE_OS_WINCE";
53 case DE_OS_OSX: return "DE_OS_OSX";
54 case DE_OS_ANDROID: return "DE_OS_ANDROID";
55 case DE_OS_SYMBIAN: return "DE_OS_SYMBIAN";
56 case DE_OS_IOS: return "DE_OS_IOS";
57 default:
58 return de::toString(os);
59 }
60 }
61
getCompilerName(int compiler)62 std::string getCompilerName (int compiler)
63 {
64 switch (compiler)
65 {
66 case DE_COMPILER_VANILLA: return "DE_COMPILER_VANILLA";
67 case DE_COMPILER_MSC: return "DE_COMPILER_MSC";
68 case DE_COMPILER_GCC: return "DE_COMPILER_GCC";
69 case DE_COMPILER_CLANG: return "DE_COMPILER_CLANG";
70 default:
71 return de::toString(compiler);
72 }
73 }
74
getCpuName(int cpu)75 std::string getCpuName (int cpu)
76 {
77 switch (cpu)
78 {
79 case DE_CPU_VANILLA: return "DE_CPU_VANILLA";
80 case DE_CPU_ARM: return "DE_CPU_ARM";
81 case DE_CPU_X86: return "DE_CPU_X86";
82 case DE_CPU_X86_64: return "DE_CPU_X86_64";
83 case DE_CPU_ARM_64: return "DE_CPU_ARM_64";
84 case DE_CPU_MIPS: return "DE_CPU_MIPS";
85 case DE_CPU_MIPS_64: return "DE_CPU_MIPS_64";
86 default:
87 return de::toString(cpu);
88 }
89 }
90
getEndiannessName(int endianness)91 std::string getEndiannessName (int endianness)
92 {
93 switch (endianness)
94 {
95 case DE_BIG_ENDIAN: return "DE_BIG_ENDIAN";
96 case DE_LITTLE_ENDIAN: return "DE_LITTLE_ENDIAN";
97 default:
98 return de::toString(endianness);
99 }
100 }
101
logBuildInfo(Context & context)102 tcu::TestStatus logBuildInfo (Context& context)
103 {
104 #if defined(DE_DEBUG)
105 const bool isDebug = true;
106 #else
107 const bool isDebug = false;
108 #endif
109
110 context.getTestContext().getLog()
111 << TestLog::Message
112 << "DE_OS: " << getOsName(DE_OS) << "\n"
113 << "DE_CPU: " << getCpuName(DE_CPU) << "\n"
114 << "DE_PTR_SIZE: " << DE_PTR_SIZE << "\n"
115 << "DE_ENDIANNESS: " << getEndiannessName(DE_ENDIANNESS) << "\n"
116 << "DE_COMPILER: " << getCompilerName(DE_COMPILER) << "\n"
117 << "DE_DEBUG: " << (isDebug ? "true" : "false") << "\n"
118 << TestLog::EndMessage;
119
120 return tcu::TestStatus::pass("Not validated");
121 }
122
logDeviceInfo(Context & context)123 tcu::TestStatus logDeviceInfo (Context& context)
124 {
125 TestLog& log = context.getTestContext().getLog();
126 const vk::VkPhysicalDeviceProperties& properties = context.getDeviceProperties();
127
128 log << TestLog::Message
129 << "Using --deqp-vk-device-id="
130 << context.getTestContext().getCommandLine().getVKDeviceId()
131 << TestLog::EndMessage;
132
133 log << TestLog::Message
134 << "apiVersion: " << vk::unpackVersion(properties.apiVersion) << "\n"
135 << "driverVersion: " << tcu::toHex(properties.driverVersion) << "\n"
136 << "deviceName: " << (const char*)properties.deviceName << "\n"
137 << "vendorID: " << tcu::toHex(properties.vendorID) << "\n"
138 << "deviceID: " << tcu::toHex(properties.deviceID) << "\n"
139 << TestLog::EndMessage;
140
141 return tcu::TestStatus::pass("Not validated");
142 }
143
logPlatformInfo(Context & context)144 tcu::TestStatus logPlatformInfo (Context& context)
145 {
146 std::ostringstream details;
147
148 context.getTestContext().getPlatform().getVulkanPlatform().describePlatform(details);
149
150 context.getTestContext().getLog()
151 << TestLog::Message
152 << details.str()
153 << TestLog::EndMessage;
154
155 return tcu::TestStatus::pass("Not validated");
156 }
157
158 template<typename SizeType>
159 struct PrettySize
160 {
161 SizeType value;
162 int precision;
163
PrettySizevkt::__anonea38e41c0111::PrettySize164 PrettySize (SizeType value_, int precision_)
165 : value (value_)
166 , precision (precision_)
167 {}
168 };
169
170 struct SizeUnit
171 {
172 const char* name;
173 deUint64 value;
174 };
175
getBestSizeUnit(deUint64 value)176 const SizeUnit* getBestSizeUnit (deUint64 value)
177 {
178 static const SizeUnit s_units[] =
179 {
180 // \note Must be ordered from largest to smallest
181 { "TiB", 1ull<<40ull },
182 { "MiB", 1ull<<20ull },
183 { "GiB", 1ull<<30ull },
184 { "KiB", 1ull<<10ull },
185 };
186 static const SizeUnit s_defaultUnit = { "B", 1u };
187
188 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_units); ++ndx)
189 {
190 if (value >= s_units[ndx].value)
191 return &s_units[ndx];
192 }
193
194 return &s_defaultUnit;
195 }
196
197 template<typename SizeType>
operator <<(std::ostream & str,const PrettySize<SizeType> & size)198 std::ostream& operator<< (std::ostream& str, const PrettySize<SizeType>& size)
199 {
200 const SizeUnit* unit = getBestSizeUnit(deUint64(size.value));
201 std::ostringstream tmp;
202
203 tmp << std::fixed << std::setprecision(size.precision)
204 << (double(size.value) / double(unit->value))
205 << " " << unit->name;
206
207 return str << tmp.str();
208 }
209
210 template<typename SizeType>
prettySize(SizeType value,int precision=2)211 PrettySize<SizeType> prettySize (SizeType value, int precision = 2)
212 {
213 return PrettySize<SizeType>(value, precision);
214 }
215
logPlatformMemoryLimits(Context & context)216 tcu::TestStatus logPlatformMemoryLimits (Context& context)
217 {
218 TestLog& log = context.getTestContext().getLog();
219 vk::PlatformMemoryLimits limits;
220
221 context.getTestContext().getPlatform().getVulkanPlatform().getMemoryLimits(limits);
222
223 log << TestLog::Message << "totalSystemMemory = " << prettySize(limits.totalSystemMemory) << " (" << limits.totalSystemMemory << ")\n"
224 << "totalDeviceLocalMemory = " << prettySize(limits.totalDeviceLocalMemory) << " (" << limits.totalDeviceLocalMemory << ")\n"
225 << "deviceMemoryAllocationGranularity = " << limits.deviceMemoryAllocationGranularity << "\n"
226 << "devicePageSize = " << limits.devicePageSize << "\n"
227 << "devicePageTableEntrySize = " << limits.devicePageTableEntrySize << "\n"
228 << "devicePageTableHierarchyLevels = " << limits.devicePageTableHierarchyLevels << "\n"
229 << TestLog::EndMessage;
230
231 TCU_CHECK(limits.totalSystemMemory > 0);
232 TCU_CHECK(limits.deviceMemoryAllocationGranularity > 0);
233 TCU_CHECK(deIsPowerOfTwo64(limits.devicePageSize));
234
235 return tcu::TestStatus::pass("Pass");
236 }
237
238 } // anonymous
239
createInfoTests(tcu::TestCaseGroup * testGroup)240 void createInfoTests (tcu::TestCaseGroup* testGroup)
241 {
242 addFunctionCase(testGroup, "build", "Build Info", logBuildInfo);
243 addFunctionCase(testGroup, "device", "Device Info", logDeviceInfo);
244 addFunctionCase(testGroup, "platform", "Platform Info", logPlatformInfo);
245 addFunctionCase(testGroup, "memory_limits", "Platform Memory Limits", logPlatformMemoryLimits);
246 }
247
248 } // vkt
249