// | |
// Copyright (c) 2017-2019 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; | |
} | |
} | |
} |