241 lines
11 KiB
C++
241 lines
11 KiB
C++
/*
|
|
* Copyright (c) 2014-2023, NVIDIA CORPORATION. All rights reserved.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*
|
|
* SPDX-FileCopyrightText: Copyright (c) 2014-2023 NVIDIA CORPORATION
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*/
|
|
|
|
|
|
#ifndef __NVPRINT_H__
|
|
#define __NVPRINT_H__
|
|
|
|
#include <cstdarg>
|
|
#include <fmt/format.h>
|
|
#include <functional>
|
|
#include <stdint.h>
|
|
#include <string>
|
|
|
|
/** @DOC_START
|
|
Multiple functions and macros that should be used for logging purposes,
|
|
rather than printf. These can print to multiple places at once
|
|
# Function nvprintf etc
|
|
|
|
Configuration:
|
|
- nvprintSetLevel : sets default loglevel
|
|
- nvprintGetLevel : gets default loglevel
|
|
- nvprintSetLogFileName : sets log filename
|
|
- nvprintSetLogging : sets file logging state
|
|
- nvprintSetCallback : sets custom callback
|
|
|
|
Printf-style functions and macros.
|
|
These take printf-style specifiers.
|
|
- nvprintf : prints at default loglevel
|
|
- nvprintfLevel : nvprintfLevel print at a certain loglevel
|
|
- LOGI : macro that does nvprintfLevel(LOGLEVEL_INFO)
|
|
- LOGW : macro that does nvprintfLevel(LOGLEVEL_WARNING)
|
|
- LOGE : macro that does nvprintfLevel(LOGLEVEL_ERROR)
|
|
- LOGE_FILELINE : macro that does nvprintfLevel(LOGLEVEL_ERROR) combined with filename/line
|
|
- LOGD : macro that does nvprintfLevel(LOGLEVEL_DEBUG) (only in debug builds)
|
|
- LOGOK : macro that does nvprintfLevel(LOGLEVEL_OK)
|
|
- LOGSTATS : macro that does nvprintfLevel(LOGLEVEL_STATS)
|
|
|
|
std::print-style functions and macros.
|
|
These take std::format-style specifiers
|
|
(https://en.cppreference.com/w/cpp/utility/format/formatter#Standard_format_specification).
|
|
- nvprintLevel : print at a certain loglevel
|
|
- PRINTI : macro that does nvprintLevel(LOGLEVEL_INFO)
|
|
- PRINTW : macro that does nvprintLevel(LOGLEVEL_WARNING)
|
|
- PRINTE : macro that does nvprintLevel(LOGLEVEL_ERROR)
|
|
- PRINTE_FILELINE : macro that does nvprintLevel(LOGLEVEL_ERROR) combined with filename/line
|
|
- PRINTD : macro that does nvprintLevel(LOGLEVEL_DEBUG) (only in debug builds)
|
|
- PRINTOK : macro that does nvprintLevel(LOGLEVEL_OK)
|
|
- PRINTSTATS : macro that does nvprintLevel(LOGLEVEL_STATS)
|
|
|
|
Safety:
|
|
On error, all functions print an error message.
|
|
All functions are thread-safe.
|
|
Printf-style functions have annotations that should produce warnings at
|
|
compile-time or when performing static analysis. Their format strings may be
|
|
dynamic - but this can be bad if an adversary can choose the content of the
|
|
format string.
|
|
std::print-style functions are safer: they produce compile-time errors, and
|
|
their format strings must be compile-time constants. Dynamic formatting
|
|
should be performed outside of printing, like this:
|
|
```cpp
|
|
ImGui::InputText("Enter a format string: ", userFormat, sizeof(userFormat));
|
|
try
|
|
{
|
|
std::string formatted = fmt::vformat(userFormat, ...);
|
|
}
|
|
catch (const std::exception& e)
|
|
{
|
|
(error handling...)
|
|
}
|
|
PRINTI("{}", formatted);
|
|
```
|
|
|
|
Text encoding:
|
|
Printing to the Windows debug console is the only operation that assumes a
|
|
text encoding, which is ANSI. In all other cases, strings are copied into
|
|
the output.
|
|
@DOC_END */
|
|
|
|
|
|
// trick for pragma message so we can write:
|
|
// #pragma message(__FILE__"("S__LINE__"): blah")
|
|
#define S__(x) #x
|
|
#define S_(x) S__(x)
|
|
#define S__LINE__ S_(__LINE__)
|
|
|
|
#ifndef LOGLEVEL_INFO
|
|
#define LOGLEVEL_INFO 0
|
|
#define LOGLEVEL_WARNING 1
|
|
#define LOGLEVEL_ERROR 2
|
|
#define LOGLEVEL_DEBUG 3
|
|
#define LOGLEVEL_STATS 4
|
|
#define LOGLEVEL_OK 7
|
|
#define LOGBIT_INFO (1 << LOGLEVEL_INFO)
|
|
#define LOGBIT_WARNING (1 << LOGLEVEL_WARNING)
|
|
#define LOGBIT_ERROR (1 << LOGLEVEL_ERROR)
|
|
#define LOGBIT_DEBUG (1 << LOGLEVEL_DEBUG)
|
|
#define LOGBIT_STATS (1 << LOGLEVEL_STATS)
|
|
#define LOGBIT_OK (1 << LOGLEVEL_OK)
|
|
#define LOGBITS_ERRORS LOGBIT_ERROR
|
|
#define LOGBITS_WARNINGS (LOGBITS_ERRORS | LOGBIT_WARNING)
|
|
#define LOGBITS_INFO (LOGBITS_WARNINGS | LOGBIT_INFO)
|
|
#define LOGBITS_DEBUG (LOGBITS_INFO | LOGBIT_DEBUG)
|
|
#define LOGBITS_STATS (LOGBITS_DEBUG | LOGBIT_STATS)
|
|
#define LOGBITS_OK (LOGBITS_WARNINGS | LOGBIT_OK)
|
|
#define LOGBITS_ALL 0xffffffffu
|
|
#endif
|
|
|
|
// Set/get the default level for calls to nvprintf(). Use LOGLEVEL_*.
|
|
void nvprintSetLevel(int l);
|
|
int nvprintGetLevel();
|
|
|
|
void nvprintSetLogFileName(const char* name) noexcept;
|
|
|
|
// Globally enable/disable all nvprint output and logging
|
|
void nvprintSetLogging(bool b);
|
|
|
|
// Update the bitmask of which levels receive file and stderr output, or
|
|
// trigger breakpoints. `state` controls whether to enable or disable the bits
|
|
// in `mask`. Use LOGBITS_*.
|
|
void nvprintSetFileLogging(bool state, uint32_t mask = ~0);
|
|
void nvprintSetConsoleLogging(bool state, uint32_t mask = ~0);
|
|
void nvprintSetBreakpoints(bool state, uint32_t mask = LOGBITS_ERRORS);
|
|
|
|
// Set a custom print handler. Called in addition to file and console logging.
|
|
using PFN_NVPRINTCALLBACK = std::function<void(int level, const char* msg)>;
|
|
void nvprintSetCallback(PFN_NVPRINTCALLBACK callback);
|
|
|
|
// Printf-style macros and functions.
|
|
#define LOGI(...) \
|
|
{ \
|
|
nvprintfLevel(LOGLEVEL_INFO, __VA_ARGS__); \
|
|
}
|
|
#define LOGW(...) \
|
|
{ \
|
|
nvprintfLevel(LOGLEVEL_WARNING, __VA_ARGS__); \
|
|
}
|
|
#define LOGE(...) \
|
|
{ \
|
|
nvprintfLevel(LOGLEVEL_ERROR, __VA_ARGS__); \
|
|
}
|
|
#define LOGE_FILELINE(...) \
|
|
{ \
|
|
nvprintfLevel(LOGLEVEL_ERROR, __FILE__ "(" S__LINE__ "): **ERROR**:\n" __VA_ARGS__); \
|
|
}
|
|
#ifndef NDEBUG
|
|
#define LOGD(...) \
|
|
{ \
|
|
nvprintfLevel(LOGLEVEL_DEBUG, __FILE__ "(" S__LINE__ "): Debug Info:\n" __VA_ARGS__); \
|
|
}
|
|
#else
|
|
#define LOGD(...)
|
|
#endif
|
|
#define LOGOK(...) \
|
|
{ \
|
|
nvprintfLevel(LOGLEVEL_OK, __VA_ARGS__); \
|
|
}
|
|
#define LOGSTATS(...) \
|
|
{ \
|
|
nvprintfLevel(LOGLEVEL_STATS, __VA_ARGS__); \
|
|
}
|
|
|
|
void nvprintf(
|
|
#ifdef _MSC_VER
|
|
_Printf_format_string_
|
|
#endif
|
|
const char* fmt,
|
|
...) noexcept
|
|
#if defined(__GNUC__) || defined(__clang__)
|
|
__attribute__((format(printf, 1, 2)));
|
|
#endif
|
|
;
|
|
|
|
void nvprintfLevel(int level,
|
|
#ifdef _MSC_VER
|
|
_Printf_format_string_
|
|
#endif
|
|
const char* fmt,
|
|
...) noexcept
|
|
#if defined(__GNUC__) || defined(__clang__)
|
|
__attribute__((format(printf, 2, 3)));
|
|
#endif
|
|
;
|
|
|
|
// std::print-style macros and functions.
|
|
// Use fmt::format's built-in checking if the compiler supports consteval,
|
|
// which cleans up how the macros appear in Intellisense. Otherwise, use
|
|
// FMT_STRING; this will be messier. In either case, the last line of the
|
|
// compiler error will point to the line with the incorrect print specifier.
|
|
#ifdef FMT_HAS_CONSTEVAL
|
|
#define PRINT_CHECK_FMT
|
|
#else
|
|
#define PRINT_CHECK_FMT FMT_STRING
|
|
#endif
|
|
// This macro catches exceptions from fmt::format. This gives us compile-time
|
|
// checking, while still making these functions have the same noexcept
|
|
// semantics as nvprintf.
|
|
#define PRINT_CATCH(lvl, fmtstr, ...) \
|
|
{ \
|
|
try \
|
|
{ \
|
|
nvprintLevel(lvl, fmt::format(PRINT_CHECK_FMT(fmtstr), __VA_ARGS__)); \
|
|
} \
|
|
catch(const std::exception&) \
|
|
{ \
|
|
nvprintLevel(LOGLEVEL_ERROR, "PRINT_CATCH: Could not format string.\n"); \
|
|
} \
|
|
}
|
|
#define PRINTI(fmtstr, ...) PRINT_CATCH(LOGLEVEL_INFO, fmtstr, __VA_ARGS__)
|
|
#define PRINTW(fmtstr, ...) PRINT_CATCH(LOGLEVEL_WARNING, fmtstr, __VA_ARGS__)
|
|
#define PRINTE(fmtstr, ...) PRINT_CATCH(LOGLEVEL_ERROR, fmtstr, __VA_ARGS__)
|
|
#define PRINTE_FILELINE(fmtstr, ...) \
|
|
PRINT_CATCH(LOGLEVEL_ERROR, __FILE__ "(" S__LINE__ "): **ERROR**:\n" fmtstr, __VA_ARGS__)
|
|
#ifndef NDEBUG
|
|
#define PRINTD(fmtstr, ...) PRINT_CATCH(LOGLEVEL_DEBUG, __FILE__ "(" S__LINE__ "): Debug Info:\n" fmtstr, __VA_ARGS__)
|
|
#else
|
|
#define PRINTD(...)
|
|
#endif
|
|
#define PRINTOK(fmtstr, ...) PRINT_CATCH(LOGLEVEL_OK, fmtstr, __VA_ARGS__)
|
|
#define PRINTSTATS(fmtstr, ...) PRINT_CATCH(LOGLEVEL_STATS, fmtstr, __VA_ARGS__)
|
|
|
|
// Directly prints a message at the given level, without formatting.
|
|
void nvprintLevel(int level, const std::string& msg) noexcept;
|
|
void nvprintLevel(int level, const char* msg) noexcept;
|
|
|
|
#endif
|