feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity

NanoTrace: Simplyfy categories and tracer events

Browse Source 
Reduce the template magic. That is creating simpler error messages, too.

Change-Id: I57ed3dbfca9a86bc71ecd1a352143a7a5d937a0c
Reviewed-by: Marco Bubke <marco.bubke@qt.io>
This commit is contained in:
Marco Bubke
2025-06-01 11:35:25 +02:00
parent cc0eda2ecf
commit 41895d9fa7
19 changed files with 436 additions and 358 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
src/libs/nanotrace/nanotracehr.cpp
View File

@@ -45,8 +45,7 @@ unsigned int getUnsignedIntegerHash(std::thread::id id)
return static_cast<unsigned int>(std::hash<std::thread::id>{}(id) & 0xFFFFFFFF);
}
template<std::size_t capacity>
constexpr bool isArgumentValid(const StaticString<capacity> &string)
constexpr bool isArgumentValid(const ArgumentsString &string)
{
return string.isValid() && string.size();
}
@@ -171,7 +170,7 @@ void flushEvents(const Utils::span<TraceEvent> events,
}
}
template NANOTRACE_EXPORT void flushEvents(const Utils::span<StringViewWithStringArgumentsTraceEvent> events,
template NANOTRACE_EXPORT void flushEvents(const Utils::span<TraceEventWithArguments> events,
std::thread::id threadId,
std::shared_ptr<EnabledTraceFile> file);
@@ -226,8 +225,7 @@ void flushInThread(EnabledEventQueue<TraceEvent> &eventQueue)
eventQueue.eventsIndex = 0;
}
template NANOTRACE_EXPORT void flushInThread(
EnabledEventQueue<StringViewWithStringArgumentsTraceEvent> &eventQueue);
template NANOTRACE_EXPORT void flushInThread(EnabledEventQueue<TraceEventWithArguments> &eventQueue);
template NANOTRACE_EXPORT void flushInThread(EnabledEventQueue<TraceEventWithoutArguments> &eventQueue);
template<typename TraceEvent>
@@ -273,8 +271,7 @@ void EventQueue<TraceEvent, Tracing::IsEnabled>::flush()
file.reset();
}
template class NANOTRACE_EXPORT_TEMPLATE
EventQueue<StringViewWithStringArgumentsTraceEvent, Tracing::IsEnabled>;
template class NANOTRACE_EXPORT_TEMPLATE EventQueue<TraceEventWithArguments, Tracing::IsEnabled>;
template class NANOTRACE_EXPORT_TEMPLATE EventQueue<TraceEventWithoutArguments, Tracing::IsEnabled>;
} // namespace NanotraceHR

413
src/libs/nanotrace/nanotracehr.h
View File

@@ -49,7 +49,7 @@ enum class Tracing { IsDisabled, IsEnabled };
# define NO_UNIQUE_ADDRESS
#endif
using ArgumentsString = StaticString<3700>;
using ArgumentsString = StaticString;
namespace Literals {
struct TracerLiteral
@@ -98,9 +98,7 @@ template<std::size_t size, typename Tuple>
concept HasTupleSize = requires { std::tuple_size_v<Tuple> == size; };
template<typename Entry>
concept CanConvert = requires(Entry entry, StaticString<1000> string) {
convertToString(string, entry);
};
concept CanConvert = requires(Entry entry, StaticString string) { convertToString(string, entry); };
namespace Internal {
template<typename Type>
@@ -413,15 +411,11 @@ struct TraceEventWithoutArguments
char type = ' ';
};
template<typename ArgumentsString>
struct alignas(4096) TraceEvent : public TraceEventWithoutArguments
struct alignas(4096) TraceEventWithArguments : public TraceEventWithoutArguments
{
using ArgumentsStringType = ArgumentsString;
ArgumentsString arguments;
};
using StringViewWithStringArgumentsTraceEvent = TraceEvent<ArgumentsString>;
enum class IsEnabled { No, Yes };
@@ -431,12 +425,13 @@ class EventQueue;
template<typename TraceEvent>
using EnabledEventQueue = EventQueue<TraceEvent, Tracing::IsEnabled>;
using EnabledEventQueueWithoutArguments = EventQueue<TraceEventWithoutArguments, Tracing::IsEnabled>;
using EnabledEventQueueWithArguments = EnabledEventQueue<TraceEventWithArguments>;
using EnabledEventQueueWithoutArguments = EnabledEventQueue<TraceEventWithoutArguments>;
template<typename TraceEvent>
void flushInThread(EnabledEventQueue<TraceEvent> &eventQueue);
extern template NANOTRACE_EXPORT void flushInThread(
EnabledEventQueue<StringViewWithStringArgumentsTraceEvent> &eventQueue);
extern template NANOTRACE_EXPORT void flushInThread(EnabledEventQueue<TraceEventWithArguments> &eventQueue);
extern template NANOTRACE_EXPORT void flushInThread(
EnabledEventQueue<TraceEventWithoutArguments> &eventQueue);
@@ -598,13 +593,12 @@ public:
};
template<Tracing isEnabled>
using StringViewWithStringArgumentsEventQueue = EventQueue<StringViewWithStringArgumentsTraceEvent, isEnabled>;
using EventQueueWithArguments = EventQueue<TraceEventWithArguments, isEnabled>;
template<Tracing isEnabled>
using EventQueueWithoutArguments = EventQueue<TraceEventWithoutArguments, isEnabled>;
using EnabledEventQueueWithoutArguments = EventQueueWithoutArguments<Tracing::IsEnabled>;
extern template class NANOTRACE_EXPORT_EXTERN_TEMPLATE
EventQueue<StringViewWithStringArgumentsTraceEvent, Tracing::IsEnabled>;
extern template class NANOTRACE_EXPORT_EXTERN_TEMPLATE EventQueue<TraceEventWithArguments, Tracing::IsEnabled>;
extern template class NANOTRACE_EXPORT_EXTERN_TEMPLATE
EventQueue<TraceEventWithoutArguments, Tracing::IsEnabled>;
@@ -656,7 +650,171 @@ public:
};
template<typename Category, typename IsActive>
class Tracer;
class Tracer
{
public:
Tracer() = default;
using TokenType = typename Category::TokenType;
using FlowTokenType = typename Category::FlowTokenType;
friend TokenType;
friend FlowTokenType;
friend Category;
[[nodiscard]] Tracer(TracerLiteral, const Category &, KeyValue auto &&...) {}
Tracer(const Tracer &) = delete;
Tracer &operator=(const Tracer &) = delete;
Tracer(Tracer &&other) noexcept = default;
Tracer &operator=(Tracer &&other) noexcept = delete;
TokenType createToken() { return {}; }
Tracer beginDuration(TracerLiteral, KeyValue auto &&...) { return {}; }
void tick(TracerLiteral, KeyValue auto &&...) {}
void end(KeyValue auto &&...) {}
~Tracer() {}
};
template<typename Category>
class Tracer<Category, std::true_type>
{
using TokenType = typename Category::TokenType;
using FlowTokenType = typename Category::FlowTokenType;
using PrivateTag = typename Category::PrivateTag;
using CategoryFunctionPointer = typename Category::CategoryFunctionPointer;
friend FlowTokenType;
friend TokenType;
friend Category;
template<KeyValue... Arguments>
[[nodiscard]] Tracer(std::size_t bindId,
IsFlow flow,
TracerLiteral name,
CategoryFunctionPointer category,
Arguments &&...arguments)
: m_name{name}
, m_bindId{bindId}
, flow{flow}
, m_category{category}
{
if (category().isEnabled == IsEnabled::Yes)
sendBeginTrace(std::forward<Arguments>(arguments)...);
}
public:
template<KeyValue... Arguments>
[[nodiscard]] Tracer(PrivateTag,
std::size_t bindId,
IsFlow flow,
TracerLiteral name,
CategoryFunctionPointer category,
Arguments &&...arguments)
: Tracer{bindId, flow, std::move(name), category, std::forward<Arguments>(arguments)...}
{}
template<KeyValue... Arguments>
[[nodiscard]] Tracer(TracerLiteral name, CategoryFunctionPointer category, Arguments &&...arguments)
: m_name{name}
, m_category{category}
{
if (category().isEnabled == IsEnabled::Yes)
sendBeginTrace(std::forward<Arguments>(arguments)...);
}
template<KeyValue... Arguments>
[[nodiscard]] Tracer(TracerLiteral name, Category &category, Arguments &&...arguments)
: Tracer(std::move(name), category.self(), std::forward<Arguments>(arguments)...)
{}
Tracer(const Tracer &) = delete;
Tracer &operator=(const Tracer &) = delete;
Tracer(Tracer &&other) noexcept = delete;
Tracer &operator=(Tracer &&other) noexcept = delete;
TokenType createToken() { return {0, m_category}; }
~Tracer() { sendEndTrace(); }
template<KeyValue... Arguments>
Tracer beginDuration(TracerLiteral name, Arguments &&...arguments)
{
return {std::move(name), m_category, std::forward<Arguments>(arguments)...};
}
template<KeyValue... Arguments>
void tick(TracerLiteral name, Arguments &&...arguments)
{
m_category().begin('i', 0, name, 0, IsFlow::No, std::forward<Arguments>(arguments)...);
}
template<KeyValue... Arguments>
void end(Arguments &&...arguments)
{
sendEndTrace(std::forward<Arguments>(arguments)...);
m_name = {};
}
private:
template<KeyValue... Arguments>
void sendBeginTrace(Arguments &&...arguments)
{
auto &category = m_category();
if (category.isEnabled == IsEnabled::Yes) {
auto &traceEvent = getTraceEvent(category.eventQueue(arguments...));
traceEvent.name = m_name;
traceEvent.category = category.name();
traceEvent.bindId = m_bindId;
traceEvent.flow = flow;
traceEvent.type = 'B';
if constexpr (sizeof...(arguments)) {
Internal::setArguments<ArgumentsString>(traceEvent.arguments,
std::forward<Arguments>(arguments)...);
}
traceEvent.time = Clock::now();
}
}
template<KeyValue... Arguments>
void sendEndTrace(Arguments &&...arguments)
{
if (m_name.size()) {
auto &category = m_category();
if (category.isEnabled == IsEnabled::Yes) {
auto end = Clock::now();
auto &traceEvent = getTraceEvent(category.eventQueue(arguments...));
traceEvent.name = std::move(m_name);
traceEvent.category = category.name();
traceEvent.time = end;
traceEvent.bindId = m_bindId;
traceEvent.flow = flow;
traceEvent.type = 'E';
if constexpr (sizeof...(arguments)) {
Internal::setArguments<ArgumentsString>(traceEvent.arguments,
std::forward<Arguments>(arguments)...);
}
}
}
}
private:
std::string_view m_name;
std::size_t m_bindId = 0;
IsFlow flow = IsFlow::No;
CategoryFunctionPointer m_category;
};
template<typename Category, KeyValue... Arguments>
Tracer(TracerLiteral name, Category &category, Arguments &&...)
-> Tracer<Category, typename Category::IsActive>;
template<typename Category, KeyValue... Arguments>
Tracer(TracerLiteral name, const Category &category, Arguments &&...)
-> Tracer<Category, typename Category::IsActive>;
template<typename Category, Tracing isEnabled>
class Token : public BasicDisabledToken
@@ -1130,8 +1288,7 @@ private:
CategoryFunctionPointer m_category = nullptr;
};
template<typename TraceEvent, Tracing isEnabled>
class Category
class DisabledCategory
{
public:
class SourceLocation
@@ -1143,21 +1300,22 @@ public:
};
using IsActive = std::false_type;
using ArgumentsStringType = typename TraceEvent::ArgumentsStringType;
using AsynchronousTokenType = AsynchronousToken<Category, Tracing::IsDisabled>;
using FlowTokenType = FlowToken<Category, Tracing::IsDisabled>;
using TracerType = Tracer<Category, std::false_type>;
using TokenType = Token<Category, Tracing::IsDisabled>;
using CategoryFunctionPointer = Category &(*) ();
using AsynchronousTokenType = AsynchronousToken<DisabledCategory, Tracing::IsDisabled>;
using FlowTokenType = FlowToken<DisabledCategory, Tracing::IsDisabled>;
using TracerType = Tracer<DisabledCategory, std::false_type>;
using TokenType = Token<DisabledCategory, Tracing::IsDisabled>;
using CategoryFunctionPointer = DisabledCategory &(*) ();
Category(TracerLiteral,
EventQueue<TraceEvent, Tracing::IsDisabled> &,
DisabledCategory() = default;
DisabledCategory(TracerLiteral,
EventQueueWithArguments<Tracing::IsDisabled> &,
EventQueueWithoutArguments<Tracing::IsDisabled> &,
CategoryFunctionPointer)
{}
Category(TracerLiteral,
EventQueue<TraceEvent, Tracing::IsEnabled> &,
DisabledCategory(TracerLiteral,
EventQueueWithArguments<Tracing::IsEnabled> &,
EventQueueWithoutArguments<Tracing::IsEnabled> &,
CategoryFunctionPointer)
{}
@@ -1171,7 +1329,9 @@ public:
template<typename... Arguments>
[[nodiscard]] std::pair<AsynchronousTokenType, FlowTokenType> beginAsynchronousWithFlow(
TracerLiteral, Arguments &&...)
{}
{
return {};
}
template<typename... Arguments>
[[nodiscard]] TracerType beginDuration(TracerLiteral, Arguments &&...)
@@ -1193,8 +1353,7 @@ public:
static constexpr bool isActive() { return false; }
};
template<typename TraceEvent>
class Category<TraceEvent, Tracing::IsEnabled>
class EnabledCategory
{
class PrivateTag
{};
@@ -1233,12 +1392,11 @@ public:
};
using IsActive = std::true_type;
using ArgumentsStringType = typename TraceEvent::ArgumentsStringType;
using AsynchronousTokenType = AsynchronousToken<Category, Tracing::IsEnabled>;
using FlowTokenType = FlowToken<Category, Tracing::IsEnabled>;
using TracerType = Tracer<Category, std::true_type>;
using TokenType = Token<Category, Tracing::IsEnabled>;
using CategoryFunctionPointer = Category &(*) ();
using AsynchronousTokenType = AsynchronousToken<EnabledCategory, Tracing::IsEnabled>;
using FlowTokenType = FlowToken<EnabledCategory, Tracing::IsEnabled>;
using TracerType = Tracer<EnabledCategory, std::true_type>;
using TokenType = Token<EnabledCategory, Tracing::IsEnabled>;
using CategoryFunctionPointer = EnabledCategory &(*) ();
friend AsynchronousTokenType;
friend TokenType;
@@ -1246,7 +1404,7 @@ public:
friend TracerType;
template<typename EventQueue>
Category(TracerLiteral name,
EnabledCategory(TracerLiteral name,
EventQueue &queue,
EnabledEventQueueWithoutArguments &eventQueueWithoutArguments,
CategoryFunctionPointer self)
@@ -1261,8 +1419,8 @@ public:
m_bindIdCounter = m_globalBindIdCounter += 1ULL << 32;
}
Category(const Category &) = delete;
Category &operator=(const Category &) = delete;
EnabledCategory(const EnabledCategory &) = delete;
EnabledCategory &operator=(const EnabledCategory &) = delete;
template<typename... Arguments>
[[nodiscard]] AsynchronousTokenType beginAsynchronous(TracerLiteral traceName,
@@ -1292,7 +1450,7 @@ public:
template<typename... Arguments>
[[nodiscard]] TracerType beginDuration(TracerLiteral traceName, Arguments &&...arguments)
{
return {traceName, m_self, std::forward<Arguments>(arguments)...};
return TracerType{traceName, m_self, std::forward<Arguments>(arguments)...};
}
template<typename... Arguments>
@@ -1333,7 +1491,7 @@ public:
EnabledEventQueueWithoutArguments &eventQueue() const { return m_eventQueueWithoutArguments; }
template<typename Arguments>
EnabledEventQueue<TraceEvent> &eventQueue(const Arguments &...) const
EnabledEventQueueWithArguments &eventQueue(const Arguments &...) const
{
return m_eventQueue;
}
@@ -1425,7 +1583,7 @@ private:
private:
std::string_view m_name;
EnabledEventQueue<TraceEvent> &m_eventQueue;
EnabledEventQueueWithArguments &m_eventQueue;
EnabledEventQueueWithoutArguments &m_eventQueueWithoutArguments;
inline static std::atomic<std::size_t> m_globalIdCounter;
std::size_t m_idCounter;
@@ -1434,171 +1592,4 @@ private:
CategoryFunctionPointer m_self;
};
template<Tracing isEnabled>
using StringViewWithStringArgumentsCategory = Category<StringViewWithStringArgumentsTraceEvent, isEnabled>;
template<typename Category, typename IsActive>
class Tracer
{
public:
Tracer() = default;
using TokenType = typename Category::TokenType;
using FlowTokenType = typename Category::FlowTokenType;
friend TokenType;
friend FlowTokenType;
friend Category;
[[nodiscard]] Tracer(TracerLiteral, Category &, KeyValue auto &&...) {}
Tracer(const Tracer &) = delete;
Tracer &operator=(const Tracer &) = delete;
Tracer(Tracer &&other) noexcept = default;
Tracer &operator=(Tracer &&other) noexcept = delete;
TokenType createToken() { return {}; }
Tracer beginDuration(TracerLiteral, KeyValue auto &&...) { return {}; }
void tick(TracerLiteral, KeyValue auto &&...) {}
void end(KeyValue auto &&...) {}
~Tracer() {}
};
template<typename Category>
class Tracer<Category, std::true_type>
{
using ArgumentsStringType = typename Category::ArgumentsStringType;
using TokenType = typename Category::TokenType;
using FlowTokenType = typename Category::FlowTokenType;
using PrivateTag = typename Category::PrivateTag;
using CategoryFunctionPointer = typename Category::CategoryFunctionPointer;
friend FlowTokenType;
friend TokenType;
friend Category;
template<KeyValue... Arguments>
[[nodiscard]] Tracer(std::size_t bindId,
IsFlow flow,
TracerLiteral name,
CategoryFunctionPointer category,
Arguments &&...arguments)
: m_name{name}
, m_bindId{bindId}
, flow{flow}
, m_category{category}
{
if (category().isEnabled == IsEnabled::Yes)
sendBeginTrace(std::forward<Arguments>(arguments)...);
}
public:
template<KeyValue... Arguments>
[[nodiscard]] Tracer(PrivateTag,
std::size_t bindId,
IsFlow flow,
TracerLiteral name,
CategoryFunctionPointer category,
Arguments &&...arguments)
: Tracer{bindId, flow, std::move(name), category, std::forward<Arguments>(arguments)...}
{}
template<KeyValue... Arguments>
[[nodiscard]] Tracer(TracerLiteral name, CategoryFunctionPointer category, Arguments &&...arguments)
: m_name{name}
, m_category{category}
{
if (category().isEnabled == IsEnabled::Yes)
sendBeginTrace(std::forward<Arguments>(arguments)...);
}
template<KeyValue... Arguments>
[[nodiscard]] Tracer(TracerLiteral name, Category &category, Arguments &&...arguments)
: Tracer(std::move(name), category.self(), std::forward<Arguments>(arguments)...)
{}
Tracer(const Tracer &) = delete;
Tracer &operator=(const Tracer &) = delete;
Tracer(Tracer &&other) noexcept = delete;
Tracer &operator=(Tracer &&other) noexcept = delete;
TokenType createToken() { return {0, m_category}; }
~Tracer() { sendEndTrace(); }
template<KeyValue... Arguments>
Tracer beginDuration(TracerLiteral name, Arguments &&...arguments)
{
return {std::move(name), m_category, std::forward<Arguments>(arguments)...};
}
template<KeyValue... Arguments>
void tick(TracerLiteral name, Arguments &&...arguments)
{
m_category().begin('i', 0, name, 0, IsFlow::No, std::forward<Arguments>(arguments)...);
}
template<KeyValue... Arguments>
void end(Arguments &&...arguments)
{
sendEndTrace(std::forward<Arguments>(arguments)...);
m_name = {};
}
private:
template<KeyValue... Arguments>
void sendBeginTrace(Arguments &&...arguments)
{
auto &category = m_category();
if (category.isEnabled == IsEnabled::Yes) {
auto &traceEvent = getTraceEvent(category.eventQueue(arguments...));
traceEvent.name = m_name;
traceEvent.category = category.name();
traceEvent.bindId = m_bindId;
traceEvent.flow = flow;
traceEvent.type = 'B';
if constexpr (sizeof...(arguments)) {
Internal::setArguments<ArgumentsStringType>(traceEvent.arguments,
std::forward<Arguments>(arguments)...);
}
traceEvent.time = Clock::now();
}
}
template<KeyValue... Arguments>
void sendEndTrace(Arguments &&...arguments)
{
if (m_name.size()) {
auto &category = m_category();
if (category.isEnabled == IsEnabled::Yes) {
auto end = Clock::now();
auto &traceEvent = getTraceEvent(category.eventQueue(arguments...));
traceEvent.name = std::move(m_name);
traceEvent.category = category.name();
traceEvent.time = end;
traceEvent.bindId = m_bindId;
traceEvent.flow = flow;
traceEvent.type = 'E';
if constexpr (sizeof...(arguments)) {
Internal::setArguments<ArgumentsStringType>(traceEvent.arguments,
std::forward<Arguments>(arguments)...);
}
}
}
}
private:
std::string_view m_name;
std::size_t m_bindId = 0;
IsFlow flow = IsFlow::No;
CategoryFunctionPointer m_category;
};
template<typename Category, KeyValue... Arguments>
Tracer(TracerLiteral name, Category &category, Arguments &&...)
-> Tracer<Category, typename Category::IsActive>;
} // namespace NanotraceHR

14
src/libs/nanotrace/staticstring.h
View File

@@ -11,7 +11,6 @@
namespace NanotraceHR {
template<std::size_t Capacity>
class StaticString
{
public:
@@ -27,13 +26,13 @@ public:
{
auto newSize = m_size + string.size();
if (newSize <= Capacity) {
if (newSize <= capacity) {
std::char_traits<char>::copy(std::next(data(), static_cast<std::ptrdiff_t>(m_size)),
string.data(),
string.size());
m_size = newSize;
} else {
m_size = Capacity + 1;
m_size = capacity + 1;
}
}
@@ -41,13 +40,13 @@ public:
{
auto newSize = m_size + 1;
if (newSize <= Capacity) {
if (newSize <= capacity) {
auto current = std::next(data(), static_cast<std::ptrdiff_t>(m_size));
*current = character;
m_size = newSize;
} else {
m_size = Capacity + 1;
m_size = capacity + 1;
}
}
@@ -103,7 +102,7 @@ public:
return *this;
}
bool isValid() const { return m_size <= Capacity; }
constexpr bool isValid() const { return m_size <= capacity; }
std::size_t size() const { return m_size; }
@@ -115,7 +114,8 @@ public:
void clear() { m_size = 0; }
private:
std::array<char, Capacity> m_data;
inline static constexpr std::size_t capacity = 3700;
std::array<char, capacity> m_data;
std::size_t m_size = 0;
};

20
src/libs/sqlite/sqlitetracing.cpp
View File

@@ -5,6 +5,8 @@
namespace Sqlite {
#ifdef ENABLE_SQLITE_TRACING
std::shared_ptr<TraceFile> traceFile()
{
static auto traceFile = std::make_shared<TraceFile>("tracing.json");
@@ -14,27 +16,23 @@ std::shared_ptr<TraceFile> traceFile()
namespace {
thread_local NanotraceHR::StringViewWithStringArgumentsEventQueue<sqliteTracingStatus()> eventQueue(
traceFile());
thread_local NanotraceHR::EventQueueWithoutArguments<sqliteTracingStatus()> eventQueueWithoutArguments(
traceFile());
thread_local NanotraceHR::EnabledEventQueueWithoutArguments eventQueue(traceFile());
thread_local NanotraceHR::EnabledEventQueueWithoutArguments eventQueueWithoutArguments(traceFile());
} // namespace
NanotraceHR::StringViewWithStringArgumentsCategory<sqliteTracingStatus()> &sqliteLowLevelCategory()
NanotraceHR::EnabledCategory &sqliteLowLevelCategory()
{
thread_local NanotraceHR::StringViewWithStringArgumentsCategory<sqliteTracingStatus()>
sqliteLowLevelCategory_{"sqlite low level",
thread_local NanotraceHR::EnabledCategory sqliteLowLevelCategory_{"sqlite low level",
eventQueue,
eventQueueWithoutArguments,
sqliteLowLevelCategory};
return sqliteLowLevelCategory_;
}
NanotraceHR::StringViewWithStringArgumentsCategory<sqliteTracingStatus()> &sqliteHighLevelCategory()
NanotraceHR::EnabledCategory &sqliteHighLevelCategory()
{
thread_local NanotraceHR::StringViewWithStringArgumentsCategory<sqliteTracingStatus()>
sqliteHighLevelCategory_{"sqlite high level",
thread_local NanotraceHR::EnabledCategory sqliteHighLevelCategory_{"sqlite high level",
eventQueue,
eventQueueWithoutArguments,
sqliteHighLevelCategory};
@@ -42,4 +40,6 @@ NanotraceHR::StringViewWithStringArgumentsCategory<sqliteTracingStatus()> &sqlit
return sqliteHighLevelCategory_;
}
#endif
} // namespace Sqlite

29
src/libs/sqlite/sqlitetracing.h
View File

@@ -10,22 +10,25 @@
namespace Sqlite {
using namespace NanotraceHR::Literals;
constexpr NanotraceHR::Tracing sqliteTracingStatus()
{
#ifdef ENABLE_SQLITE_TRACING
return NanotraceHR::Tracing::IsEnabled;
using TraceFile = NanotraceHR::EnabledTraceFile;
SQLITE_EXPORT std::shared_ptr<NanotraceHR::EnabledTraceFile> traceFile();
NanotraceHR::EnabledCategory &sqliteLowLevelCategory();
SQLITE_EXPORT NanotraceHR::EnabledCategory &sqliteHighLevelCategory();
#else
return NanotraceHR::Tracing::IsDisabled;
#endif
inline NanotraceHR::DisabledCategory sqliteLowLevelCategory()
{
return {};
}
using TraceFile = NanotraceHR::TraceFile<sqliteTracingStatus()>;
SQLITE_EXPORT std::shared_ptr<TraceFile> traceFile();
NanotraceHR::StringViewWithStringArgumentsCategory<sqliteTracingStatus()> &sqliteLowLevelCategory();
SQLITE_EXPORT NanotraceHR::StringViewWithStringArgumentsCategory<sqliteTracingStatus()> &
sqliteHighLevelCategory();
inline NanotraceHR::DisabledCategory sqliteHighLevelCategory()
{
return {};
}
#endif
} // namespace Sqlite

7
src/plugins/qmldesigner/components/formeditor/formeditortracing.cpp
View File

@@ -9,9 +9,12 @@
namespace QmlDesigner::FormEditorTracing {
using namespace NanotraceHR::Literals;
#ifdef ENABLE_FORM_EDITOR_TRACING
namespace {
thread_local Category category_{"model",
thread_local Category category_{"form editor",
Tracing::eventQueueWithStringArguments(),
Tracing::eventQueueWithoutArguments(),
category};
@@ -23,4 +26,6 @@ Category &category()
return category_;
}
#endif
} // namespace QmlDesigner::FormEditorTracing

20
src/plugins/qmldesigner/components/formeditor/formeditortracing.h
View File

@@ -9,18 +9,22 @@
namespace QmlDesigner::FormEditorTracing {
constexpr NanotraceHR::Tracing tracingStatus()
{
#ifdef ENABLE_FORM_EDITOR_TRACING
return NanotraceHR::Tracing::IsEnabled;
#else
return NanotraceHR::Tracing::IsDisabled;
#endif
}
using Category = NanotraceHR::StringViewWithStringArgumentsCategory<tracingStatus()>;
using Category = NanotraceHR::EnabledCategory;
using SourceLocation = Category::SourceLocation;
[[gnu::pure]] QMLDESIGNERCOMPONENTS_EXPORT Category &category();
#else
using Category = NanotraceHR::DisabledCategory;
using SourceLocation = Category::SourceLocation;
inline Category category()
{
return {};
}
#endif
} // namespace QmlDesigner::FormEditorTracing

7
src/plugins/qmldesigner/components/itemlibrary/itemlibrarytracing.cpp
View File

@@ -9,9 +9,12 @@
namespace QmlDesigner::ItemLibraryTracing {
using namespace NanotraceHR::Literals;
#ifdef ENABLE_ITEM_LIBRARY_TRACING
namespace {
thread_local Category category_{"model",
thread_local Category category_{"item library",
Tracing::eventQueueWithStringArguments(),
Tracing::eventQueueWithoutArguments(),
category};
@@ -23,4 +26,6 @@ Category &category()
return category_;
}
#endif
} // namespace QmlDesigner::ItemLibraryTracing

21
src/plugins/qmldesigner/components/itemlibrary/itemlibrarytracing.h
View File

@@ -9,18 +9,23 @@
namespace QmlDesigner::ItemLibraryTracing {
constexpr NanotraceHR::Tracing tracingStatus()
{
#ifdef ENABLE_ITEM_LIBRARY_TRACING
return NanotraceHR::Tracing::IsEnabled;
#else
return NanotraceHR::Tracing::IsDisabled;
#endif
}
using Category = NanotraceHR::StringViewWithStringArgumentsCategory<tracingStatus()>;
using Category = NanotraceHR::EnabledCategory;
using SourceLocation = Category::SourceLocation;
[[gnu::pure]] QMLDESIGNERCOMPONENTS_EXPORT Category &category();
#else
using Category = NanotraceHR::DisabledCategory;
using SourceLocation = Category::SourceLocation;
inline Category category()
{
return {};
}
#endif
} // namespace QmlDesigner::ItemLibraryTracing

7
src/plugins/qmldesigner/components/navigator/navigatortracing.cpp
View File

@@ -9,9 +9,12 @@
namespace QmlDesigner::NavigatorTracing {
using namespace NanotraceHR::Literals;
#ifdef ENABLE_NAVIGATOR_TRACING
namespace {
thread_local Category category_{"model",
thread_local Category category_{"navigator",
Tracing::eventQueueWithStringArguments(),
Tracing::eventQueueWithoutArguments(),
category};
@@ -23,4 +26,6 @@ Category &category()
return category_;
}
#endif
} // namespace QmlDesigner::NavigatorTracing

21
src/plugins/qmldesigner/components/navigator/navigatortracing.h
View File

@@ -9,18 +9,23 @@
namespace QmlDesigner::NavigatorTracing {
constexpr NanotraceHR::Tracing tracingStatus()
{
#ifdef ENABLE_NAVIGATOR_TRACING
return NanotraceHR::Tracing::IsEnabled;
#else
return NanotraceHR::Tracing::IsDisabled;
#endif
}
using Category = NanotraceHR::StringViewWithStringArgumentsCategory<tracingStatus()>;
using Category = NanotraceHR::EnabledCategory;
using SourceLocation = Category::SourceLocation;
[[gnu::pure]] QMLDESIGNERCOMPONENTS_EXPORT Category &category();
#else
using Category = NanotraceHR::DisabledCategory;
using SourceLocation = Category::SourceLocation;
inline Category category()
{
return {};
}
#endif
} // namespace QmlDesigner::NavigatorTracing

7
src/plugins/qmldesigner/components/propertyeditor/propertyeditortracing.cpp
View File

@@ -9,9 +9,12 @@
namespace QmlDesigner::PropertyEditorTracing {
using namespace NanotraceHR::Literals;
#ifdef ENABLE_PROPERTY_EDITOR_TRACING
namespace {
thread_local Category category_{"model",
thread_local Category category_{"property editor",
Tracing::eventQueueWithStringArguments(),
Tracing::eventQueueWithoutArguments(),
category};
@@ -23,4 +26,6 @@ Category &category()
return category_;
}
#endif
} // namespace QmlDesigner::PropertyEditorTracing

21
src/plugins/qmldesigner/components/propertyeditor/propertyeditortracing.h
View File

@@ -9,18 +9,23 @@
namespace QmlDesigner::PropertyEditorTracing {
constexpr NanotraceHR::Tracing tracingStatus()
{
#ifdef ENABLE_PROPERTY_EDITOR_TRACING
return NanotraceHR::Tracing::IsEnabled;
#else
return NanotraceHR::Tracing::IsDisabled;
#endif
}
using Category = NanotraceHR::StringViewWithStringArgumentsCategory<tracingStatus()>;
using Category = NanotraceHR::EnabledCategory;
using SourceLocation = Category::SourceLocation;
[[gnu::pure]] QMLDESIGNERCOMPONENTS_EXPORT Category &category();
#else
using Category = NanotraceHR::DisabledCategory;
using SourceLocation = Category::SourceLocation;
inline Category category()
{
return {};
};
#endif
} // namespace QmlDesigner::PropertyEditorTracing

6
src/plugins/qmldesigner/libs/designercore/imagecache/asynchronousimagecache.cpp
View File

@@ -18,6 +18,9 @@ namespace QmlDesigner {
using namespace NanotraceHR::Literals;
namespace ImageCache {
#ifdef ENABLE_IMAGE_CACHE_TRACING
namespace {
thread_local Category category_{"image cache",
@@ -30,6 +33,9 @@ Category &category()
{
return category_;
}
#endif
} // namespace ImageCache
AsynchronousImageCache::AsynchronousImageCache(ImageCacheStorageInterface &storage,

25
src/plugins/qmldesigner/libs/designercore/include/imagecacheauxiliarydata.h
View File

@@ -17,20 +17,27 @@ namespace QmlDesigner {
namespace ImageCache {
constexpr NanotraceHR::Tracing tracingStatus()
{
#ifdef ENABLE_IMAGE_CACHE_TRACING
return NanotraceHR::Tracing::IsEnabled;
#else
return NanotraceHR::Tracing::IsDisabled;
#endif
}
using Category = NanotraceHR::StringViewWithStringArgumentsCategory<tracingStatus()>;
using Category = NanotraceHR::EnabledCategory;
using TraceToken = Category::FlowTokenType;
using FlowToken = Category::FlowTokenType;
using Token = Category::TokenType;
extern Category &category();
[[gnu::pure]] QMLDESIGNERCORE_EXPORT Category &category();
#else
using Category = NanotraceHR::DisabledCategory;
using TraceToken = Category::FlowTokenType;
using FlowToken = Category::FlowTokenType;
using Token = Category::TokenType;
inline Category category()
{
return {};
}
#endif
class FontCollectorSizeAuxiliaryData
{

7
src/plugins/qmldesigner/libs/designercore/projectstorage/projectstorageexceptions.cpp
View File

@@ -11,10 +11,9 @@ using namespace NanotraceHR::Literals;
using NanotraceHR::keyValue;
namespace {
auto &category()
{
return ProjectStorageTracing::projectStorageCategory();
}
auto category = ProjectStorageTracing::projectStorageCategory;
} // namespace
TypeHasInvalidSourceId::TypeHasInvalidSourceId(const Sqlite::source_location &location)

35
src/plugins/qmldesigner/libs/designercore/tracing/qmldesignertracing.cpp
View File

@@ -9,34 +9,35 @@ namespace QmlDesigner {
using namespace NanotraceHR::Literals;
#ifdef ENABLE_QMLDESIGNER_TRACING
namespace Tracing {
namespace {
using TraceFile = NanotraceHR::TraceFile<tracingStatus()>;
using TraceFile = NanotraceHR::EnabledTraceFile;
auto traceFile()
{
if constexpr (std::is_same_v<Sqlite::TraceFile, TraceFile>) {
# ifdef ENABLE_SQLITE_TRACING
return Sqlite::traceFile();
} else {
# else
static auto traceFile = std::make_shared<TraceFile>("tracing.json");
return traceFile;
}
# endif
}
} // namespace
EventQueueWithStringArguments &eventQueueWithStringArguments()
{
thread_local NanotraceHR::StringViewWithStringArgumentsEventQueue<tracingStatus()> eventQueue(
traceFile());
thread_local NanotraceHR::EnabledEventQueueWithArguments eventQueue(traceFile());
return eventQueue;
}
EventQueueWithoutArguments &eventQueueWithoutArguments()
{
thread_local NanotraceHR::EventQueueWithoutArguments<tracingStatus()> eventQueue(traceFile());
thread_local NanotraceHR::EnabledEventQueueWithoutArguments eventQueue(traceFile());
return eventQueue;
}
@@ -44,6 +45,9 @@ EventQueueWithoutArguments &eventQueueWithoutArguments()
} // namespace Tracing
namespace ModelTracing {
# ifdef ENABLE_MODEL_TRACING
namespace {
thread_local Category category_{"model",
@@ -58,10 +62,14 @@ Category &category()
return category_;
}
# endif
} // namespace ModelTracing
namespace ProjectStorageTracing {
# ifdef ENABLE_PROJECT_STORAGE_TRACING
Category &projectStorageCategory()
{
thread_local Category category{"project storage",
@@ -82,17 +90,28 @@ Category &projectStorageUpdaterCategory()
return category;
}
# endif
} // namespace ProjectStorageTracing
namespace SourcePathStorageTracing {
# ifdef ENABLE_SOURCE_PATH_STORAGE_TRACING
Category &category()
{
thread_local Category category_{"project storage updater",
thread_local Category category_{"source path storage",
Tracing::eventQueueWithStringArguments(),
Tracing::eventQueueWithoutArguments(),
category};
return category_;
}
# endif
} // namespace SourcePathStorageTracing
#endif
} // namespace QmlDesigner

89
src/plugins/qmldesigner/libs/designercore/tracing/qmldesignertracing.h
View File

@@ -10,70 +10,87 @@
namespace QmlDesigner {
namespace Tracing {
constexpr NanotraceHR::Tracing tracingStatus()
{
#ifdef ENABLE_QMLDESIGNER_TRACING
return NanotraceHR::Tracing::IsEnabled;
#else
return NanotraceHR::Tracing::IsDisabled;
#endif
}
using EventQueueWithStringArguments = NanotraceHR::StringViewWithStringArgumentsEventQueue<tracingStatus()>;
using EventQueueWithoutArguments = NanotraceHR::EventQueueWithoutArguments<tracingStatus()>;
using EventQueueWithStringArguments = NanotraceHR::EnabledEventQueueWithArguments;
using EventQueueWithoutArguments = NanotraceHR::EnabledEventQueueWithoutArguments;
[[gnu::pure]] QMLDESIGNERCORE_EXPORT EventQueueWithStringArguments &eventQueueWithStringArguments();
[[gnu::pure]] QMLDESIGNERCORE_EXPORT EventQueueWithoutArguments &eventQueueWithoutArguments();
#endif
} // namespace Tracing
namespace ModelTracing {
constexpr NanotraceHR::Tracing tracingStatus()
{
#ifdef ENABLE_MODEL_TRACING
return NanotraceHR::Tracing::IsEnabled;
#else
return NanotraceHR::Tracing::IsDisabled;
#endif
}
using Category = NanotraceHR::StringViewWithStringArgumentsCategory<tracingStatus()>;
#ifdef ENABLE_MODEL_TRACING
using Category = NanotraceHR::EnabledCategory;
using SourceLocation = Category::SourceLocation;
using AsynchronousToken = Category::AsynchronousTokenType;
[[gnu::pure]] QMLDESIGNERCORE_EXPORT Category &category();
#else
using Category = NanotraceHR::DisabledCategory;
using SourceLocation = Category::SourceLocation;
using AsynchronousToken = Category::AsynchronousTokenType;
inline Category category()
{
return {};
};
#endif
} // namespace ModelTracing
namespace ProjectStorageTracing {
constexpr NanotraceHR::Tracing projectStorageTracingStatus()
{
#ifdef ENABLE_PROJECT_STORAGE_TRACING
return NanotraceHR::Tracing::IsEnabled;
#else
return NanotraceHR::Tracing::IsDisabled;
#endif
}
using Category = NanotraceHR::StringViewWithStringArgumentsCategory<projectStorageTracingStatus()>;
#ifdef ENABLE_PROJECT_STORAGE_TRACING
using Category = NanotraceHR::EnabledCategory;
[[gnu::pure]] Category &projectStorageCategory();
[[gnu::pure]] Category &projectStorageUpdaterCategory();
#else
using Category = NanotraceHR::DisabledCategory;
inline Category projectStorageCategory()
{
return {};
}
inline Category projectStorageUpdaterCategory()
{
return {};
}
#endif
} // namespace ProjectStorageTracing
namespace SourcePathStorageTracing {
constexpr NanotraceHR::Tracing tracingStatus()
{
#ifdef ENABLE_SOURCE_PATH_STORAGE_TRACING
return NanotraceHR::Tracing::IsEnabled;
#else
return NanotraceHR::Tracing::IsDisabled;
#endif
}
using Category = NanotraceHR::StringViewWithStringArgumentsCategory<tracingStatus()>;
#ifdef ENABLE_SOURCE_PATH_STORAGE_TRACING
using Category = NanotraceHR::EnabledCategory;
[[gnu::pure]] Category &category();
#else
using Category = NanotraceHR::DisabledCategory;
inline Category category()
{
return {};
}
#endif
} // namespace SourcePathStorageTracing
} // namespace QmlDesigner

2
tests/unit/tests/unittests/imagecache/taskqueue-test.cpp
View File

@@ -26,7 +26,7 @@ auto IsTask(Matcher matcher)
class TaskQueue : public testing::Test
{
using Category = NanotraceHR::StringViewWithStringArgumentsCategory<NanotraceHR::Tracing::IsDisabled>;
using Category = NanotraceHR::DisabledCategory;
protected:
Notification notification;