reduced memory churn using fixed_xxx containers (#236)

* Added EASTL to help with eliminating memory allocations
* Applied EASTL to eliminate memory allocations, primarily by using `fixed_vector` et al to use stack allocations / inline struct allocations

Reduces memory events in traces by close to a factor of 10 in test scenario (starting editor for project F)

5 files changed, 97 insertions, 10 deletions

diff --git a/src/zencore/include/zencore/compactbinarybuilder.h b/src/zencore/include/zencore/compactbinarybuilder.h
index 1c625cacc..f11717453 100644
--- a/src/zencore/include/zencore/compactbinarybuilder.h
+++ b/src/zencore/include/zencore/compactbinarybuilder.h
@@ -18,6 +18,8 @@
 #include <type_traits>
 #include <vector>
 
+#include <EASTL/fixed_vector.h>
+
 #include <gsl/gsl-lite.hpp>
 
 namespace zen {
@@ -367,6 +369,8 @@ public:
 	/** Private flags that are public to work with ENUM_CLASS_FLAGS. */
 	enum class StateFlags : uint8_t;
 
+	typedef eastl::fixed_vector<uint8_t, 2048> CbWriterData_t;
+
 protected:
 	/** Reserve the specified size up front until the format is optimized. */
 	ZENCORE_API explicit CbWriter(int64_t InitialSize);
@@ -409,8 +413,8 @@ private:
 	// provided externally, such as on the stack. That format will store the offsets that require
 	// object or array sizes to be inserted and field types to be removed, and will perform those
 	// operations only when saving to a buffer.
-	std::vector<uint8_t>	 Data;
-	std::vector<WriterState> States;
+	eastl::fixed_vector<WriterState, 4> States;
+	CbWriterData_t						Data;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/zencore/include/zencore/compactbinarypackage.h b/src/zencore/include/zencore/compactbinarypackage.h
index 12fcc41b7..9ec12cb0f 100644
--- a/src/zencore/include/zencore/compactbinarypackage.h
+++ b/src/zencore/include/zencore/compactbinarypackage.h
@@ -12,6 +12,8 @@
 #include <span>
 #include <variant>
 
+#include <EASTL/fixed_vector.h>
+
 #ifdef GetObject
 #	error "windows.h pollution"
 #	undef GetObject
@@ -265,7 +267,10 @@ public:
 	}
 
 	/** Returns the attachments in this package. */
-	inline std::span<const CbAttachment> GetAttachments() const { return Attachments; }
+	inline std::span<const CbAttachment> GetAttachments() const
+	{
+		return std::span<const CbAttachment>(begin(Attachments), end(Attachments));
+	}
 
 	/**
 	 * Find an attachment by its hash.
@@ -286,6 +291,8 @@ public:
 
 	void AddAttachments(std::span<const CbAttachment> Attachments);
 
+	void ReserveAttachments(size_t Count);
+
 	/**
 	 * Remove an attachment by hash.
 	 *
@@ -324,9 +331,9 @@ private:
 	void GatherAttachments(const CbObject& Object, AttachmentResolver Resolver);
 
 	/** Attachments ordered by their hash. */
-	std::vector<CbAttachment> Attachments;
-	CbObject				  Object;
-	IoHash					  ObjectHash;
+	eastl::fixed_vector<CbAttachment, 32> Attachments;
+	CbObject							  Object;
+	IoHash								  ObjectHash;
 };
 
 namespace legacy {
diff --git a/src/zencore/include/zencore/compositebuffer.h b/src/zencore/include/zencore/compositebuffer.h
index b435c5e74..1e1611de9 100644
--- a/src/zencore/include/zencore/compositebuffer.h
+++ b/src/zencore/include/zencore/compositebuffer.h
@@ -2,6 +2,7 @@
 
 #pragma once
 
+#include <zencore/eastlutil.h>
 #include <zencore/sharedbuffer.h>
 #include <zencore/zencore.h>
 
@@ -9,6 +10,8 @@
 #include <span>
 #include <vector>
 
+#include <EASTL/fixed_vector.h>
+
 namespace zen {
 
 /**
@@ -35,7 +38,7 @@ public:
 		{
 			m_Segments.reserve((GetBufferCount(std::forward<BufferTypes>(Buffers)) + ...));
 			(AppendBuffers(std::forward<BufferTypes>(Buffers)), ...);
-			std::erase_if(m_Segments, [](const SharedBuffer& It) { return It.IsNull(); });
+			erase_if(m_Segments, [](const SharedBuffer& It) { return It.IsNull(); });
 		}
 	}
 
@@ -46,7 +49,10 @@ public:
 	[[nodiscard]] ZENCORE_API uint64_t GetSize() const;
 
 	/** Returns the segments that the buffer is composed from. */
-	[[nodiscard]] inline std::span<const SharedBuffer> GetSegments() const { return std::span<const SharedBuffer>{m_Segments}; }
+	[[nodiscard]] inline std::span<const SharedBuffer> GetSegments() const
+	{
+		return std::span<const SharedBuffer>{begin(m_Segments), end(m_Segments)};
+	}
 
 	/** Returns true if the composite buffer is not null. */
 	[[nodiscard]] inline explicit operator bool() const { return !IsNull(); }
@@ -120,6 +126,8 @@ public:
 	static const CompositeBuffer Null;
 
 private:
+	typedef eastl::fixed_vector<SharedBuffer, 4> SharedBufferVector_t;
+
 	static inline size_t GetBufferCount(const CompositeBuffer& Buffer) { return Buffer.m_Segments.size(); }
 	inline void			 AppendBuffers(const CompositeBuffer& Buffer)
 	{
@@ -134,12 +142,25 @@ private:
 	inline void			 AppendBuffers(SharedBuffer&& Buffer) { m_Segments.push_back(std::move(Buffer)); }
 	inline void			 AppendBuffers(IoBuffer&& Buffer) { m_Segments.push_back(SharedBuffer(std::move(Buffer))); }
 
+	static inline size_t GetBufferCount(std::span<IoBuffer>&& Container) { return Container.size(); }
+	inline void			 AppendBuffers(std::span<IoBuffer>&& Container)
+	{
+		m_Segments.reserve(m_Segments.size() + Container.size());
+		for (IoBuffer& Buffer : Container)
+		{
+			m_Segments.emplace_back(SharedBuffer(std::move(Buffer)));
+		}
+	}
+
 	static inline size_t GetBufferCount(std::vector<SharedBuffer>&& Container) { return Container.size(); }
 	static inline size_t GetBufferCount(std::vector<IoBuffer>&& Container) { return Container.size(); }
 	inline void			 AppendBuffers(std::vector<SharedBuffer>&& Container)
 	{
 		m_Segments.reserve(m_Segments.size() + Container.size());
-		m_Segments.insert(m_Segments.end(), std::make_move_iterator(Container.begin()), std::make_move_iterator(Container.end()));
+		for (SharedBuffer& Buffer : Container)
+		{
+			m_Segments.emplace_back(std::move(Buffer));
+		}
 	}
 	inline void AppendBuffers(std::vector<IoBuffer>&& Container)
 	{
@@ -150,8 +171,17 @@ private:
 		}
 	}
 
+	inline void AppendBuffers(SharedBufferVector_t&& Container)
+	{
+		m_Segments.reserve(m_Segments.size() + Container.size());
+		for (SharedBuffer& Buffer : Container)
+		{
+			m_Segments.emplace_back(std::move(Buffer));
+		}
+	}
+
 private:
-	std::vector<SharedBuffer> m_Segments;
+	SharedBufferVector_t m_Segments;
 };
 
 void compositebuffer_forcelink();  // internal
diff --git a/src/zencore/include/zencore/eastlutil.h b/src/zencore/include/zencore/eastlutil.h
new file mode 100644
index 000000000..642321dae
--- /dev/null
+++ b/src/zencore/include/zencore/eastlutil.h
@@ -0,0 +1,20 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#pragma once
+
+#include <algorithm>
+
+namespace zen {
+
+size_t
+erase_if(auto& _Cont, auto Predicate)
+{
+	auto	   _First	 = _Cont.begin();
+	const auto _Last	 = _Cont.end();
+	const auto _Old_size = _Cont.size();
+	_First				 = std::remove_if(_First, _Last, Predicate);
+	_Cont.erase(_First, _Last);
+	return _Old_size - _Cont.size();
+}
+
+}  // namespace zen
diff --git a/src/zencore/include/zencore/memory/newdelete.h b/src/zencore/include/zencore/memory/newdelete.h
index d22c8604f..059f1d5ea 100644
--- a/src/zencore/include/zencore/memory/newdelete.h
+++ b/src/zencore/include/zencore/memory/newdelete.h
@@ -153,3 +153,29 @@ operator new[](std::size_t n, std::align_val_t al, const std::nothrow_t&) noexce
 	return zen_new_aligned_nothrow(n, static_cast<size_t>(al));
 }
 #endif
+
+// EASTL operator new
+
+void*
+operator new[](size_t size, const char* pName, int flags, unsigned debugFlags, const char* file, int line)
+{
+	ZEN_UNUSED(pName, flags, debugFlags, file, line);
+	return zen_new(size);
+}
+
+void*
+operator new[](size_t	   size,
+			   size_t	   alignment,
+			   size_t	   alignmentOffset,
+			   const char* pName,
+			   int		   flags,
+			   unsigned	   debugFlags,
+			   const char* file,
+			   int		   line)
+{
+	ZEN_UNUSED(alignmentOffset, pName, flags, debugFlags, file, line);
+
+	ZEN_ASSERT_SLOW(alignmentOffset == 0);	// currently not supported
+
+	return zen_new_aligned(size, alignment);
+}