aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/libs/nanotrace/nanotracehr.cpp22
-rw-r--r--src/libs/nanotrace/nanotracehr.h142
-rw-r--r--src/libs/sqlite/sqlitebasestatement.cpp19
-rw-r--r--src/libs/sqlite/sqlitebasestatement.h10
-rw-r--r--src/plugins/qmldesigner/designercore/projectstorage/projectstorage.cpp10
-rw-r--r--src/plugins/qmldesigner/designercore/projectstorage/projectstorage.h9
6 files changed, 137 insertions, 75 deletions
diff --git a/src/libs/nanotrace/nanotracehr.cpp b/src/libs/nanotrace/nanotracehr.cpp
index bd67ae14ea..7ed3a796dd 100644
--- a/src/libs/nanotrace/nanotracehr.cpp
+++ b/src/libs/nanotrace/nanotracehr.cpp
@@ -28,7 +28,7 @@ void printEvent(std::ostream &out, const TraceEvent &event, qint64 processId, st
template<typename TraceEvent>
void flushEvents(const Utils::span<TraceEvent> events,
std::thread::id threadId,
- EventQueue<TraceEvent> &eventQueue)
+ EnabledEventQueue<TraceEvent> &eventQueue)
{
if (events.empty())
return;
@@ -47,12 +47,12 @@ void flushEvents(const Utils::span<TraceEvent> events,
template void flushEvents(const Utils::span<StringViewTraceEvent> events,
std::thread::id threadId,
- EventQueue<StringViewTraceEvent> &eventQueue);
+ EnabledEventQueue<StringViewTraceEvent> &eventQueue);
template void flushEvents(const Utils::span<StringTraceEvent> events,
std::thread::id threadId,
- EventQueue<StringTraceEvent> &eventQueue);
+ EnabledEventQueue<StringTraceEvent> &eventQueue);
-void openFile(class TraceFile &file)
+void openFile(EnabledTraceFile &file)
{
std::lock_guard lock{file.fileMutex};
@@ -60,7 +60,7 @@ void openFile(class TraceFile &file)
file.out << std::fixed << std::setprecision(3) << R"({"traceEvents": [)";
}
-void finalizeFile(class TraceFile &file)
+void finalizeFile(EnabledTraceFile &file)
{
std::lock_guard lock{file.fileMutex};
auto &out = file.out;
@@ -75,7 +75,7 @@ void finalizeFile(class TraceFile &file)
}
template<typename TraceEvent>
-void flushInThread(EventQueue<TraceEvent> &eventQueue)
+void flushInThread(EnabledEventQueue<TraceEvent> &eventQueue)
{
if (eventQueue.file->processing.valid())
eventQueue.file->processing.wait();
@@ -94,16 +94,16 @@ void flushInThread(EventQueue<TraceEvent> &eventQueue)
eventQueue.eventsIndex = 0;
}
-template void flushInThread(EventQueue<StringViewTraceEvent> &eventQueue);
-template void flushInThread(EventQueue<StringTraceEvent> &eventQueue);
+template void flushInThread(EnabledEventQueue<StringViewTraceEvent> &eventQueue);
+template void flushInThread(EnabledEventQueue<StringTraceEvent> &eventQueue);
namespace {
-TraceFile globalTraceFile{"global.json"};
+EnabledTraceFile globalTraceFile{"global.json"};
thread_local auto globalEventQueueData = makeEventQueueData<StringTraceEvent, 1000>(globalTraceFile);
-thread_local EventQueue<StringTraceEvent> s_globalEventQueue = globalEventQueueData;
+thread_local EventQueue s_globalEventQueue = globalEventQueueData.createEventQueue();
} // namespace
-EventQueue<StringTraceEvent> &globalEventQueue()
+EnabledEventQueue<StringTraceEvent> &globalEventQueue()
{
return s_globalEventQueue;
}
diff --git a/src/libs/nanotrace/nanotracehr.h b/src/libs/nanotrace/nanotracehr.h
index 1adb6d586b..7520574a7c 100644
--- a/src/libs/nanotrace/nanotracehr.h
+++ b/src/libs/nanotrace/nanotracehr.h
@@ -61,31 +61,51 @@ using StringTraceEvent = TraceEvent<std::string>;
enum class IsEnabled { No, Yes };
-template<typename TraceEvent>
+template<typename TraceEvent, typename Enabled>
class EventQueue;
template<typename TraceEvent>
+using EnabledEventQueue = EventQueue<TraceEvent, std::true_type>;
+
+template<typename TraceEvent>
void flushEvents(const Utils::span<TraceEvent> events,
std::thread::id threadId,
- EventQueue<TraceEvent> &eventQueue);
+ EnabledEventQueue<TraceEvent> &eventQueue);
extern template void flushEvents(const Utils::span<StringViewTraceEvent> events,
std::thread::id threadId,
- EventQueue<StringViewTraceEvent> &eventQueue);
+ EnabledEventQueue<StringViewTraceEvent> &eventQueue);
extern template void flushEvents(const Utils::span<StringTraceEvent> events,
std::thread::id threadId,
- EventQueue<StringTraceEvent> &eventQueue);
+ EnabledEventQueue<StringTraceEvent> &eventQueue);
template<typename TraceEvent>
-void flushInThread(EventQueue<TraceEvent> &eventQueue);
-extern template void flushInThread(EventQueue<StringViewTraceEvent> &eventQueue);
-extern template void flushInThread(EventQueue<StringTraceEvent> &eventQueue);
+void flushInThread(EnabledEventQueue<TraceEvent> &eventQueue);
+extern template void flushInThread(EnabledEventQueue<StringViewTraceEvent> &eventQueue);
+extern template void flushInThread(EnabledEventQueue<StringTraceEvent> &eventQueue);
+
+template<bool enable>
+class TraceFile;
-void openFile(class TraceFile &file);
-void finalizeFile(class TraceFile &file);
+using EnabledTraceFile = TraceFile<true>;
+void openFile(EnabledTraceFile &file);
+void finalizeFile(EnabledTraceFile &file);
+
+template<bool enable>
class TraceFile
{
public:
+ using IsActive = std::false_type;
+
+ TraceFile(std::string_view) {}
+};
+
+template<>
+class TraceFile<true>
+{
+public:
+ using IsActive = std::true_type;
+
TraceFile([[maybe_unused]] std::string_view filePath)
: filePath{filePath}
{
@@ -104,13 +124,18 @@ public:
std::ofstream out;
};
-template<typename TraceEvent>
+template<typename TraceEvent, typename Enabled>
class EventQueue
+{};
+
+template<typename TraceEvent>
+class EventQueue<TraceEvent, std::true_type>
{
using TraceEventsSpan = Utils::span<TraceEvent>;
public:
EventQueue() = default;
+
~EventQueue()
{
if (isEnabled == IsEnabled::Yes)
@@ -122,7 +147,7 @@ public:
EventQueue &operator=(const EventQueue &) = delete;
EventQueue &operator=(EventQueue &&) = delete;
- TraceFile *file = nullptr;
+ EnabledTraceFile *file = nullptr;
TraceEventsSpan eventsOne;
TraceEventsSpan eventsTwo;
TraceEventsSpan currentEvents;
@@ -130,25 +155,44 @@ public:
IsEnabled isEnabled = IsEnabled::No;
};
-template<typename TraceEvent, std::size_t eventCount>
+template<typename TraceEvent, std::size_t eventCount, typename Enabled>
class EventQueueData
{
using TraceEvents = std::array<TraceEvent, eventCount>;
public:
- EventQueueData(TraceFile &file)
+ using IsActive = Enabled;
+
+ EventQueueData(TraceFile<false> &) {}
+};
+
+template<typename TraceEvent, std::size_t eventCount>
+class EventQueueData<TraceEvent, eventCount, std::true_type>
+{
+ using TraceEvents = std::array<TraceEvent, eventCount>;
+
+public:
+ using IsActive = std::true_type;
+
+ EventQueueData(EnabledTraceFile &file)
: file{file}
{}
- TraceFile &file;
+ EnabledTraceFile &file;
TraceEvents eventsOne;
TraceEvents eventsTwo;
};
-template<typename TraceEvent, std::size_t eventCount>
+template<typename TraceEvent, std::size_t eventCount, typename Enabled>
struct EventQueueDataPointer
{
- operator EventQueue<TraceEvent>() const
+ EventQueue<TraceEvent, std::false_type> createEventQueue() const { return {}; }
+};
+
+template<typename TraceEvent, std::size_t eventCount>
+struct EventQueueDataPointer<TraceEvent, eventCount, std::true_type>
+{
+ EnabledEventQueue<TraceEvent> createEventQueue() const
{
if constexpr (isTracerActive()) {
return {&data->file, data->eventsOne, data->eventsTwo, data->eventsOne, 0, IsEnabled::Yes};
@@ -157,23 +201,25 @@ struct EventQueueDataPointer
}
}
- std::unique_ptr<EventQueueData<TraceEvent, eventCount>> data;
+ std::unique_ptr<EventQueueData<TraceEvent, eventCount, std::true_type>> data;
};
-template<typename TraceEvent, std::size_t eventCount>
-EventQueueDataPointer<TraceEvent, eventCount> makeEventQueueData(TraceFile &file)
+template<typename TraceEvent, std::size_t eventCount, typename TraceFile>
+EventQueueDataPointer<TraceEvent, eventCount, typename TraceFile::IsActive> makeEventQueueData(
+ TraceFile &file)
{
- if constexpr (isTracerActive()) {
- return {std::make_unique<EventQueueData<TraceEvent, eventCount>>(file)};
+ if constexpr (isTracerActive() && std::is_same_v<typename TraceFile::IsActive, std::true_type>) {
+ return {std::make_unique<EventQueueData<TraceEvent, eventCount, typename TraceFile::IsActive>>(
+ file)};
} else {
return {};
}
}
-EventQueue<StringTraceEvent> &globalEventQueue();
+EnabledEventQueue<StringTraceEvent> &globalEventQueue();
template<typename TraceEvent>
-TraceEvent &getTraceEvent(EventQueue<TraceEvent> &eventQueue)
+TraceEvent &getTraceEvent(EnabledEventQueue<TraceEvent> &eventQueue)
{
if (eventQueue.eventsIndex == eventQueue.currentEvents.size())
flushInThread(eventQueue);
@@ -195,6 +241,7 @@ private:
std::string_view text;
};
+
constexpr TracerLiteral operator""_t(const char *text, size_t size)
{
return {std::string_view{text, size}};
@@ -203,43 +250,52 @@ constexpr TracerLiteral operator""_t(const char *text, size_t size)
using namespace Literals;
-template<typename TraceEvent>
+template<typename TraceEvent, bool enabled>
class Category
{
public:
+ using IsActive = std::false_type;
+
+ Category(TracerLiteral, EventQueue<TraceEvent, std::true_type> &) {}
+
+ Category(TracerLiteral, EventQueue<TraceEvent, std::false_type> &) {}
+};
+
+template<typename TraceEvent>
+class Category<TraceEvent, true>
+{
+public:
using IsActive = std::true_type;
TracerLiteral name;
- EventQueue<TraceEvent> &eventQueue;
+ EnabledEventQueue<TraceEvent> &eventQueue;
};
-using StringViewCategory = Category<StringViewTraceEvent>;
-using StringCategory = Category<StringTraceEvent>;
+template<bool enabled>
+using StringViewCategory = Category<StringViewTraceEvent, enabled>;
+template<bool enabled>
+using StringCategory = Category<StringTraceEvent, enabled>;
class DisabledCategory
-{};
-
-template<typename TraceEvent>
-Category(TracerLiteral name, EventQueue<TraceEvent> &eventQueue) -> Category<TraceEvent>;
+{
+ using IsActive = std::false_type;
+};
template<typename Category>
class Tracer
{
public:
constexpr Tracer(TracerLiteral, Category &, TracerLiteral) {}
+
constexpr Tracer(TracerLiteral, Category &) {}
~Tracer() {}
};
-template<typename String>
-class BasicTracer
-{};
-
template<>
-class Tracer<StringViewCategory>
+class Tracer<StringViewCategory<true>>
{
public:
- constexpr Tracer(TracerLiteral name, StringViewCategory &category, TracerLiteral arguments)
+ constexpr Tracer(TracerLiteral name, StringViewCategory<true> &category, TracerLiteral arguments)
: m_name{name}
, m_arguments{arguments}
, m_category{category}
@@ -250,7 +306,7 @@ public:
}
}
- constexpr Tracer(TracerLiteral name, StringViewCategory &category)
+ constexpr Tracer(TracerLiteral name, StringViewCategory<true> &category)
: Tracer{name, category, "{}"_t}
{
if constexpr (isTracerActive()) {
@@ -278,14 +334,14 @@ private:
TimePoint m_start;
std::string_view m_name;
std::string_view m_arguments;
- StringViewCategory &m_category;
+ StringViewCategory<true> &m_category;
};
template<>
-class Tracer<StringCategory>
+class Tracer<StringCategory<true>>
{
public:
- Tracer(std::string name, StringViewCategory &category, std::string arguments)
+ Tracer(std::string name, StringViewCategory<true> &category, std::string arguments)
: m_name{std::move(name)}
, m_arguments{arguments}
, m_category{category}
@@ -296,7 +352,7 @@ public:
}
}
- Tracer(std::string name, StringViewCategory &category)
+ Tracer(std::string name, StringViewCategory<true> &category)
: Tracer{std::move(name), category, "{}"}
{
if constexpr (isTracerActive()) {
@@ -324,7 +380,7 @@ private:
TimePoint m_start;
std::string m_name;
std::string m_arguments;
- StringViewCategory &m_category;
+ StringViewCategory<true> &m_category;
};
template<typename Category>
diff --git a/src/libs/sqlite/sqlitebasestatement.cpp b/src/libs/sqlite/sqlitebasestatement.cpp
index 6b1ad28cff..79e8cd6db6 100644
--- a/src/libs/sqlite/sqlitebasestatement.cpp
+++ b/src/libs/sqlite/sqlitebasestatement.cpp
@@ -26,24 +26,21 @@ extern "C" int sqlite3_carray_bind(
namespace Sqlite {
-#ifdef ENABLE_SQLITE_TRACING
namespace {
-NanotraceHR::TraceFile traceFile{"sqlite.json"};
+using TraceFile = NanotraceHR::TraceFile<sqliteTracingIsEnabled()>;
+
+TraceFile traceFile{"sqlite.json"};
thread_local auto eventQueueData = NanotraceHR::makeEventQueueData<NanotraceHR::StringViewTraceEvent, 10000>(
traceFile);
-thread_local NanotraceHR::EventQueue<NanotraceHR::StringViewTraceEvent> eventQueue = eventQueueData;
-
-NanotraceHR::Category<NanotraceHR::StringViewTraceEvent> sqliteLowLevelCategory{"sqlite low level"_t,
- eventQueue};
-} // namespace
+thread_local NanotraceHR::EventQueue eventQueue = eventQueueData.createEventQueue();
-NanotraceHR::Category<NanotraceHR::StringViewTraceEvent> sqliteHighLevelCategory{"sqlite high level"_t,
+NanotraceHR::StringViewCategory<sqliteTracingIsEnabled()> sqliteLowLevelCategory{"sqlite low level"_t,
eventQueue};
+} // namespace
-#else
-static NanotraceHR::DisabledCategory sqliteLowLevelCategory;
-#endif
+NanotraceHR::StringViewCategory<sqliteTracingIsEnabled()> sqliteHighLevelCategory{"sqlite high level"_t,
+ eventQueue};
BaseStatement::BaseStatement(Utils::SmallStringView sqlStatement, Database &database)
: m_database(database)
diff --git a/src/libs/sqlite/sqlitebasestatement.h b/src/libs/sqlite/sqlitebasestatement.h
index 6c20262532..84575ec4db 100644
--- a/src/libs/sqlite/sqlitebasestatement.h
+++ b/src/libs/sqlite/sqlitebasestatement.h
@@ -44,11 +44,17 @@ constexpr static std::underlying_type_t<Enumeration> to_underlying(Enumeration e
return static_cast<std::underlying_type_t<Enumeration>>(enumeration);
}
+constexpr bool sqliteTracingIsEnabled()
+{
#ifdef ENABLE_SQLITE_TRACING
-extern NanotraceHR::Category<NanotraceHR::StringViewTraceEvent> sqliteHighLevelCategory;
+ return NanotraceHR::isTracerActive();
#else
-inline NanotraceHR::DisabledCategory sqliteHighLevelCategory;
+ return false;
#endif
+}
+
+SQLITE_EXPORT extern NanotraceHR::StringViewCategory<sqliteTracingIsEnabled()> sqliteHighLevelCategory;
+
class SQLITE_EXPORT BaseStatement
{
public:
diff --git a/src/plugins/qmldesigner/designercore/projectstorage/projectstorage.cpp b/src/plugins/qmldesigner/designercore/projectstorage/projectstorage.cpp
index 9819c2adcc..48e36206a4 100644
--- a/src/plugins/qmldesigner/designercore/projectstorage/projectstorage.cpp
+++ b/src/plugins/qmldesigner/designercore/projectstorage/projectstorage.cpp
@@ -7,18 +7,16 @@
namespace QmlDesigner {
-#ifdef ENABLE_PROJECT_STORAGE_TRACING
namespace {
-NanotraceHR::TraceFile traceFile{"projectstorage.json"};
+NanotraceHR::TraceFile<projectStorageTracingIsEnabled()> traceFile{"projectstorage.json"};
thread_local auto eventQueueData = NanotraceHR::makeEventQueueData<NanotraceHR::StringViewTraceEvent, 1000>(
traceFile);
-thread_local NanotraceHR::EventQueue<NanotraceHR::StringViewTraceEvent> eventQueue = eventQueueData;
+thread_local NanotraceHR::EventQueue eventQueue = eventQueueData.createEventQueue();
} // namespace
-NanotraceHR::Category<NanotraceHR::StringViewTraceEvent> projectStorageCategory{"project storage"_t,
- eventQueue};
-#endif
+NanotraceHR::StringViewCategory<projectStorageTracingIsEnabled()> projectStorageCategory{"project storage"_t,
+ eventQueue};
} // namespace QmlDesigner
template class QmlDesigner::ProjectStorage<Sqlite::Database>;
diff --git a/src/plugins/qmldesigner/designercore/projectstorage/projectstorage.h b/src/plugins/qmldesigner/designercore/projectstorage/projectstorage.h
index d396301944..0db827e4fb 100644
--- a/src/plugins/qmldesigner/designercore/projectstorage/projectstorage.h
+++ b/src/plugins/qmldesigner/designercore/projectstorage/projectstorage.h
@@ -28,11 +28,16 @@ namespace QmlDesigner {
using namespace NanotraceHR::Literals;
+constexpr bool projectStorageTracingIsEnabled()
+{
#ifdef ENABLE_PROJECT_STORAGE_TRACING
-extern NanotraceHR::Category<NanotraceHR::StringViewTraceEvent> projectStorageCategory;
+ return NanotraceHR::isTracerActive();
#else
-inline NanotraceHR::DisabledCategory projectStorageCategory;
+ return false;
#endif
+}
+
+extern NanotraceHR::StringViewCategory<projectStorageTracingIsEnabled()> projectStorageCategory;
template<typename Database>
class ProjectStorage final : public ProjectStorageInterface
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-22 07:13:21 +0000