// // Copyright (c) 2017-2020 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. // #pragma once #include "VmaUsage.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include typedef std::chrono::high_resolution_clock::time_point time_point; typedef std::chrono::high_resolution_clock::duration duration; inline float ToFloatSeconds(duration d) { return std::chrono::duration_cast>(d).count(); } void SecondsToFriendlyStr(float seconds, std::string& out); template T ceil_div(T x, T y) { return (x+y-1) / y; } template inline T round_div(T x, T y) { return (x+y/(T)2) / y; } template inline T align_up(T val, T align) { return (val + align - 1) / align * align; } struct StrRange { const char* beg; const char* end; StrRange() { } StrRange(const char* beg, const char* end) : beg(beg), end(end) { } explicit StrRange(const char* sz) : beg(sz), end(sz + strlen(sz)) { } explicit StrRange(const std::string& s) : beg(s.data()), end(s.data() + s.length()) { } size_t length() const { return end - beg; } void to_str(std::string& out) const { out.assign(beg, end); } }; inline bool StrRangeEq(const StrRange& lhs, const char* rhsSz) { const size_t rhsLen = strlen(rhsSz); return rhsLen == lhs.length() && memcmp(lhs.beg, rhsSz, rhsLen) == 0; } inline bool StrRangeToUint(const StrRange& s, uint32_t& out) { char* end = (char*)s.end; out = (uint32_t)strtoul(s.beg, &end, 10); return end == s.end; } inline bool StrRangeToUint(const StrRange& s, uint64_t& out) { char* end = (char*)s.end; out = (uint64_t)strtoull(s.beg, &end, 10); return end == s.end; } inline bool StrRangeToPtr(const StrRange& s, uint64_t& out) { char* end = (char*)s.end; out = (uint64_t)strtoull(s.beg, &end, 16); return end == s.end; } inline bool StrRangeToFloat(const StrRange& s, float& out) { char* end = (char*)s.end; out = strtof(s.beg, &end); return end == s.end; } inline bool StrRangeToBool(const StrRange& s, bool& out) { if(s.end - s.beg == 1) { if(*s.beg == '1') { out = true; } else if(*s.beg == '0') { out = false; } else { return false; } } else { return false; } return true; } bool StrRangeToPtrList(const StrRange& s, std::vector& out); class LineSplit { public: LineSplit(const char* data, size_t numBytes) : m_Data(data), m_NumBytes(numBytes), m_NextLineBeg(0), m_NextLineIndex(0) { } bool GetNextLine(StrRange& out); size_t GetNextLineIndex() const { return m_NextLineIndex; } private: const char* const m_Data; const size_t m_NumBytes; size_t m_NextLineBeg; size_t m_NextLineIndex; }; class CsvSplit { public: static const size_t RANGE_COUNT_MAX = 32; void Set(const StrRange& line, size_t maxCount = RANGE_COUNT_MAX); const StrRange& GetLine() const { return m_Line; } size_t GetCount() const { return m_Count; } StrRange GetRange(size_t index) const { if(index < m_Count) { return StrRange { m_Line.beg + m_Ranges[index * 2], m_Line.beg + m_Ranges[index * 2 + 1] }; } else { return StrRange{0, 0}; } } private: StrRange m_Line = { nullptr, nullptr }; size_t m_Count = 0; size_t m_Ranges[RANGE_COUNT_MAX * 2]; // Pairs of begin-end. }; class CmdLineParser { public: enum RESULT { RESULT_OPT, RESULT_PARAMETER, RESULT_END, RESULT_ERROR, }; CmdLineParser(int argc, char **argv); CmdLineParser(const char *CmdLine); void RegisterOpt(uint32_t Id, char Opt, bool Parameter); void RegisterOpt(uint32_t Id, const std::string &Opt, bool Parameter); RESULT ReadNext(); uint32_t GetOptId(); const std::string & GetParameter(); private: struct SHORT_OPT { uint32_t Id; char Opt; bool Parameter; SHORT_OPT(uint32_t Id, char Opt, bool Parameter) : Id(Id), Opt(Opt), Parameter(Parameter) { } }; struct LONG_OPT { uint32_t Id; std::string Opt; bool Parameter; LONG_OPT(uint32_t Id, std::string Opt, bool Parameter) : Id(Id), Opt(Opt), Parameter(Parameter) { } }; char **m_argv; const char *m_CmdLine; int m_argc; size_t m_CmdLineLength; size_t m_ArgIndex; bool ReadNextArg(std::string *OutArg); std::vector m_ShortOpts; std::vector m_LongOpts; SHORT_OPT * FindShortOpt(char Opt); LONG_OPT * FindLongOpt(const std::string &Opt); bool m_InsideMultioption; std::string m_LastArg; size_t m_LastArgIndex; uint32_t m_LastOptId; std::string m_LastParameter; }; /* Parses and stores a sequence of ranges. Upper range is inclusive. Examples: "1" -> [ {1, 1} ] "1,10" -> [ {1, 1}, {10, 10} ] "2-6" -> [ {2, 6} ] "-8" -> [ {MIN, 8} ] "12-" -> [ {12, MAX} ] "1-10,12,15-" -> [ {1, 10}, {12, 12}, {15, MAX} ] TODO: Optimize it: Do sorting and merging while parsing. Do binary search while reading. */ template class RangeSequence { public: typedef std::pair RangeType; void Clear() { m_Ranges.clear(); } bool Parse(const StrRange& str); bool IsEmpty() const { return m_Ranges.empty(); } size_t GetCount() const { return m_Ranges.size(); } const RangeType* GetRanges() const { return m_Ranges.data(); } bool Includes(T number) const; private: std::vector m_Ranges; }; template bool RangeSequence::Parse(const StrRange& str) { m_Ranges.clear(); StrRange currRange = { str.beg, str.beg }; while(currRange.beg < str.end) { currRange.end = currRange.beg + 1; // Find next ',' or the end. while(currRange.end < str.end && *currRange.end != ',') { ++currRange.end; } // Find '-' within this range. const char* hyphenPos = currRange.beg; while(hyphenPos < currRange.end && *hyphenPos != '-') { ++hyphenPos; } // No hyphen - single number like '10'. if(hyphenPos == currRange.end) { RangeType range; if(!StrRangeToUint(currRange, range.first)) { return false; } range.second = range.first; m_Ranges.push_back(range); } // Hyphen at the end, like '10-'. else if(hyphenPos + 1 == currRange.end) { const StrRange numberRange = { currRange.beg, hyphenPos }; RangeType range; if(!StrRangeToUint(numberRange, range.first)) { return false; } range.second = std::numeric_limits::max(); m_Ranges.push_back(range); } // Hyphen at the beginning, like "-10". else if(hyphenPos == currRange.beg) { const StrRange numberRange = { currRange.beg + 1, currRange.end }; RangeType range; range.first = std::numeric_limits::min(); if(!StrRangeToUint(numberRange, range.second)) { return false; } m_Ranges.push_back(range); } // Hyphen in the middle, like "1-10". else { const StrRange numberRange1 = { currRange.beg, hyphenPos }; const StrRange numberRange2 = { hyphenPos + 1, currRange.end }; RangeType range; if(!StrRangeToUint(numberRange1, range.first) || !StrRangeToUint(numberRange2, range.second) || range.second < range.first) { return false; } m_Ranges.push_back(range); } // Skip ',' currRange.beg = currRange.end + 1; } return true; } template bool RangeSequence::Includes(T number) const { for(const auto& it : m_Ranges) { if(number >= it.first && number <= it.second) { return true; } } return false; } /* class RandomNumberGenerator { public: RandomNumberGenerator() : m_Value{GetTickCount()} {} RandomNumberGenerator(uint32_t seed) : m_Value{seed} { } void Seed(uint32_t seed) { m_Value = seed; } uint32_t Generate() { return GenerateFast() ^ (GenerateFast() >> 7); } private: uint32_t m_Value; uint32_t GenerateFast() { return m_Value = (m_Value * 196314165 + 907633515); } }; enum class CONSOLE_COLOR { INFO, NORMAL, WARNING, ERROR_, COUNT }; void SetConsoleColor(CONSOLE_COLOR color); void PrintMessage(CONSOLE_COLOR color, const char* msg); void PrintMessage(CONSOLE_COLOR color, const wchar_t* msg); inline void Print(const char* msg) { PrintMessage(CONSOLE_COLOR::NORMAL, msg); } inline void Print(const wchar_t* msg) { PrintMessage(CONSOLE_COLOR::NORMAL, msg); } inline void PrintWarning(const char* msg) { PrintMessage(CONSOLE_COLOR::WARNING, msg); } inline void PrintWarning(const wchar_t* msg) { PrintMessage(CONSOLE_COLOR::WARNING, msg); } inline void PrintError(const char* msg) { PrintMessage(CONSOLE_COLOR::ERROR_, msg); } inline void PrintError(const wchar_t* msg) { PrintMessage(CONSOLE_COLOR::ERROR_, msg); } void PrintMessageV(CONSOLE_COLOR color, const char* format, va_list argList); void PrintMessageV(CONSOLE_COLOR color, const wchar_t* format, va_list argList); void PrintMessageF(CONSOLE_COLOR color, const char* format, ...); void PrintMessageF(CONSOLE_COLOR color, const wchar_t* format, ...); void PrintWarningF(const char* format, ...); void PrintWarningF(const wchar_t* format, ...); void PrintErrorF(const char* format, ...); void PrintErrorF(const wchar_t* format, ...); */