mirror of
https://github.com/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator.git
synced 2024-11-29 18:04:34 +00:00
329 lines
8.6 KiB
C++
329 lines
8.6 KiB
C++
//
|
|
// Copyright (c) 2017-2022 Advanced Micro Devices, Inc. All rights reserved.
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
// of this software and associated documentation files (the "Software"), to deal
|
|
// in the Software without restriction, including without limitation the rights
|
|
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
// copies of the Software, and to permit persons to whom the Software is
|
|
// furnished to do so, subject to the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included in
|
|
// all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
// THE SOFTWARE.
|
|
//
|
|
|
|
#include "Common.h"
|
|
|
|
#ifdef _WIN32
|
|
|
|
void ReadFile(std::vector<char>& out, const char* fileName)
|
|
{
|
|
std::ifstream file(fileName, std::ios::ate | std::ios::binary);
|
|
assert(file.is_open());
|
|
size_t fileSize = (size_t)file.tellg();
|
|
if(fileSize > 0)
|
|
{
|
|
out.resize(fileSize);
|
|
file.seekg(0);
|
|
file.read(out.data(), fileSize);
|
|
}
|
|
else
|
|
out.clear();
|
|
}
|
|
|
|
void SetConsoleColor(CONSOLE_COLOR color)
|
|
{
|
|
WORD attr = 0;
|
|
switch(color)
|
|
{
|
|
case CONSOLE_COLOR::INFO:
|
|
attr = FOREGROUND_INTENSITY;
|
|
break;
|
|
case CONSOLE_COLOR::NORMAL:
|
|
attr = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE;
|
|
break;
|
|
case CONSOLE_COLOR::WARNING:
|
|
attr = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY;
|
|
break;
|
|
case CONSOLE_COLOR::ERROR_:
|
|
attr = FOREGROUND_RED | FOREGROUND_INTENSITY;
|
|
break;
|
|
default:
|
|
assert(0);
|
|
}
|
|
|
|
HANDLE out = GetStdHandle(STD_OUTPUT_HANDLE);
|
|
SetConsoleTextAttribute(out, attr);
|
|
}
|
|
|
|
void PrintMessage(CONSOLE_COLOR color, const char* msg)
|
|
{
|
|
if(color != CONSOLE_COLOR::NORMAL)
|
|
SetConsoleColor(color);
|
|
|
|
printf("%s\n", msg);
|
|
|
|
if (color != CONSOLE_COLOR::NORMAL)
|
|
SetConsoleColor(CONSOLE_COLOR::NORMAL);
|
|
}
|
|
|
|
void PrintMessage(CONSOLE_COLOR color, const wchar_t* msg)
|
|
{
|
|
if(color != CONSOLE_COLOR::NORMAL)
|
|
SetConsoleColor(color);
|
|
|
|
wprintf(L"%s\n", msg);
|
|
|
|
if (color != CONSOLE_COLOR::NORMAL)
|
|
SetConsoleColor(CONSOLE_COLOR::NORMAL);
|
|
}
|
|
|
|
static const size_t CONSOLE_SMALL_BUF_SIZE = 256;
|
|
|
|
void PrintMessageV(CONSOLE_COLOR color, const char* format, va_list argList)
|
|
{
|
|
size_t dstLen = (size_t)::_vscprintf(format, argList);
|
|
if(dstLen)
|
|
{
|
|
bool useSmallBuf = dstLen < CONSOLE_SMALL_BUF_SIZE;
|
|
char smallBuf[CONSOLE_SMALL_BUF_SIZE];
|
|
std::vector<char> bigBuf(useSmallBuf ? 0 : dstLen + 1);
|
|
char* bufPtr = useSmallBuf ? smallBuf : bigBuf.data();
|
|
::vsprintf_s(bufPtr, dstLen + 1, format, argList);
|
|
PrintMessage(color, bufPtr);
|
|
}
|
|
}
|
|
|
|
void PrintMessageV(CONSOLE_COLOR color, const wchar_t* format, va_list argList)
|
|
{
|
|
size_t dstLen = (size_t)::_vcwprintf(format, argList);
|
|
if(dstLen)
|
|
{
|
|
bool useSmallBuf = dstLen < CONSOLE_SMALL_BUF_SIZE;
|
|
wchar_t smallBuf[CONSOLE_SMALL_BUF_SIZE];
|
|
std::vector<wchar_t> bigBuf(useSmallBuf ? 0 : dstLen + 1);
|
|
wchar_t* bufPtr = useSmallBuf ? smallBuf : bigBuf.data();
|
|
::vswprintf_s(bufPtr, dstLen + 1, format, argList);
|
|
PrintMessage(color, bufPtr);
|
|
}
|
|
}
|
|
|
|
void PrintMessageF(CONSOLE_COLOR color, const char* format, ...)
|
|
{
|
|
va_list argList;
|
|
va_start(argList, format);
|
|
PrintMessageV(color, format, argList);
|
|
va_end(argList);
|
|
}
|
|
|
|
void PrintMessageF(CONSOLE_COLOR color, const wchar_t* format, ...)
|
|
{
|
|
va_list argList;
|
|
va_start(argList, format);
|
|
PrintMessageV(color, format, argList);
|
|
va_end(argList);
|
|
}
|
|
|
|
void PrintWarningF(const char* format, ...)
|
|
{
|
|
va_list argList;
|
|
va_start(argList, format);
|
|
PrintMessageV(CONSOLE_COLOR::WARNING, format, argList);
|
|
va_end(argList);
|
|
}
|
|
|
|
void PrintWarningF(const wchar_t* format, ...)
|
|
{
|
|
va_list argList;
|
|
va_start(argList, format);
|
|
PrintMessageV(CONSOLE_COLOR::WARNING, format, argList);
|
|
va_end(argList);
|
|
}
|
|
|
|
void PrintErrorF(const char* format, ...)
|
|
{
|
|
va_list argList;
|
|
va_start(argList, format);
|
|
PrintMessageV(CONSOLE_COLOR::WARNING, format, argList);
|
|
va_end(argList);
|
|
}
|
|
|
|
void PrintErrorF(const wchar_t* format, ...)
|
|
{
|
|
va_list argList;
|
|
va_start(argList, format);
|
|
PrintMessageV(CONSOLE_COLOR::WARNING, format, argList);
|
|
va_end(argList);
|
|
}
|
|
|
|
void SaveFile(const wchar_t* filePath, const void* data, size_t dataSize)
|
|
{
|
|
FILE* f = nullptr;
|
|
_wfopen_s(&f, filePath, L"wb");
|
|
if(f)
|
|
{
|
|
fwrite(data, 1, dataSize, f);
|
|
fclose(f);
|
|
}
|
|
else
|
|
assert(0);
|
|
}
|
|
|
|
std::wstring SizeToStr(size_t size)
|
|
{
|
|
if(size == 0)
|
|
return L"0";
|
|
wchar_t result[32];
|
|
double size2 = (double)size;
|
|
if (size2 >= 1024.0*1024.0*1024.0*1024.0)
|
|
{
|
|
swprintf_s(result, L"%.2f TB", size2 / (1024.0*1024.0*1024.0*1024.0));
|
|
}
|
|
else if (size2 >= 1024.0*1024.0*1024.0)
|
|
{
|
|
swprintf_s(result, L"%.2f GB", size2 / (1024.0*1024.0*1024.0));
|
|
}
|
|
else if (size2 >= 1024.0*1024.0)
|
|
{
|
|
swprintf_s(result, L"%.2f MB", size2 / (1024.0*1024.0));
|
|
}
|
|
else if (size2 >= 1024.0)
|
|
{
|
|
swprintf_s(result, L"%.2f KB", size2 / 1024.0);
|
|
}
|
|
else
|
|
swprintf_s(result, L"%llu B", size);
|
|
return result;
|
|
}
|
|
|
|
bool ConvertCharsToUnicode(std::wstring *outStr, const std::string &s, unsigned codePage)
|
|
{
|
|
if (s.empty())
|
|
{
|
|
outStr->clear();
|
|
return true;
|
|
}
|
|
|
|
// Phase 1 - Get buffer size.
|
|
const int size = MultiByteToWideChar(codePage, 0, s.data(), (int)s.length(), NULL, 0);
|
|
if (size == 0)
|
|
{
|
|
outStr->clear();
|
|
return false;
|
|
}
|
|
|
|
// Phase 2 - Do conversion.
|
|
std::unique_ptr<wchar_t[]> buf(new wchar_t[(size_t)size]);
|
|
int result = MultiByteToWideChar(codePage, 0, s.data(), (int)s.length(), buf.get(), size);
|
|
if (result == 0)
|
|
{
|
|
outStr->clear();
|
|
return false;
|
|
}
|
|
|
|
outStr->assign(buf.get(), (size_t)size);
|
|
return true;
|
|
}
|
|
|
|
bool ConvertCharsToUnicode(std::wstring *outStr, const char *s, size_t sCharCount, unsigned codePage)
|
|
{
|
|
if (sCharCount == 0)
|
|
{
|
|
outStr->clear();
|
|
return true;
|
|
}
|
|
|
|
assert(sCharCount <= (size_t)INT_MAX);
|
|
|
|
// Phase 1 - Get buffer size.
|
|
int size = MultiByteToWideChar(codePage, 0, s, (int)sCharCount, NULL, 0);
|
|
if (size == 0)
|
|
{
|
|
outStr->clear();
|
|
return false;
|
|
}
|
|
|
|
// Phase 2 - Do conversion.
|
|
std::unique_ptr<wchar_t[]> buf(new wchar_t[(size_t)size]);
|
|
int result = MultiByteToWideChar(codePage, 0, s, (int)sCharCount, buf.get(), size);
|
|
if (result == 0)
|
|
{
|
|
outStr->clear();
|
|
return false;
|
|
}
|
|
|
|
outStr->assign(buf.get(), (size_t)size);
|
|
return true;
|
|
}
|
|
|
|
const wchar_t* PhysicalDeviceTypeToStr(VkPhysicalDeviceType type)
|
|
{
|
|
// Skipping common prefix VK_PHYSICAL_DEVICE_TYPE_
|
|
static const wchar_t* const VALUES[] = {
|
|
L"OTHER",
|
|
L"INTEGRATED_GPU",
|
|
L"DISCRETE_GPU",
|
|
L"VIRTUAL_GPU",
|
|
L"CPU",
|
|
};
|
|
return (uint32_t)type < _countof(VALUES) ? VALUES[(uint32_t)type] : L"";
|
|
}
|
|
|
|
const wchar_t* VendorIDToStr(uint32_t vendorID)
|
|
{
|
|
switch(vendorID)
|
|
{
|
|
// Skipping common prefix VK_VENDOR_ID_ for these:
|
|
case 0x10001: return L"VIV";
|
|
case 0x10002: return L"VSI";
|
|
case 0x10003: return L"KAZAN";
|
|
case 0x10004: return L"CODEPLAY";
|
|
case 0x10005: return L"MESA";
|
|
case 0x10006: return L"POCL";
|
|
// Others...
|
|
case VENDOR_ID_AMD: return L"AMD";
|
|
case VENDOR_ID_NVIDIA: return L"NVIDIA";
|
|
case VENDOR_ID_INTEL: return L"Intel";
|
|
case 0x1010: return L"ImgTec";
|
|
case 0x13B5: return L"ARM";
|
|
case 0x5143: return L"Qualcomm";
|
|
}
|
|
return L"";
|
|
}
|
|
|
|
#if VMA_VULKAN_VERSION >= 1002000
|
|
const wchar_t* DriverIDToStr(VkDriverId driverID)
|
|
{
|
|
// Skipping common prefix VK_DRIVER_ID_
|
|
static const wchar_t* const VALUES[] = {
|
|
L"",
|
|
L"AMD_PROPRIETARY",
|
|
L"AMD_OPEN_SOURCE",
|
|
L"MESA_RADV",
|
|
L"NVIDIA_PROPRIETARY",
|
|
L"INTEL_PROPRIETARY_WINDOWS",
|
|
L"INTEL_OPEN_SOURCE_MESA",
|
|
L"IMAGINATION_PROPRIETARY",
|
|
L"QUALCOMM_PROPRIETARY",
|
|
L"ARM_PROPRIETARY",
|
|
L"GOOGLE_SWIFTSHADER",
|
|
L"GGP_PROPRIETARY",
|
|
L"BROADCOM_PROPRIETARY",
|
|
L"MESA_LLVMPIPE",
|
|
L"MOLTENVK",
|
|
};
|
|
return (uint32_t)driverID < _countof(VALUES) ? VALUES[(uint32_t)driverID] : L"";
|
|
}
|
|
#endif // #if VMA_VULKAN_VERSION >= 1002000
|
|
|
|
|
|
#endif // #ifdef _WIN32
|