From 60367a287e373b8ec23f3ef18914d61ed345ca32 Mon Sep 17 00:00:00 2001
From: Matej Ferencevic <matej.ferencevic@memgraph.io>
Date: Mon, 2 Sep 2019 15:01:24 +0200
Subject: [PATCH] Implement wrappers for STL containers with our allocator

Reviewers: teon.banek

Reviewed By: teon.banek

Subscribers: pullbot

Differential Revision: https://phabricator.memgraph.io/D2342
---
 src/query/interpret/frame.hpp                 |   3 +-
 src/query/path.hpp                            |   5 +-
 src/query/plan/operator.cpp                   | 138 ++++++++----------
 src/query/typed_value.hpp                     |  16 +-
 src/utils/memory.hpp                          |  10 +-
 src/utils/pmr/list.hpp                        |  12 ++
 src/utils/pmr/map.hpp                         |  16 ++
 src/utils/pmr/string.hpp                      |  12 ++
 src/utils/pmr/unordered_map.hpp               |  18 +++
 src/utils/pmr/unordered_set.hpp               |  17 +++
 src/utils/pmr/vector.hpp                      |  12 ++
 tests/unit/query_plan_match_filter_return.cpp |   2 +-
 12 files changed, 163 insertions(+), 98 deletions(-)
 create mode 100644 src/utils/pmr/list.hpp
 create mode 100644 src/utils/pmr/map.hpp
 create mode 100644 src/utils/pmr/string.hpp
 create mode 100644 src/utils/pmr/unordered_map.hpp
 create mode 100644 src/utils/pmr/unordered_set.hpp
 create mode 100644 src/utils/pmr/vector.hpp

diff --git a/src/query/interpret/frame.hpp b/src/query/interpret/frame.hpp
index eab69898c..4f4617b1f 100644
--- a/src/query/interpret/frame.hpp
+++ b/src/query/interpret/frame.hpp
@@ -7,6 +7,7 @@
 #include "query/frontend/semantic/symbol_table.hpp"
 #include "query/typed_value.hpp"
 #include "utils/memory.hpp"
+#include "utils/pmr/vector.hpp"
 
 namespace query {
 
@@ -43,7 +44,7 @@ class Frame {
 
  private:
   int64_t size_;
-  utils::AVector<TypedValue> elems_;
+  utils::pmr::vector<TypedValue> elems_;
 };
 
 }  // namespace query
diff --git a/src/query/path.hpp b/src/query/path.hpp
index 81fa0788c..89b288c97 100644
--- a/src/query/path.hpp
+++ b/src/query/path.hpp
@@ -8,6 +8,7 @@
 #include "storage/edge_accessor.hpp"
 #include "storage/vertex_accessor.hpp"
 #include "utils/memory.hpp"
+#include "utils/pmr/vector.hpp"
 
 namespace query {
 
@@ -167,9 +168,9 @@ class Path {
 
  private:
   // Contains all the vertices in the path.
-  std::vector<VertexAccessor, utils::Allocator<VertexAccessor>> vertices_;
+  utils::pmr::vector<VertexAccessor> vertices_;
   // Contains all the edges in the path (one less then there are vertices).
-  std::vector<EdgeAccessor, utils::Allocator<EdgeAccessor>> edges_;
+  utils::pmr::vector<EdgeAccessor> edges_;
 };
 
 }  // namespace query
diff --git a/src/query/plan/operator.cpp b/src/query/plan/operator.cpp
index 6bd77ba18..5b3265f78 100644
--- a/src/query/plan/operator.cpp
+++ b/src/query/plan/operator.cpp
@@ -27,6 +27,9 @@
 #include "utils/algorithm.hpp"
 #include "utils/exceptions.hpp"
 #include "utils/hashing/fnv.hpp"
+#include "utils/pmr/unordered_map.hpp"
+#include "utils/pmr/unordered_set.hpp"
+#include "utils/pmr/vector.hpp"
 
 // macro for the default implementation of LogicalOperator::Accept
 // that accepts the visitor and visits it's input_ operator
@@ -667,7 +670,7 @@ auto ExpandFromVertex(const VertexAccessor &vertex,
   };
 
   // prepare a vector of elements we'll pass to the itertools
-  utils::AVector<decltype(wrapper(direction, vertex.in()))> chain_elements(
+  utils::pmr::vector<decltype(wrapper(direction, vertex.in()))> chain_elements(
       memory);
 
   if (direction != EdgeAtom::Direction::OUT && vertex.in_degree() > 0) {
@@ -752,9 +755,9 @@ class ExpandVariableCursor : public Cursor {
       ExpandFromVertex(std::declval<VertexAccessor>(), EdgeAtom::Direction::IN,
                        self_.common_.edge_types, utils::NewDeleteResource()));
 
-  utils::AVector<ExpandEdges> edges_;
+  utils::pmr::vector<ExpandEdges> edges_;
   // an iterator indicating the position in the corresponding edges_ element
-  utils::AVector<decltype(edges_.begin()->begin())> edges_it_;
+  utils::pmr::vector<decltype(edges_.begin()->begin())> edges_it_;
 
   /**
    * Helper function that Pulls from the input vertex and
@@ -811,9 +814,8 @@ class ExpandVariableCursor : public Cursor {
   }
 
   // Helper function for appending an edge to the list on the frame.
-  void AppendEdge(
-      const EdgeAccessor &new_edge,
-      std::vector<TypedValue, utils::Allocator<TypedValue>> *edges_on_frame) {
+  void AppendEdge(const EdgeAccessor &new_edge,
+                  utils::pmr::vector<TypedValue> *edges_on_frame) {
     // We are placing an edge on the frame. It is possible that there already
     // exists an edge on the frame for this level. If so first remove it.
     DCHECK(edges_.size() > 0) << "Edges are empty";
@@ -987,17 +989,14 @@ class STShortestPathCursor : public query::plan::Cursor {
   const ExpandVariable &self_;
   UniqueCursorPtr input_cursor_;
 
-  using VertexEdgeMapT = std::unordered_map<
-      VertexAccessor, std::optional<EdgeAccessor>, std::hash<VertexAccessor>,
-      std::equal_to<>,
-      utils::Allocator<
-          std::pair<const VertexAccessor, std::optional<EdgeAccessor>>>>;
+  using VertexEdgeMapT =
+      utils::pmr::unordered_map<VertexAccessor, std::optional<EdgeAccessor>>;
 
   void ReconstructPath(const VertexAccessor &midpoint,
                        const VertexEdgeMapT &in_edge,
                        const VertexEdgeMapT &out_edge, Frame *frame,
                        utils::MemoryResource *pull_memory) {
-    utils::AVector<TypedValue> result(pull_memory);
+    utils::pmr::vector<TypedValue> result(pull_memory);
     auto last_vertex = midpoint;
     while (true) {
       const auto &last_edge = in_edge.at(last_vertex);
@@ -1049,13 +1048,13 @@ class STShortestPathCursor : public query::plan::Cursor {
     auto *pull_memory = evaluator->GetMemoryResource();
     // Holds vertices at the current level of expansion from the source
     // (sink).
-    utils::AVector<VertexAccessor> source_frontier(pull_memory);
-    utils::AVector<VertexAccessor> sink_frontier(pull_memory);
+    utils::pmr::vector<VertexAccessor> source_frontier(pull_memory);
+    utils::pmr::vector<VertexAccessor> sink_frontier(pull_memory);
 
     // Holds vertices we can expand to from `source_frontier`
     // (`sink_frontier`).
-    utils::AVector<VertexAccessor> source_next(pull_memory);
-    utils::AVector<VertexAccessor> sink_next(pull_memory);
+    utils::pmr::vector<VertexAccessor> source_next(pull_memory);
+    utils::pmr::vector<VertexAccessor> sink_next(pull_memory);
 
     // Maps each vertex we visited expanding from the source (sink) to the
     // edge used. Necessary for path reconstruction.
@@ -1279,7 +1278,7 @@ class SingleSourceShortestPathCursor : public query::plan::Cursor {
 
       // create the frame value for the edges
       auto *pull_memory = context.evaluation_context.memory;
-      utils::AVector<TypedValue> edge_list(pull_memory);
+      utils::pmr::vector<TypedValue> edge_list(pull_memory);
       edge_list.emplace_back(expansion.first);
       auto last_vertex = expansion.second;
       while (true) {
@@ -1330,14 +1329,11 @@ class SingleSourceShortestPathCursor : public query::plan::Cursor {
   // maps vertices to the edge they got expanded from. it is an optional
   // edge because the root does not get expanded from anything.
   // contains visited vertices as well as those scheduled to be visited.
-  std::unordered_map<VertexAccessor, std::optional<EdgeAccessor>,
-                     std::hash<VertexAccessor>, std::equal_to<>,
-                     utils::Allocator<std::pair<const VertexAccessor,
-                                                std::optional<EdgeAccessor>>>>
+  utils::pmr::unordered_map<VertexAccessor, std::optional<EdgeAccessor>>
       processed_;
   // edge/vertex pairs we have yet to visit, for current and next depth
-  utils::AVector<std::pair<EdgeAccessor, VertexAccessor>> to_visit_current_;
-  utils::AVector<std::pair<EdgeAccessor, VertexAccessor>> to_visit_next_;
+  utils::pmr::vector<std::pair<EdgeAccessor, VertexAccessor>> to_visit_current_;
+  utils::pmr::vector<std::pair<EdgeAccessor, VertexAccessor>> to_visit_next_;
 };
 
 class ExpandWeightedShortestPathCursor : public query::plan::Cursor {
@@ -1490,7 +1486,7 @@ class ExpandWeightedShortestPathCursor : public query::plan::Cursor {
         auto last_vertex = current_vertex;
         auto last_depth = current_depth;
         auto *pull_memory = context.evaluation_context.memory;
-        utils::AVector<TypedValue> edge_list(pull_memory);
+        utils::pmr::vector<TypedValue> edge_list(pull_memory);
         while (true) {
           // Origin_vertex must be in previous.
           const auto &previous_edge =
@@ -1553,23 +1549,17 @@ class ExpandWeightedShortestPathCursor : public query::plan::Cursor {
   };
 
   // Maps vertices to weights they got in expansion.
-  std::unordered_map<
-      std::pair<VertexAccessor, int>, TypedValue, WspStateHash, std::equal_to<>,
-      utils::Allocator<
-          std::pair<const std::pair<VertexAccessor, int>, TypedValue>>>
+  utils::pmr::unordered_map<std::pair<VertexAccessor, int>, TypedValue,
+                            WspStateHash>
       total_cost_;
 
   // Maps vertices to edges used to reach them.
-  std::unordered_map<std::pair<VertexAccessor, int>,
-                     std::optional<EdgeAccessor>, WspStateHash, std::equal_to<>,
-                     utils::Allocator<std::pair<
-                         const std::pair<VertexAccessor, int>, TypedValue>>>
+  utils::pmr::unordered_map<std::pair<VertexAccessor, int>,
+                            std::optional<EdgeAccessor>, WspStateHash>
       previous_;
 
   // Keeps track of vertices for which we yielded a path already.
-  std::unordered_set<VertexAccessor, std::hash<VertexAccessor>, std::equal_to<>,
-                     utils::Allocator<VertexAccessor>>
-      yielded_vertices_;
+  utils::pmr::unordered_set<VertexAccessor> yielded_vertices_;
 
   // Priority queue comparator. Keep lowest weight on top of the queue.
   class PriorityQueueComparator {
@@ -1584,7 +1574,7 @@ class ExpandWeightedShortestPathCursor : public query::plan::Cursor {
 
   std::priority_queue<
       std::tuple<double, int, VertexAccessor, std::optional<EdgeAccessor>>,
-      utils::AVector<
+      utils::pmr::vector<
           std::tuple<double, int, VertexAccessor, std::optional<EdgeAccessor>>>,
       PriorityQueueComparator>
       pq_;
@@ -1829,7 +1819,7 @@ bool Delete::DeleteCursor::Pull(Frame &frame, ExecutionContext &context) {
   // collect expressions results so edges can get deleted before vertices
   // this is necessary because an edge that gets deleted could block vertex
   // deletion
-  utils::AVector<TypedValue> expression_results(pull_memory);
+  utils::pmr::vector<TypedValue> expression_results(pull_memory);
   expression_results.reserve(self_.expressions_.size());
   for (Expression *expression : self_.expressions_) {
     expression_results.emplace_back(expression->Accept(evaluator));
@@ -2291,7 +2281,7 @@ class AccumulateCursor : public Cursor {
     // cache all the input
     if (!pulled_all_input_) {
       while (input_cursor_->Pull(frame, context)) {
-        std::vector<TypedValue, utils::Allocator<TypedValue>> row(
+        utils::pmr::vector<TypedValue> row(
             cache_.get_allocator().GetMemoryResource());
         row.reserve(self_.symbols_.size());
         for (const Symbol &symbol : self_.symbols_)
@@ -2327,10 +2317,7 @@ class AccumulateCursor : public Cursor {
  private:
   const Accumulate &self_;
   const UniqueCursorPtr input_cursor_;
-  std::vector<
-      std::vector<TypedValue, utils::Allocator<TypedValue>>,
-      utils::Allocator<std::vector<TypedValue, utils::Allocator<TypedValue>>>>
-      cache_;
+  utils::pmr::vector<utils::pmr::vector<TypedValue>> cache_;
   decltype(cache_.begin()) cache_it_ = cache_.begin();
   bool pulled_all_input_{false};
 };
@@ -2444,12 +2431,12 @@ class AggregateCursor : public Cursor {
 
     // how many input rows have been aggregated in respective values_ element so
     // far
-    std::vector<int, utils::Allocator<int>> counts_;
+    utils::pmr::vector<int> counts_;
     // aggregated values. Initially Null (until at least one input row with a
     // valid value gets processed)
-    std::vector<TypedValue, utils::Allocator<TypedValue>> values_;
+    utils::pmr::vector<TypedValue> values_;
     // remember values.
-    std::vector<TypedValue, utils::Allocator<TypedValue>> remember_;
+    utils::pmr::vector<TypedValue> remember_;
   };
 
   const Aggregate &self_;
@@ -2457,17 +2444,13 @@ class AggregateCursor : public Cursor {
   // storage for aggregated data
   // map key is the vector of group-by values
   // map value is an AggregationValue struct
-  std::unordered_map<
-      std::vector<TypedValue, utils::Allocator<TypedValue>>, AggregationValue,
-      // use FNV collection hashing specialized for a vector of TypedValues
-      utils::FnvCollection<
-          std::vector<TypedValue, utils::Allocator<TypedValue>>, TypedValue,
-          TypedValue::Hash>,
-      // custom equality
-      TypedValueVectorEqual,
-      utils::Allocator<
-          std::pair<const std::vector<TypedValue, utils::Allocator<TypedValue>>,
-                    AggregationValue>>>
+  utils::pmr::unordered_map<utils::pmr::vector<TypedValue>, AggregationValue,
+                            // use FNV collection hashing specialized for a
+                            // vector of TypedValues
+                            utils::FnvCollection<utils::pmr::vector<TypedValue>,
+                                                 TypedValue, TypedValue::Hash>,
+                            // custom equality
+                            TypedValueVectorEqual>
       aggregation_;
   // iterator over the accumulated cache
   decltype(aggregation_.begin()) aggregation_it_ = aggregation_.begin();
@@ -2513,7 +2496,7 @@ class AggregateCursor : public Cursor {
    */
   void ProcessOne(const Frame &frame, ExpressionEvaluator *evaluator) {
     auto *mem = aggregation_.get_allocator().GetMemoryResource();
-    std::vector<TypedValue, utils::Allocator<TypedValue>> group_by(mem);
+    utils::pmr::vector<TypedValue> group_by(mem);
     group_by.reserve(self_.group_by_.size());
     for (Expression *expression : self_.group_by_) {
       group_by.emplace_back(expression->Accept(*evaluator));
@@ -2851,14 +2834,14 @@ class OrderByCursor : public Cursor {
       auto *mem = cache_.get_allocator().GetMemoryResource();
       while (input_cursor_->Pull(frame, context)) {
         // collect the order_by elements
-        std::vector<TypedValue, utils::Allocator<TypedValue>> order_by(mem);
+        utils::pmr::vector<TypedValue> order_by(mem);
         order_by.reserve(self_.order_by_.size());
         for (auto expression_ptr : self_.order_by_) {
           order_by.emplace_back(expression_ptr->Accept(evaluator));
         }
 
         // collect the output elements
-        std::vector<TypedValue, utils::Allocator<TypedValue>> output(mem);
+        utils::pmr::vector<TypedValue> output(mem);
         output.reserve(self_.output_symbols_.size());
         for (const Symbol &output_sym : self_.output_symbols_)
           output.emplace_back(frame[output_sym]);
@@ -2901,8 +2884,8 @@ class OrderByCursor : public Cursor {
 
  private:
   struct Element {
-    std::vector<TypedValue, utils::Allocator<TypedValue>> order_by;
-    std::vector<TypedValue, utils::Allocator<TypedValue>> remember;
+    utils::pmr::vector<TypedValue> order_by;
+    utils::pmr::vector<TypedValue> remember;
   };
 
   const OrderBy &self_;
@@ -2910,7 +2893,7 @@ class OrderByCursor : public Cursor {
   bool did_pull_all_{false};
   // a cache of elements pulled from the input
   // the cache is filled and sorted (only on first elem) on first Pull
-  std::vector<Element, utils::Allocator<Element>> cache_;
+  utils::pmr::vector<Element> cache_;
   // iterator over the cache_, maintains state between Pulls
   decltype(cache_.begin()) cache_it_ = cache_.begin();
 };
@@ -3150,7 +3133,7 @@ class UnwindCursor : public Cursor {
   const Unwind &self_;
   const UniqueCursorPtr input_cursor_;
   // typed values we are unwinding and yielding
-  std::vector<TypedValue, utils::Allocator<TypedValue>> input_value_;
+  utils::pmr::vector<TypedValue> input_value_;
   // current position in input_value_
   decltype(input_value_)::iterator input_value_it_ = input_value_.end();
 };
@@ -3172,7 +3155,7 @@ class DistinctCursor : public Cursor {
     while (true) {
       if (!input_cursor_->Pull(frame, context)) return false;
 
-      std::vector<TypedValue, utils::Allocator<TypedValue>> row(
+      utils::pmr::vector<TypedValue> row(
           seen_rows_.get_allocator().GetMemoryResource());
       row.reserve(self_.value_symbols_.size());
       for (const auto &symbol : self_.value_symbols_)
@@ -3192,14 +3175,12 @@ class DistinctCursor : public Cursor {
   const Distinct &self_;
   const UniqueCursorPtr input_cursor_;
   // a set of already seen rows
-  std::unordered_set<
-      std::vector<TypedValue, utils::Allocator<TypedValue>>,
-      // use FNV collection hashing specialized for a vector of TypedValue
-      utils::FnvCollection<
-          std::vector<TypedValue, utils::Allocator<TypedValue>>, TypedValue,
-          TypedValue::Hash>,
-      TypedValueVectorEqual,
-      utils::Allocator<std::vector<TypedValue, utils::Allocator<TypedValue>>>>
+  utils::pmr::unordered_set<utils::pmr::vector<TypedValue>,
+                            // use FNV collection hashing specialized for a
+                            // vector of TypedValue
+                            utils::FnvCollection<utils::pmr::vector<TypedValue>,
+                                                 TypedValue, TypedValue::Hash>,
+                            TypedValueVectorEqual>
       seen_rows_;
 };
 
@@ -3266,10 +3247,8 @@ Union::UnionCursor::UnionCursor(const Union &self, utils::MemoryResource *mem)
 bool Union::UnionCursor::Pull(Frame &frame, ExecutionContext &context) {
   SCOPED_PROFILE_OP("Union");
 
-  std::unordered_map<std::string, TypedValue, std::hash<std::string>,
-                     std::equal_to<>,
-                     utils::Allocator<std::pair<const std::string, TypedValue>>>
-      results(context.evaluation_context.memory);
+  utils::pmr::unordered_map<std::string, TypedValue> results(
+      context.evaluation_context.memory);
   if (left_cursor_->Pull(frame, context)) {
     // collect values from the left child
     for (const auto &output_symbol : self_.left_symbols_) {
@@ -3395,11 +3374,12 @@ class CartesianCursor : public Cursor {
 
  private:
   const Cartesian &self_;
-  utils::AVector<utils::AVector<TypedValue>> left_op_frames_;
-  utils::AVector<TypedValue> right_op_frame_;
+  utils::pmr::vector<utils::pmr::vector<TypedValue>> left_op_frames_;
+  utils::pmr::vector<TypedValue> right_op_frame_;
   const UniqueCursorPtr left_op_cursor_;
   const UniqueCursorPtr right_op_cursor_;
-  utils::AVector<utils::AVector<TypedValue>>::iterator left_op_frames_it_;
+  utils::pmr::vector<utils::pmr::vector<TypedValue>>::iterator
+      left_op_frames_it_;
   bool cartesian_pull_initialized_{false};
 };
 
diff --git a/src/query/typed_value.hpp b/src/query/typed_value.hpp
index 8119fc61c..d697f03ec 100644
--- a/src/query/typed_value.hpp
+++ b/src/query/typed_value.hpp
@@ -15,6 +15,9 @@
 #include "storage/vertex_accessor.hpp"
 #include "utils/exceptions.hpp"
 #include "utils/memory.hpp"
+#include "utils/pmr/map.hpp"
+#include "utils/pmr/string.hpp"
+#include "utils/pmr/vector.hpp"
 
 namespace query {
 
@@ -68,22 +71,15 @@ class TypedValue {
     Path
   };
 
-  /** Concrete value type of character string */
-  using TString =
-      std::basic_string<char, std::char_traits<char>, utils::Allocator<char>>;
-
   // TypedValue at this exact moment of compilation is an incomplete type, and
   // the standard says that instantiating a container with an incomplete type
   // invokes undefined behaviour. The libstdc++-8.3.0 we are using supports
   // std::map with incomplete type, but this is still murky territory. Note that
   // since C++17, std::vector is explicitly said to support incomplete types.
 
-  // Use transparent std::less<void> which forwards to `operator<`, so that it's
-  // possible to use `find` with C-style (null terminated) strings without
-  // actually constructing (and allocating) a key.
-  using TMap = std::map<TString, TypedValue, std::less<void>,
-                        utils::Allocator<std::pair<const TString, TypedValue>>>;
-  using TVector = std::vector<TypedValue, utils::Allocator<TypedValue>>;
+  using TString = utils::pmr::string;
+  using TVector = utils::pmr::vector<TypedValue>;
+  using TMap = utils::pmr::map<utils::pmr::string, TypedValue>;
 
   /** Allocator type so that STL containers are aware that we need one */
   using allocator_type = utils::Allocator<TypedValue>;
diff --git a/src/utils/memory.hpp b/src/utils/memory.hpp
index 567665fa1..1317117b0 100644
--- a/src/utils/memory.hpp
+++ b/src/utils/memory.hpp
@@ -262,9 +262,6 @@ bool operator!=(const Allocator<T> &a, const Allocator<U> &b) {
   return !(a == b);
 }
 
-template <class T>
-using AVector = std::vector<T, Allocator<T>>;
-
 /// Wraps std::pmr::memory_resource for use with out MemoryResource
 class StdMemoryResource final : public MemoryResource {
  public:
@@ -410,6 +407,9 @@ class MonotonicBufferResource final : public MemoryResource {
 
 namespace impl {
 
+template <class T>
+using AVector = std::vector<T, Allocator<T>>;
+
 /// Holds a number of Chunks each serving blocks of particular size. When a
 /// Chunk runs out of available blocks, a new Chunk is allocated. The naming is
 /// taken from `libstdc++` implementation, but the implementation details are
@@ -532,11 +532,11 @@ class PoolResource final : public MemoryResource {
   // `impl::Pool` stores a `chunks_` vector.
 
   // Pools are sorted by bound_size_, ascending.
-  AVector<impl::Pool> pools_;
+  impl::AVector<impl::Pool> pools_;
   impl::Pool *last_alloc_pool_{nullptr};
   impl::Pool *last_dealloc_pool_{nullptr};
   // Unpooled BigBlocks are sorted by data pointer.
-  AVector<BigBlock> unpooled_;
+  impl::AVector<BigBlock> unpooled_;
   size_t max_blocks_per_chunk_;
   size_t max_block_size_;
 
diff --git a/src/utils/pmr/list.hpp b/src/utils/pmr/list.hpp
new file mode 100644
index 000000000..efdd6065e
--- /dev/null
+++ b/src/utils/pmr/list.hpp
@@ -0,0 +1,12 @@
+#pragma once
+
+#include <list>
+
+#include "utils/memory.hpp"
+
+namespace utils::pmr {
+
+template <class T>
+using list = std::list<T, utils::Allocator<T>>;
+
+}  // namespace utils::pmr
diff --git a/src/utils/pmr/map.hpp b/src/utils/pmr/map.hpp
new file mode 100644
index 000000000..66d70e4a7
--- /dev/null
+++ b/src/utils/pmr/map.hpp
@@ -0,0 +1,16 @@
+#pragma once
+
+#include <map>
+
+#include "utils/memory.hpp"
+
+namespace utils::pmr {
+
+// Use transparent std::less<void> which forwards to `operator<`, so that, for
+// example, it's possible to use `find` with C-style (null terminated) strings
+// without actually constructing (and allocating) a key.
+template <class Key, class T, class Compare = std::less<void>>
+using map =
+    std::map<Key, T, Compare, utils::Allocator<std::pair<const Key, T>>>;
+
+}  // namespace utils::pmr
diff --git a/src/utils/pmr/string.hpp b/src/utils/pmr/string.hpp
new file mode 100644
index 000000000..3f782caff
--- /dev/null
+++ b/src/utils/pmr/string.hpp
@@ -0,0 +1,12 @@
+#pragma once
+
+#include <string>
+
+#include "utils/memory.hpp"
+
+namespace utils::pmr {
+
+using string =
+    std::basic_string<char, std::char_traits<char>, utils::Allocator<char>>;
+
+}  // namespace utils::pmr
diff --git a/src/utils/pmr/unordered_map.hpp b/src/utils/pmr/unordered_map.hpp
new file mode 100644
index 000000000..98f710f36
--- /dev/null
+++ b/src/utils/pmr/unordered_map.hpp
@@ -0,0 +1,18 @@
+#pragma once
+
+#include <unordered_map>
+
+#include "utils/memory.hpp"
+
+namespace utils::pmr {
+
+// Use transparent std::equal_to<void> which forwards to `operator==`, so that,
+// for example, it's possible to use `find` with C-style (null terminated)
+// strings without actually constructing (and allocating) a key.
+template <class Key, class T, class Hash = std::hash<Key>,
+          class Pred = std::equal_to<void>>
+using unordered_map =
+    std::unordered_map<Key, T, Hash, Pred,
+                       utils::Allocator<std::pair<const Key, T>>>;
+
+}  // namespace utils::pmr
diff --git a/src/utils/pmr/unordered_set.hpp b/src/utils/pmr/unordered_set.hpp
new file mode 100644
index 000000000..71af94ac5
--- /dev/null
+++ b/src/utils/pmr/unordered_set.hpp
@@ -0,0 +1,17 @@
+#pragma once
+
+#include <unordered_set>
+
+#include "utils/memory.hpp"
+
+namespace utils::pmr {
+
+// Use transparent std::equal_to<void> which forwards to `operator==`, so that,
+// for example, it's possible to use `find` with C-style (null terminated)
+// strings without actually constructing (and allocating) a key.
+template <class Key, class Hash = std::hash<Key>,
+          class Pred = std::equal_to<void>>
+using unordered_set =
+    std::unordered_set<Key, Hash, Pred, utils::Allocator<Key>>;
+
+}  // namespace utils::pmr
diff --git a/src/utils/pmr/vector.hpp b/src/utils/pmr/vector.hpp
new file mode 100644
index 000000000..5949ccfed
--- /dev/null
+++ b/src/utils/pmr/vector.hpp
@@ -0,0 +1,12 @@
+#pragma once
+
+#include <vector>
+
+#include "utils/memory.hpp"
+
+namespace utils::pmr {
+
+template <class T>
+using vector = std::vector<T, utils::Allocator<T>>;
+
+}  // namespace utils::pmr
diff --git a/tests/unit/query_plan_match_filter_return.cpp b/tests/unit/query_plan_match_filter_return.cpp
index 5d82c751e..2ecde3f08 100644
--- a/tests/unit/query_plan_match_filter_return.cpp
+++ b/tests/unit/query_plan_match_filter_return.cpp
@@ -583,7 +583,7 @@ class QueryPlanExpandVariable : public testing::Test {
     Frame frame(symbol_table.max_position());
     auto cursor = input_op->MakeCursor(utils::NewDeleteResource());
     auto context = MakeContext(storage, symbol_table, &dba_);
-    std::vector<utils::AVector<TypedValue>> results;
+    std::vector<utils::pmr::vector<TypedValue>> results;
     while (cursor->Pull(frame, context))
       results.emplace_back(frame[symbol].ValueList());
     return results;