more memory tagging and fixes (#263)

This change adds more instrumentation for memory tracking, so that as little as possible comes through as Unknown in Insights analysis.

2 files changed, 94 insertions, 4 deletions

diff --git a/src/zenhttp/servers/httpasio.cpp b/src/zenhttp/servers/httpasio.cpp
index cddbe1ae2..c2a823430 100644
--- a/src/zenhttp/servers/httpasio.cpp
+++ b/src/zenhttp/servers/httpasio.cpp
@@ -5,6 +5,7 @@
 
 #include <zencore/except.h>
 #include <zencore/logging.h>
+#include <zencore/memory/llm.h>
 #include <zencore/thread.h>
 #include <zencore/trace.h>
 #include <zenhttp/httpserver.h>
@@ -32,6 +33,18 @@ ZEN_THIRD_PARTY_INCLUDES_END
 #	define ZEN_TRACE_VERBOSE(fmtstr, ...)
 #endif
 
+namespace zen {
+
+const FLLMTag&
+GetHttpasioTag()
+{
+	static FLLMTag _("httpasio");
+
+	return _;
+}
+
+}  // namespace zen
+
 namespace zen::asio_http {
 
 using namespace std::literals;
@@ -125,6 +138,8 @@ public:
 
 	void InitializeForPayload(uint16_t ResponseCode, std::span<IoBuffer> BlobList)
 	{
+		ZEN_MEMSCOPE(GetHttpasioTag());
+
 		ZEN_TRACE_CPU("asio::InitializeForPayload");
 
 		m_ResponseCode			  = ResponseCode;
@@ -173,8 +188,8 @@ public:
 		}
 		m_ContentLength = LocalDataSize;
 
-		auto Headers	 = GetHeaders();
-		m_AsioBuffers[0] = asio::const_buffer(Headers.data(), Headers.size());
+		std::string_view Headers = GetHeaders();
+		m_AsioBuffers[0]		 = asio::const_buffer(Headers.data(), Headers.size());
 	}
 
 	uint16_t ResponseCode() const { return m_ResponseCode; }
@@ -184,6 +199,8 @@ public:
 
 	std::string_view GetHeaders()
 	{
+		ZEN_MEMSCOPE(GetHttpasioTag());
+
 		m_Headers << "HTTP/1.1 " << ResponseCode() << " " << ReasonStringForHttpResultCode(ResponseCode()) << "\r\n"
 				  << "Content-Type: " << MapContentTypeToString(m_ContentType) << "\r\n"
 				  << "Content-Length: " << ContentLength() << "\r\n"sv;
@@ -298,6 +315,8 @@ HttpServerConnection::TerminateConnection()
 void
 HttpServerConnection::EnqueueRead()
 {
+	ZEN_MEMSCOPE(GetHttpasioTag());
+
 	if ((m_RequestState == RequestState::kInitialRead) || (m_RequestState == RequestState::kReadingMore))
 	{
 		m_RequestState = RequestState::kReadingMore;
@@ -318,6 +337,8 @@ HttpServerConnection::EnqueueRead()
 void
 HttpServerConnection::OnDataReceived(const asio::error_code& Ec, [[maybe_unused]] std::size_t ByteCount)
 {
+	ZEN_MEMSCOPE(GetHttpasioTag());
+
 	if (Ec)
 	{
 		switch (m_RequestState)
@@ -369,6 +390,8 @@ HttpServerConnection::OnDataReceived(const asio::error_code& Ec, [[maybe_unused]
 void
 HttpServerConnection::OnResponseDataSent(const asio::error_code& Ec, [[maybe_unused]] std::size_t ByteCount, bool Pop)
 {
+	ZEN_MEMSCOPE(GetHttpasioTag());
+
 	if (Ec)
 	{
 		ZEN_WARN("on data sent ERROR, connection: {}, reason: '{}'", m_ConnectionId, Ec.message());
@@ -402,6 +425,8 @@ HttpServerConnection::OnResponseDataSent(const asio::error_code& Ec, [[maybe_unu
 void
 HttpServerConnection::CloseConnection()
 {
+	ZEN_MEMSCOPE(GetHttpasioTag());
+
 	if (m_RequestState == RequestState::kDone || m_RequestState == RequestState::kTerminated)
 	{
 		return;
@@ -425,6 +450,8 @@ HttpServerConnection::CloseConnection()
 void
 HttpServerConnection::HandleRequest()
 {
+	ZEN_MEMSCOPE(GetHttpasioTag());
+
 	if (!m_RequestData.IsKeepAlive())
 	{
 		m_RequestState = RequestState::kWritingFinal;
@@ -525,11 +552,11 @@ HttpServerConnection::HandleRequest()
 				Response->SuppressPayload();
 			}
 
-			auto ResponseBuffers = Response->AsioBuffers();
+			const std::vector<asio::const_buffer>& ResponseBuffers = Response->AsioBuffers();
 
 			uint64_t ResponseLength = 0;
 
-			for (auto& Buffer : ResponseBuffers)
+			for (const asio::const_buffer& Buffer : ResponseBuffers)
 			{
 				ResponseLength += Buffer.size();
 			}
@@ -728,6 +755,8 @@ struct HttpAcceptor
 
 	void Start()
 	{
+		ZEN_MEMSCOPE(GetHttpasioTag());
+
 		ZEN_ASSERT(!m_IsStopped);
 		InitAcceptInternal(m_Acceptor);
 		if (m_UseAlternateProtocolAcceptor)
@@ -878,6 +907,8 @@ HttpAsioServerRequest::ReadPayload()
 void
 HttpAsioServerRequest::WriteResponse(HttpResponseCode ResponseCode)
 {
+	ZEN_MEMSCOPE(GetHttpasioTag());
+
 	ZEN_ASSERT(!m_Response);
 
 	m_Response.reset(new HttpResponse(HttpContentType::kBinary));
@@ -889,6 +920,8 @@ HttpAsioServerRequest::WriteResponse(HttpResponseCode ResponseCode)
 void
 HttpAsioServerRequest::WriteResponse(HttpResponseCode ResponseCode, HttpContentType ContentType, std::span<IoBuffer> Blobs)
 {
+	ZEN_MEMSCOPE(GetHttpasioTag());
+
 	ZEN_ASSERT(!m_Response);
 
 	m_Response.reset(new HttpResponse(ContentType));
@@ -898,6 +931,8 @@ HttpAsioServerRequest::WriteResponse(HttpResponseCode ResponseCode, HttpContentT
 void
 HttpAsioServerRequest::WriteResponse(HttpResponseCode ResponseCode, HttpContentType ContentType, std::u8string_view ResponseString)
 {
+	ZEN_MEMSCOPE(GetHttpasioTag());
+
 	ZEN_ASSERT(!m_Response);
 	m_Response.reset(new HttpResponse(ContentType));
 
@@ -910,6 +945,8 @@ HttpAsioServerRequest::WriteResponse(HttpResponseCode ResponseCode, HttpContentT
 void
 HttpAsioServerRequest::WriteResponseAsync(std::function<void(HttpServerRequest&)>&& ContinuationHandler)
 {
+	ZEN_MEMSCOPE(GetHttpasioTag());
+
 	ZEN_ASSERT(!m_Response);
 
 	// Not one bit async, innit
@@ -941,6 +978,8 @@ HttpAsioServerImpl::Initialize(std::filesystem::path DataDir)
 int
 HttpAsioServerImpl::Start(uint16_t Port, bool ForceLooopback, int ThreadCount)
 {
+	ZEN_MEMSCOPE(GetHttpasioTag());
+
 	ZEN_ASSERT(ThreadCount > 0);
 
 	ZEN_INFO("starting asio http with {} service threads", ThreadCount);
@@ -960,6 +999,8 @@ HttpAsioServerImpl::Start(uint16_t Port, bool ForceLooopback, int ThreadCount)
 	for (int i = 0; i < ThreadCount; ++i)
 	{
 		m_ThreadPool.emplace_back([this, Index = i + 1] {
+			ZEN_MEMSCOPE(GetHttpasioTag());
+
 			SetCurrentThreadName(fmt::format("asio_io_{}", Index));
 
 			try
@@ -985,6 +1026,8 @@ HttpAsioServerImpl::Start(uint16_t Port, bool ForceLooopback, int ThreadCount)
 void
 HttpAsioServerImpl::Stop()
 {
+	ZEN_MEMSCOPE(GetHttpasioTag());
+
 	if (m_Acceptor)
 	{
 		m_Acceptor->StopAccepting();
@@ -1004,6 +1047,8 @@ HttpAsioServerImpl::Stop()
 void
 HttpAsioServerImpl::RegisterService(const char* InUrlPath, HttpService& Service)
 {
+	ZEN_MEMSCOPE(GetHttpasioTag());
+
 	std::string_view UrlPath(InUrlPath);
 	Service.SetUriPrefixLength(UrlPath.size());
 	if (!UrlPath.empty() && UrlPath.back() == '/')
@@ -1018,6 +1063,8 @@ HttpAsioServerImpl::RegisterService(const char* InUrlPath, HttpService& Service)
 HttpService*
 HttpAsioServerImpl::RouteRequest(std::string_view Url)
 {
+	ZEN_MEMSCOPE(GetHttpasioTag());
+
 	RwLock::SharedLockScope _(m_Lock);
 
 	HttpService*		   CandidateService	  = nullptr;
@@ -1163,6 +1210,8 @@ HttpAsioServer::RequestExit()
 Ref<HttpServer>
 CreateHttpAsioServer(bool ForceLoopback, unsigned int ThreadCount)
 {
+	ZEN_MEMSCOPE(GetHttpasioTag());
+
 	return Ref<HttpServer>{new HttpAsioServer(ForceLoopback, ThreadCount)};
 }
 
diff --git a/src/zenhttp/servers/httpplugin.cpp b/src/zenhttp/servers/httpplugin.cpp
index 9c2110476..b55d80af8 100644
--- a/src/zenhttp/servers/httpplugin.cpp
+++ b/src/zenhttp/servers/httpplugin.cpp
@@ -12,6 +12,7 @@
 #	include <zencore/filesystem.h>
 #	include <zencore/fmtutils.h>
 #	include <zencore/logging.h>
+#	include <zencore/memory/llm.h>
 #	include <zencore/scopeguard.h>
 #	include <zencore/session.h>
 #	include <zencore/thread.h>
@@ -34,6 +35,14 @@ struct HttpPluginResponse;
 
 using namespace std::literals;
 
+const FLLMTag&
+GetHttppluginTag()
+{
+	static FLLMTag _("httpplugin");
+
+	return _;
+}
+
 //////////////////////////////////////////////////////////////////////////
 
 struct HttpPluginConnectionHandler : public TransportServerConnection, public HttpRequestParserCallbacks, RefCounted
@@ -183,6 +192,7 @@ private:
 void
 HttpPluginResponse::InitializeForPayload(uint16_t ResponseCode, std::span<IoBuffer> BlobList)
 {
+	ZEN_MEMSCOPE(GetHttppluginTag());
 	ZEN_TRACE_CPU("http_plugin::InitializeForPayload");
 
 	m_ResponseCode			  = ResponseCode;
@@ -224,6 +234,8 @@ HttpPluginResponse::InitializeForPayload(uint16_t ResponseCode, std::span<IoBuff
 std::string_view
 HttpPluginResponse::GetHeaders()
 {
+	ZEN_MEMSCOPE(GetHttppluginTag());
+
 	if (m_Headers.Size() == 0)
 	{
 		m_Headers << "HTTP/1.1 " << ResponseCode() << " " << ReasonStringForHttpResultCode(ResponseCode()) << "\r\n"
@@ -258,6 +270,8 @@ HttpPluginConnectionHandler::~HttpPluginConnectionHandler()
 void
 HttpPluginConnectionHandler::Initialize(TransportConnection* Transport, HttpPluginServerImpl& Server, uint32_t ConnectionId)
 {
+	ZEN_MEMSCOPE(GetHttppluginTag());
+
 	m_TransportConnection = Transport;
 	m_Server			  = &Server;
 	m_ConnectionId		  = ConnectionId;
@@ -290,6 +304,8 @@ HttpPluginConnectionHandler::Release() const
 void
 HttpPluginConnectionHandler::OnBytesRead(const void* Buffer, size_t AvailableBytes)
 {
+	ZEN_MEMSCOPE(GetHttppluginTag());
+
 	ZEN_ASSERT(m_Server);
 
 	ZEN_LOG_TRACE(m_Server->m_RequestLog, "connection #{} OnBytesRead: {}", m_ConnectionId, AvailableBytes);
@@ -317,6 +333,8 @@ HttpPluginConnectionHandler::OnBytesRead(const void* Buffer, size_t AvailableByt
 void
 HttpPluginConnectionHandler::HandleRequest()
 {
+	ZEN_MEMSCOPE(GetHttppluginTag());
+
 	ZEN_ASSERT(m_Server);
 
 	const uint32_t RequestNumber = m_RequestCounter.fetch_add(1);
@@ -516,6 +534,7 @@ HttpPluginConnectionHandler::HandleRequest()
 void
 HttpPluginConnectionHandler::TerminateConnection()
 {
+	ZEN_MEMSCOPE(GetHttppluginTag());
 	ZEN_ASSERT(m_TransportConnection);
 	m_TransportConnection->CloseConnection();
 }
@@ -526,6 +545,8 @@ HttpPluginServerRequest::HttpPluginServerRequest(HttpRequestParser& Request, Htt
 : m_Request(Request)
 , m_PayloadBuffer(std::move(PayloadBuffer))
 {
+	ZEN_MEMSCOPE(GetHttppluginTag());
+
 	const int PrefixLength = Service.UriPrefixLength();
 
 	std::string_view Uri = Request.Url();
@@ -606,6 +627,7 @@ void
 HttpPluginServerRequest::WriteResponse(HttpResponseCode ResponseCode)
 {
 	ZEN_ASSERT(!m_Response);
+	ZEN_MEMSCOPE(GetHttppluginTag());
 
 	m_Response.reset(new HttpPluginResponse(HttpContentType::kBinary));
 	std::array<IoBuffer, 0> Empty;
@@ -617,6 +639,7 @@ void
 HttpPluginServerRequest::WriteResponse(HttpResponseCode ResponseCode, HttpContentType ContentType, std::span<IoBuffer> Blobs)
 {
 	ZEN_ASSERT(!m_Response);
+	ZEN_MEMSCOPE(GetHttppluginTag());
 
 	m_Response.reset(new HttpPluginResponse(ContentType));
 	m_Response->InitializeForPayload((uint16_t)ResponseCode, Blobs);
@@ -626,6 +649,8 @@ void
 HttpPluginServerRequest::WriteResponse(HttpResponseCode ResponseCode, HttpContentType ContentType, std::u8string_view ResponseString)
 {
 	ZEN_ASSERT(!m_Response);
+	ZEN_MEMSCOPE(GetHttppluginTag());
+
 	m_Response.reset(new HttpPluginResponse(ContentType));
 
 	IoBuffer				MessageBuffer(IoBuffer::Wrap, ResponseString.data(), ResponseString.size());
@@ -638,6 +663,7 @@ void
 HttpPluginServerRequest::WriteResponseAsync(std::function<void(HttpServerRequest&)>&& ContinuationHandler)
 {
 	ZEN_ASSERT(!m_Response);
+	ZEN_MEMSCOPE(GetHttppluginTag());
 
 	// Not one bit async, innit
 	ContinuationHandler(*this);
@@ -662,6 +688,7 @@ HttpPluginServerImpl::~HttpPluginServerImpl()
 TransportServerConnection*
 HttpPluginServerImpl::CreateConnectionHandler(TransportConnection* Connection)
 {
+	ZEN_MEMSCOPE(GetHttppluginTag());
 	HttpPluginConnectionHandler* Handler{new HttpPluginConnectionHandler()};
 	const uint32_t				 ConnectionId = m_ConnectionIdCounter.fetch_add(1);
 	Handler->Initialize(Connection, *this, ConnectionId);
@@ -671,6 +698,7 @@ HttpPluginServerImpl::CreateConnectionHandler(TransportConnection* Connection)
 int
 HttpPluginServerImpl::Initialize(int BasePort, std::filesystem::path DataDir)
 {
+	ZEN_MEMSCOPE(GetHttppluginTag());
 	m_RequestTracer.Initialize(DataDir);
 
 	try
@@ -705,6 +733,8 @@ HttpPluginServerImpl::Close()
 	if (!m_IsInitialized)
 		return;
 
+	ZEN_MEMSCOPE(GetHttppluginTag());
+
 	try
 	{
 		RwLock::ExclusiveLockScope _(m_Lock);
@@ -736,6 +766,8 @@ HttpPluginServerImpl::Close()
 void
 HttpPluginServerImpl::Run(bool IsInteractive)
 {
+	ZEN_MEMSCOPE(GetHttppluginTag());
+
 	const bool TestMode = !IsInteractive;
 
 	int WaitTimeout = -1;
@@ -786,6 +818,8 @@ HttpPluginServerImpl::RequestExit()
 void
 HttpPluginServerImpl::AddPlugin(Ref<TransportPlugin> Plugin)
 {
+	ZEN_MEMSCOPE(GetHttppluginTag());
+
 	RwLock::ExclusiveLockScope _(m_Lock);
 	m_Plugins.emplace_back(std::move(Plugin));
 }
@@ -793,6 +827,8 @@ HttpPluginServerImpl::AddPlugin(Ref<TransportPlugin> Plugin)
 void
 HttpPluginServerImpl::RemovePlugin(Ref<TransportPlugin> Plugin)
 {
+	ZEN_MEMSCOPE(GetHttppluginTag());
+
 	RwLock::ExclusiveLockScope _(m_Lock);
 	auto					   It = std::find(begin(m_Plugins), end(m_Plugins), Plugin);
 	if (It != m_Plugins.end())
@@ -804,6 +840,8 @@ HttpPluginServerImpl::RemovePlugin(Ref<TransportPlugin> Plugin)
 void
 HttpPluginServerImpl::RegisterService(HttpService& Service)
 {
+	ZEN_MEMSCOPE(GetHttppluginTag());
+
 	std::string_view UrlPath(Service.BaseUri());
 	Service.SetUriPrefixLength(UrlPath.size());
 
@@ -819,6 +857,8 @@ HttpPluginServerImpl::RegisterService(HttpService& Service)
 HttpService*
 HttpPluginServerImpl::RouteRequest(std::string_view Url)
 {
+	ZEN_MEMSCOPE(GetHttppluginTag());
+
 	RwLock::SharedLockScope _(m_Lock);
 
 	HttpService*		   CandidateService	  = nullptr;
@@ -845,6 +885,7 @@ struct HttpPluginServerImpl;
 Ref<HttpPluginServer>
 CreateHttpPluginServer()
 {
+	ZEN_MEMSCOPE(GetHttppluginTag());
 	return Ref<HttpPluginServer>(new HttpPluginServerImpl);
 }