| // |
| // 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. |
| // |
| |
| #include "Common.h" |
| |
| bool StrRangeToPtrList(const StrRange& s, std::vector<uint64_t>& out) |
| { |
| out.clear(); |
| StrRange currRange = { s.beg, nullptr }; |
| while(currRange.beg < s.end) |
| { |
| currRange.end = currRange.beg; |
| while(currRange.end < s.end && *currRange.end != ' ') |
| { |
| ++currRange.end; |
| } |
| |
| uint64_t ptr = 0; |
| if(!StrRangeToPtr(currRange, ptr)) |
| { |
| return false; |
| } |
| out.push_back(ptr); |
| |
| currRange.beg = currRange.end + 1; |
| } |
| return true; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // LineSplit class |
| |
| bool LineSplit::GetNextLine(StrRange& out) |
| { |
| if(m_NextLineBeg < m_NumBytes) |
| { |
| out.beg = m_Data + m_NextLineBeg; |
| size_t currLineEnd = m_NextLineBeg; |
| while(currLineEnd < m_NumBytes && m_Data[currLineEnd] != '\n') |
| ++currLineEnd; |
| out.end = m_Data + currLineEnd; |
| // Ignore trailing '\r' to support Windows end of line. |
| if(out.end > out.beg && *(out.end - 1) == '\r') |
| { |
| --out.end; |
| } |
| m_NextLineBeg = currLineEnd + 1; // Past '\n' |
| ++m_NextLineIndex; |
| return true; |
| } |
| else |
| return false; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // CsvSplit class |
| |
| void CsvSplit::Set(const StrRange& line, size_t maxCount) |
| { |
| assert(maxCount <= RANGE_COUNT_MAX); |
| m_Line = line; |
| const size_t strLen = line.length(); |
| size_t rangeIndex = 0; |
| size_t charIndex = 0; |
| while(charIndex < strLen && rangeIndex < maxCount) |
| { |
| m_Ranges[rangeIndex * 2] = charIndex; |
| while(charIndex < strLen && (rangeIndex + 1 == maxCount || m_Line.beg[charIndex] != ',')) |
| ++charIndex; |
| m_Ranges[rangeIndex * 2 + 1] = charIndex; |
| ++rangeIndex; |
| ++charIndex; // Past ',' |
| } |
| m_Count = rangeIndex; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // class CmdLineParser |
| |
| bool CmdLineParser::ReadNextArg(std::string *OutArg) |
| { |
| if (m_argv != NULL) |
| { |
| if (m_ArgIndex >= (size_t)m_argc) return false; |
| |
| *OutArg = m_argv[m_ArgIndex]; |
| m_ArgIndex++; |
| return true; |
| } |
| else |
| { |
| if (m_ArgIndex >= m_CmdLineLength) return false; |
| |
| OutArg->clear(); |
| bool InsideQuotes = false; |
| while (m_ArgIndex < m_CmdLineLength) |
| { |
| char Ch = m_CmdLine[m_ArgIndex]; |
| if (Ch == '\\') |
| { |
| bool FollowedByQuote = false; |
| size_t BackslashCount = 1; |
| size_t TmpIndex = m_ArgIndex + 1; |
| while (TmpIndex < m_CmdLineLength) |
| { |
| char TmpCh = m_CmdLine[TmpIndex]; |
| if (TmpCh == '\\') |
| { |
| BackslashCount++; |
| TmpIndex++; |
| } |
| else if (TmpCh == '"') |
| { |
| FollowedByQuote = true; |
| break; |
| } |
| else |
| break; |
| } |
| |
| if (FollowedByQuote) |
| { |
| if (BackslashCount % 2 == 0) |
| { |
| for (size_t i = 0; i < BackslashCount / 2; i++) |
| *OutArg += '\\'; |
| m_ArgIndex += BackslashCount + 1; |
| InsideQuotes = !InsideQuotes; |
| } |
| else |
| { |
| for (size_t i = 0; i < BackslashCount / 2; i++) |
| *OutArg += '\\'; |
| *OutArg += '"'; |
| m_ArgIndex += BackslashCount + 1; |
| } |
| } |
| else |
| { |
| for (size_t i = 0; i < BackslashCount; i++) |
| *OutArg += '\\'; |
| m_ArgIndex += BackslashCount; |
| } |
| } |
| else if (Ch == '"') |
| { |
| InsideQuotes = !InsideQuotes; |
| m_ArgIndex++; |
| } |
| else if (isspace(Ch)) |
| { |
| if (InsideQuotes) |
| { |
| *OutArg += Ch; |
| m_ArgIndex++; |
| } |
| else |
| { |
| m_ArgIndex++; |
| break; |
| } |
| } |
| else |
| { |
| *OutArg += Ch; |
| m_ArgIndex++; |
| } |
| } |
| |
| while (m_ArgIndex < m_CmdLineLength && isspace(m_CmdLine[m_ArgIndex])) |
| m_ArgIndex++; |
| |
| return true; |
| } |
| } |
| |
| CmdLineParser::SHORT_OPT * CmdLineParser::FindShortOpt(char Opt) |
| { |
| for (size_t i = 0; i < m_ShortOpts.size(); i++) |
| if (m_ShortOpts[i].Opt == Opt) |
| return &m_ShortOpts[i]; |
| return NULL; |
| } |
| |
| CmdLineParser::LONG_OPT * CmdLineParser::FindLongOpt(const std::string &Opt) |
| { |
| for (size_t i = 0; i < m_LongOpts.size(); i++) |
| if (m_LongOpts[i].Opt == Opt) |
| return &m_LongOpts[i]; |
| return NULL; |
| } |
| |
| CmdLineParser::CmdLineParser(int argc, char **argv) : |
| m_argv(argv), |
| m_CmdLine(NULL), |
| m_argc(argc), |
| m_CmdLineLength(0), |
| m_ArgIndex(1), |
| m_InsideMultioption(false), |
| m_LastArgIndex(0), |
| m_LastOptId(0) |
| { |
| assert(argc > 0); |
| assert(argv != NULL); |
| } |
| |
| CmdLineParser::CmdLineParser(const char *CmdLine) : |
| m_argv(NULL), |
| m_CmdLine(CmdLine), |
| m_argc(0), |
| m_ArgIndex(0), |
| m_InsideMultioption(false), |
| m_LastArgIndex(0), |
| m_LastOptId(0) |
| { |
| assert(CmdLine != NULL); |
| |
| m_CmdLineLength = strlen(m_CmdLine); |
| |
| while (m_ArgIndex < m_CmdLineLength && isspace(m_CmdLine[m_ArgIndex])) |
| m_ArgIndex++; |
| } |
| |
| void CmdLineParser::RegisterOpt(uint32_t Id, char Opt, bool Parameter) |
| { |
| assert(Opt != '\0'); |
| |
| m_ShortOpts.push_back(SHORT_OPT(Id, Opt, Parameter)); |
| } |
| |
| void CmdLineParser::RegisterOpt(uint32_t Id, const std::string &Opt, bool Parameter) |
| { |
| assert(!Opt.empty()); |
| |
| m_LongOpts.push_back(LONG_OPT(Id, Opt, Parameter)); |
| } |
| |
| CmdLineParser::RESULT CmdLineParser::ReadNext() |
| { |
| if (m_InsideMultioption) |
| { |
| assert(m_LastArgIndex < m_LastArg.length()); |
| SHORT_OPT *so = FindShortOpt(m_LastArg[m_LastArgIndex]); |
| if (so == NULL) |
| { |
| m_LastOptId = 0; |
| m_LastParameter.clear(); |
| return CmdLineParser::RESULT_ERROR; |
| } |
| if (so->Parameter) |
| { |
| if (m_LastArg.length() == m_LastArgIndex+1) |
| { |
| if (!ReadNextArg(&m_LastParameter)) |
| { |
| m_LastOptId = 0; |
| m_LastParameter.clear(); |
| return CmdLineParser::RESULT_ERROR; |
| } |
| m_InsideMultioption = false; |
| m_LastOptId = so->Id; |
| return CmdLineParser::RESULT_OPT; |
| } |
| else if (m_LastArg[m_LastArgIndex+1] == '=') |
| { |
| m_InsideMultioption = false; |
| m_LastParameter = m_LastArg.substr(m_LastArgIndex+2); |
| m_LastOptId = so->Id; |
| return CmdLineParser::RESULT_OPT; |
| } |
| else |
| { |
| m_InsideMultioption = false; |
| m_LastParameter = m_LastArg.substr(m_LastArgIndex+1); |
| m_LastOptId = so->Id; |
| return CmdLineParser::RESULT_OPT; |
| } |
| } |
| else |
| { |
| if (m_LastArg.length() == m_LastArgIndex+1) |
| { |
| m_InsideMultioption = false; |
| m_LastParameter.clear(); |
| m_LastOptId = so->Id; |
| return CmdLineParser::RESULT_OPT; |
| } |
| else |
| { |
| m_LastArgIndex++; |
| |
| m_LastParameter.clear(); |
| m_LastOptId = so->Id; |
| return CmdLineParser::RESULT_OPT; |
| } |
| } |
| } |
| else |
| { |
| if (!ReadNextArg(&m_LastArg)) |
| { |
| m_LastParameter.clear(); |
| m_LastOptId = 0; |
| return CmdLineParser::RESULT_END; |
| } |
| |
| if (!m_LastArg.empty() && m_LastArg[0] == '-') |
| { |
| if (m_LastArg.length() > 1 && m_LastArg[1] == '-') |
| { |
| size_t EqualIndex = m_LastArg.find('=', 2); |
| if (EqualIndex != std::string::npos) |
| { |
| LONG_OPT *lo = FindLongOpt(m_LastArg.substr(2, EqualIndex-2)); |
| if (lo == NULL || lo->Parameter == false) |
| { |
| m_LastOptId = 0; |
| m_LastParameter.clear(); |
| return CmdLineParser::RESULT_ERROR; |
| } |
| m_LastParameter = m_LastArg.substr(EqualIndex+1); |
| m_LastOptId = lo->Id; |
| return CmdLineParser::RESULT_OPT; |
| } |
| else |
| { |
| LONG_OPT *lo = FindLongOpt(m_LastArg.substr(2)); |
| if (lo == NULL) |
| { |
| m_LastOptId = 0; |
| m_LastParameter.clear(); |
| return CmdLineParser::RESULT_ERROR; |
| } |
| if (lo->Parameter) |
| { |
| if (!ReadNextArg(&m_LastParameter)) |
| { |
| m_LastOptId = 0; |
| m_LastParameter.clear(); |
| return CmdLineParser::RESULT_ERROR; |
| } |
| } |
| else |
| m_LastParameter.clear(); |
| m_LastOptId = lo->Id; |
| return CmdLineParser::RESULT_OPT; |
| } |
| } |
| else |
| { |
| if (m_LastArg.length() < 2) |
| { |
| m_LastOptId = 0; |
| m_LastParameter.clear(); |
| return CmdLineParser::RESULT_ERROR; |
| } |
| SHORT_OPT *so = FindShortOpt(m_LastArg[1]); |
| if (so == NULL) |
| { |
| m_LastOptId = 0; |
| m_LastParameter.clear(); |
| return CmdLineParser::RESULT_ERROR; |
| } |
| if (so->Parameter) |
| { |
| if (m_LastArg.length() == 2) |
| { |
| if (!ReadNextArg(&m_LastParameter)) |
| { |
| m_LastOptId = 0; |
| m_LastParameter.clear(); |
| return CmdLineParser::RESULT_ERROR; |
| } |
| m_LastOptId = so->Id; |
| return CmdLineParser::RESULT_OPT; |
| } |
| else if (m_LastArg[2] == '=') |
| { |
| m_LastParameter = m_LastArg.substr(3); |
| m_LastOptId = so->Id; |
| return CmdLineParser::RESULT_OPT; |
| } |
| else |
| { |
| m_LastParameter = m_LastArg.substr(2); |
| m_LastOptId = so->Id; |
| return CmdLineParser::RESULT_OPT; |
| } |
| } |
| else |
| { |
| if (m_LastArg.length() == 2) |
| { |
| m_LastParameter.clear(); |
| m_LastOptId = so->Id; |
| return CmdLineParser::RESULT_OPT; |
| } |
| else |
| { |
| m_InsideMultioption = true; |
| m_LastArgIndex = 2; |
| |
| m_LastParameter.clear(); |
| m_LastOptId = so->Id; |
| return CmdLineParser::RESULT_OPT; |
| } |
| } |
| } |
| } |
| else if (!m_LastArg.empty() && m_LastArg[0] == '/') |
| { |
| size_t EqualIndex = m_LastArg.find('=', 1); |
| if (EqualIndex != std::string::npos) |
| { |
| if (EqualIndex == 2) |
| { |
| SHORT_OPT *so = FindShortOpt(m_LastArg[1]); |
| if (so != NULL) |
| { |
| if (so->Parameter == false) |
| { |
| m_LastOptId = 0; |
| m_LastParameter.clear(); |
| return CmdLineParser::RESULT_ERROR; |
| } |
| m_LastParameter = m_LastArg.substr(EqualIndex+1); |
| m_LastOptId = so->Id; |
| return CmdLineParser::RESULT_OPT; |
| } |
| } |
| LONG_OPT *lo = FindLongOpt(m_LastArg.substr(1, EqualIndex-1)); |
| if (lo == NULL || lo->Parameter == false) |
| { |
| m_LastOptId = 0; |
| m_LastParameter.clear(); |
| return CmdLineParser::RESULT_ERROR; |
| } |
| m_LastParameter = m_LastArg.substr(EqualIndex+1); |
| m_LastOptId = lo->Id; |
| return CmdLineParser::RESULT_OPT; |
| } |
| else |
| { |
| if (m_LastArg.length() == 2) |
| { |
| SHORT_OPT *so = FindShortOpt(m_LastArg[1]); |
| if (so != NULL) |
| { |
| if (so->Parameter) |
| { |
| if (!ReadNextArg(&m_LastParameter)) |
| { |
| m_LastOptId = 0; |
| m_LastParameter.clear(); |
| return CmdLineParser::RESULT_ERROR; |
| } |
| } |
| else |
| m_LastParameter.clear(); |
| m_LastOptId = so->Id; |
| return CmdLineParser::RESULT_OPT; |
| } |
| } |
| LONG_OPT *lo = FindLongOpt(m_LastArg.substr(1)); |
| if (lo == NULL) |
| { |
| m_LastOptId = 0; |
| m_LastParameter.clear(); |
| return CmdLineParser::RESULT_ERROR; |
| } |
| if (lo->Parameter) |
| { |
| if (!ReadNextArg(&m_LastParameter)) |
| { |
| m_LastOptId = 0; |
| m_LastParameter.clear(); |
| return CmdLineParser::RESULT_ERROR; |
| } |
| } |
| else |
| m_LastParameter.clear(); |
| m_LastOptId = lo->Id; |
| return CmdLineParser::RESULT_OPT; |
| } |
| } |
| else |
| { |
| m_LastOptId = 0; |
| m_LastParameter = m_LastArg; |
| return CmdLineParser::RESULT_PARAMETER; |
| } |
| } |
| } |
| |
| uint32_t CmdLineParser::GetOptId() |
| { |
| return m_LastOptId; |
| } |
| |
| const std::string & CmdLineParser::GetParameter() |
| { |
| return m_LastParameter; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // Glolals |
| |
| /* |
| |
| 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 SecondsToFriendlyStr(float seconds, std::string& out) |
| { |
| if(seconds == 0.f) |
| { |
| out = "0"; |
| return; |
| } |
| |
| if (seconds < 0.f) |
| { |
| out = "-"; |
| seconds = -seconds; |
| } |
| else |
| { |
| out.clear(); |
| } |
| |
| char s[32]; |
| |
| // #.### ns |
| if(seconds < 1e-6) |
| { |
| sprintf_s(s, "%.3f ns", seconds * 1e9); |
| out += s; |
| } |
| // #.### us |
| else if(seconds < 1e-3) |
| { |
| sprintf_s(s, "%.3f us", seconds * 1e6); |
| out += s; |
| } |
| // #.### ms |
| else if(seconds < 1.f) |
| { |
| sprintf_s(s, "%.3f ms", seconds * 1e3); |
| out += s; |
| } |
| // #.### s |
| else if(seconds < 60.f) |
| { |
| sprintf_s(s, "%.3f s", seconds); |
| out += s; |
| } |
| else |
| { |
| uint64_t seconds_u = (uint64_t)seconds; |
| // "#:## min" |
| if (seconds_u < 3600) |
| { |
| uint64_t minutes = seconds_u / 60; |
| seconds_u -= minutes * 60; |
| sprintf_s(s, "%llu:%02llu min", minutes, seconds_u); |
| out += s; |
| } |
| // "#:##:## h" |
| else |
| { |
| uint64_t minutes = seconds_u / 60; |
| seconds_u -= minutes * 60; |
| uint64_t hours = minutes / 60; |
| minutes -= hours * 60; |
| sprintf_s(s, "%llu:%02llu:%02llu h", hours, minutes, seconds_u); |
| out += s; |
| } |
| } |
| } |