addressed pauls changes

test/src/unit-ReadCellSlabIter.cc

@@ -257,7 +257,7 @@ TEST_CASE_METHOD(
   shared_ptr<FragmentMetadata> fragment = make_shared<FragmentMetadata>(
       HERE(),
       nullptr,
-      ,
+      tiledb::test::create_test_memory_tracker(),
       array_->array_->array_schema_latest_ptr(),
       URI(),
       std::make_pair<uint64_t, uint64_t>(0, 0),

test/src/unit-capi-array.cc

@@ -2586,8 +2586,10 @@ TEST_CASE_METHOD(
       1,
       &buff);
   REQUIRE(rc == TILEDB_OK);
+  auto memory_tracker = ctx_->resources().create_memory_tracker();
   auto st = tiledb::sm::serialization::array_deserialize(
       array->array_.get(),
+      memory_tracker,
       tiledb::sm::SerializationType::CAPNP,
       buff->buffer(),
       ctx_->storage_manager());

test/src/unit-cppapi-schema-evolution.cc

@@ -31,6 +31,7 @@
  */
 
 #include <test/support/tdb_catch.h>
+#include "test/support/src/mem_helpers.h"
 #include "tiledb/sm/array_schema/array_schema.h"
 #include "tiledb/sm/array_schema/array_schema_evolution.h"
 #include "tiledb/sm/array_schema/attribute.h"
@@ -809,7 +810,7 @@ TEST_CASE(
 
   auto schema = make_shared<tiledb::sm::ArraySchema>(
       HERE(),
-      make_shared<tiledb::sm::MemoryTracker>(HERE()),
+      tiledb::test::create_test_memory_tracker(),
       tiledb::sm::ArrayType::SPARSE);
   auto dim = make_shared<tiledb::sm::Dimension>(
       HERE(), "dim1", tiledb::sm::Datatype::INT32);

test/src/unit-enumerations.cc

@@ -32,8 +32,8 @@
 
 #include <sstream>
 
-#include "test/support/tdb_catch.h"
 #include "test/support/src/mem_helpers.h"
+#include "test/support/tdb_catch.h"
 #include "tiledb/common/memory_tracker.h"
 #include "tiledb/sm/array/array.h"
 #include "tiledb/sm/array/array_directory.h"
@@ -1191,7 +1191,7 @@ TEST_CASE_METHOD(
     "ArraySchema - Add Enumeration - Enumeration nullptr Error",
     "[enumeration][array-schema][error]") {
   auto schema = make_shared<ArraySchema>(
-      HERE(), create_test_memory_tracker(), ArrayType::DENSE);
+      HERE(), tiledb::test::create_test_memory_tracker(), ArrayType::DENSE);
   REQUIRE_THROWS(schema->add_enumeration(nullptr));
 }
 
@@ -1200,7 +1200,7 @@ TEST_CASE_METHOD(
     "ArraySchema - Add Basic Enumeration",
     "[enumeration][array-schema][basic]") {
   auto schema = make_shared<ArraySchema>(
-      HERE(), create_test_memory_tracker(), ArrayType::DENSE);
+      HERE(), tiledb::test::create_test_memory_tracker(), ArrayType::DENSE);
 
   std::vector<int> values = {1, 2, 3, 4, 5};
   auto enmr = create_enumeration(values);
@@ -1216,7 +1216,7 @@ TEST_CASE_METHOD(
     "ArraySchema - Get Enumeration",
     "[enumeration][array-schema][get]") {
   auto schema = make_shared<ArraySchema>(
-      HERE(), create_test_memory_tracker(), ArrayType::DENSE);
+      HERE(), tiledb::test::create_test_memory_tracker(), ArrayType::DENSE);
 
   std::vector<int> values = {1, 2, 3, 4, 5};
   auto enmr1 = create_enumeration(values);
@@ -1231,7 +1231,7 @@ TEST_CASE_METHOD(
     "ArraySchema - Get Missing Enumeration Error",
     "[enumeration][array-schema][error]") {
   auto schema = make_shared<ArraySchema>(
-      HERE(), create_test_memory_tracker(), ArrayType::SPARSE);
+      HERE(), tiledb::test::create_test_memory_tracker(), ArrayType::SPARSE);
   REQUIRE_THROWS(schema->get_enumeration("not_an_enumeration"));
 }
 
@@ -1240,7 +1240,7 @@ TEST_CASE_METHOD(
     "ArraySchema - Add Enumeration with Existing Enumeration of same Name",
     "[enumeration][array-schema][eror]") {
   auto schema = make_shared<ArraySchema>(
-      HERE(), create_test_memory_tracker(), ArrayType::SPARSE);
+      HERE(), tiledb::test::create_test_memory_tracker(), ArrayType::SPARSE);
   std::vector<int> values = {1, 2, 3, 4, 5};
   auto enmr = create_enumeration(values);
 
@@ -1253,7 +1253,7 @@ TEST_CASE_METHOD(
     "ArraySchema - Add Attribute with Missing Enumeration Error",
     "[enumeration][array-schema][eror]") {
   auto schema = make_shared<ArraySchema>(
-      HERE(), create_test_memory_tracker(), ArrayType::SPARSE);
+      HERE(), tiledb::test::create_test_memory_tracker(), ArrayType::SPARSE);
   auto attr = make_shared<Attribute>(HERE(), "an_attr", Datatype::INT32);
   attr->set_enumeration_name("not_an_enumeration");
   REQUIRE(!schema->add_attribute(attr).ok());
@@ -1264,7 +1264,7 @@ TEST_CASE_METHOD(
     "ArraySchema - Get All Enumeration Names Empty",
     "[enumeration][array-schema][get-all][empty]") {
   auto schema = make_shared<ArraySchema>(
-      HERE(), create_test_memory_tracker(), ArrayType::DENSE);
+      HERE(), tiledb::test::create_test_memory_tracker(), ArrayType::DENSE);
   auto enmr_names = schema->get_enumeration_names();
   REQUIRE(enmr_names.size() == 0);
 }
@@ -1274,7 +1274,7 @@ TEST_CASE_METHOD(
     "ArraySchema - Get All Enumeration Names",
     "[enumeration][array-schema][get-all]") {
   auto schema = make_shared<ArraySchema>(
-      HERE(), create_test_memory_tracker(), ArrayType::DENSE);
+      HERE(), tiledb::test::create_test_memory_tracker(), ArrayType::DENSE);
 
   std::vector<float> values = {1.0f, 1.1f, 1.2f, 1.3f, 1.4f};
   auto enmr1 = create_enumeration(values);
@@ -1294,7 +1294,7 @@ TEST_CASE_METHOD(
     "ArraySchema - Attribute with Invalid Datatype",
     "[enumeration][array-schema][error][bad-attr-datatype]") {
   auto schema = make_shared<ArraySchema>(
-      HERE(), create_test_memory_tracker(), ArrayType::DENSE);
+      HERE(), tiledb::test::create_test_memory_tracker(), ArrayType::DENSE);
 
   std::vector<int> values = {1, 2, 3, 4, 5};
   auto enmr = create_enumeration(values);
@@ -1310,7 +1310,7 @@ TEST_CASE_METHOD(
     "ArraySchema - Attribute with Invalid Cell Val Num",
     "[enumeration][array-schema][error][bad-attr-cell-val-num]") {
   auto schema = make_shared<ArraySchema>(
-      HERE(), create_test_memory_tracker(), ArrayType::DENSE);
+      HERE(), tiledb::test::create_test_memory_tracker(), ArrayType::DENSE);
 
   std::vector<int> values = {1, 2, 3, 4, 5};
   auto enmr = create_enumeration(values);
@@ -1327,7 +1327,7 @@ TEST_CASE_METHOD(
     "ArraySchema - Store nullptr Enumeration Error",
     "[enumeration][array-schema][error][store-nullptr-enumeration]") {
   auto schema = make_shared<ArraySchema>(
-      HERE(), create_test_memory_tracker(), ArrayType::DENSE);
+      HERE(), tiledb::test::create_test_memory_tracker(), ArrayType::DENSE);
   REQUIRE_THROWS(schema->store_enumeration(nullptr));
 }
 
@@ -1336,7 +1336,7 @@ TEST_CASE_METHOD(
     "ArraySchema - Store Enumeration Error",
     "[enumeration][array-schema][error][store-unknown-enumeration]") {
   auto schema = make_shared<ArraySchema>(
-      HERE(), create_test_memory_tracker(), ArrayType::DENSE);
+      HERE(), tiledb::test::create_test_memory_tracker(), ArrayType::DENSE);
   std::vector<int> values = {1, 2, 3, 4, 5};
   auto enmr =
       create_enumeration(values, false, Datatype::INT32, "unknown_enmr");
@@ -1348,7 +1348,7 @@ TEST_CASE_METHOD(
     "ArraySchema - Store Enumeration Error - Already Loaded",
     "[enumeration][array-schema][error][store-loaded-enumeration]") {
   auto schema = make_shared<ArraySchema>(
-      HERE(), create_test_memory_tracker(), ArrayType::DENSE);
+      HERE(), tiledb::test::create_test_memory_tracker(), ArrayType::DENSE);
 
   std::vector<uint32_t> values = {0, 1, 2, 100000000};
   auto enmr = create_enumeration(values);
@@ -1365,7 +1365,7 @@ TEST_CASE_METHOD(
     "ArraySchema - Attribute Get Enumeration Name From Attribute",
     "[enumeration][array-schema][has-enumeration]") {
   auto schema = make_shared<ArraySchema>(
-      HERE(), create_test_memory_tracker(), ArrayType::SPARSE);
+      HERE(), tiledb::test::create_test_memory_tracker(), ArrayType::SPARSE);
 
   std::vector<std::string> values = {"a", "spot", "of", "tea", "perhaps?"};
   auto enmr = create_enumeration(values);
@@ -2687,7 +2687,7 @@ std::vector<T> EnumerationFx::as_vector(shared_ptr<const Enumeration> enmr) {
 shared_ptr<ArraySchema> EnumerationFx::create_schema() {
   // Create a schema to serialize
   auto schema = make_shared<ArraySchema>(
-      HERE(), create_test_memory_tracker(), ArrayType::SPARSE);
+      HERE(), tiledb::test::create_test_memory_tracker(), ArrayType::SPARSE);
 
   auto dim = make_shared<Dimension>(HERE(), "dim1", Datatype::INT32);
   int range[2] = {0, 1000};
@@ -2751,7 +2751,8 @@ shared_ptr<ArraySchema> EnumerationFx::ser_des_array_schema(
   Buffer buf;
   throw_if_not_ok(serialization::array_schema_serialize(
       *(schema.get()), stype, &buf, client_side));
-  return serialization::array_schema_deserialize(stype, buf);
+  return serialization::array_schema_deserialize(
+      stype, tiledb::test::create_test_memory_tracker(), buf);
 }
 
 shared_ptr<ArraySchemaEvolution> EnumerationFx::ser_des_array_schema_evolution(
@@ -2794,8 +2795,12 @@ void EnumerationFx::ser_des_array(
     SerializationType stype) {
   Buffer buf;
   throw_if_not_ok(serialization::array_serialize(in, stype, &buf, client_side));
-  throw_if_not_ok(
-      serialization::array_deserialize(out, stype, buf, ctx.storage_manager()));
+  throw_if_not_ok(serialization::array_deserialize(
+      out,
+      tiledb::test::create_test_memory_tracker(),
+      stype,
+      buf,
+      ctx.storage_manager()));
 }
 
 #else  // No TILEDB_SERIALIZATION

test/src/unit-filter-pipeline.cc

@@ -404,7 +404,7 @@ TEST_CASE("Filter: Test compression", "[filter][compression]") {
   auto domain{make_shared<tiledb::sm::Domain>(HERE())};
   CHECK(domain->add_dimension(dim).ok());
   tiledb::sm::ArraySchema schema(
-      create_test_memory_tracker(), ArrayType::DENSE);
+      tiledb::test::create_test_memory_tracker(), ArrayType::DENSE);
   tiledb::sm::Attribute attr("attr", Datatype::UINT64);
   CHECK(schema.add_attribute(make_shared<tiledb::sm::Attribute>(HERE(), attr))
             .ok());
@@ -530,7 +530,7 @@ TEST_CASE("Filter: Test compression var", "[filter][compression][var]") {
   auto domain{make_shared<tiledb::sm::Domain>(HERE())};
   CHECK(domain->add_dimension(dim).ok());
   tiledb::sm::ArraySchema schema(
-      create_test_memory_tracker(), ArrayType::DENSE);
+      tiledb::test::create_test_memory_tracker(), ArrayType::DENSE);
   tiledb::sm::Attribute attr("attr", Datatype::UINT64);
   CHECK(schema.add_attribute(make_shared<tiledb::sm::Attribute>(HERE(), attr))
             .ok());

test/src/unit-request-handlers.cc

@@ -32,9 +32,10 @@
 
 #ifdef TILEDB_SERIALIZATION
 
-#include "test/support/tdb_catch.h"
 #include "test/support/src/mem_helpers.h"
+#include "test/support/tdb_catch.h"
 #include "tiledb/api/c_api/buffer/buffer_api_internal.h"
+#include "tiledb/api/c_api/context/context_api_internal.h"
 #include "tiledb/api/c_api/string/string_api_internal.h"
 #include "tiledb/sm/array_schema/enumeration.h"
 #include "tiledb/sm/c_api/tiledb_serialization.h"
@@ -96,7 +97,7 @@ struct HandleConsolidationPlanRequestFx : RequestHandlerFx {
 
   virtual shared_ptr<ArraySchema> create_schema() override {
     auto schema = make_shared<ArraySchema>(
-        HERE(), create_test_memory_tracker(), ArrayType::SPARSE);
+        HERE(), tiledb::test::create_test_memory_tracker(), ArrayType::SPARSE);
     auto dim = make_shared<Dimension>(HERE(), "dim1", Datatype::INT32);
     int range[2] = {0, 1000};
     throw_if_not_ok(dim->set_domain(range));
@@ -397,7 +398,7 @@ HandleLoadArraySchemaRequestFx::create_string_enumeration(
 shared_ptr<ArraySchema> HandleLoadArraySchemaRequestFx::create_schema() {
   // Create a schema to serialize
   auto schema = make_shared<ArraySchema>(
-      HERE(), create_test_memory_tracker(), ArrayType::SPARSE);
+      HERE(), tiledb::test::create_test_memory_tracker(), ArrayType::SPARSE);
   auto dim = make_shared<Dimension>(HERE(), "dim1", Datatype::INT32);
   int range[2] = {0, 1000};
   throw_if_not_ok(dim->set_domain(range));
@@ -438,13 +439,15 @@ shared_ptr<ArraySchema> HandleLoadArraySchemaRequestFx::call_handler(
       resp_buf);
   REQUIRE(rval == TILEDB_OK);
 
+  auto memory_tracker =
+      ctx.ptr()->context().resources().create_memory_tracker();
   return serialization::deserialize_load_array_schema_response(
-      stype, resp_buf->buffer());
+      stype, memory_tracker, resp_buf->buffer());
 }
 
 shared_ptr<ArraySchema> HandleQueryPlanRequestFx::create_schema() {
   auto schema = make_shared<ArraySchema>(
-      HERE(), create_test_memory_tracker(), ArrayType::DENSE);
+      HERE(), tiledb::test::create_test_memory_tracker(), ArrayType::DENSE);
   schema->set_capacity(10000);
   throw_if_not_ok(schema->set_cell_order(Layout::ROW_MAJOR));
   throw_if_not_ok(schema->set_tile_order(Layout::ROW_MAJOR));

test/src/unit-tile-metadata-generator.cc

@@ -82,7 +82,8 @@ TEMPLATE_LIST_TEST_CASE(
 
   // Generate the array schema.
   uint64_t num_cells = empty_tile ? 0 : 1000;
-  ArraySchema schema(create_test_memory_tracker(), ArrayType::DENSE);
+  ArraySchema schema(
+      tiledb::test::create_test_memory_tracker(), ArrayType::DENSE);
   schema.set_capacity(num_cells);
   Attribute a("a", tiledb_type);
   a.set_cell_val_num(cell_val_num);
@@ -260,7 +261,8 @@ TEMPLATE_LIST_TEST_CASE(
   auto type = tiledb::impl::type_to_tiledb<T>();
 
   // Generate the array schema.
-  ArraySchema schema(create_test_memory_tracker(), ArrayType::DENSE);
+  ArraySchema schema(
+      tiledb::test::create_test_memory_tracker(), ArrayType::DENSE);
   schema.set_capacity(4);
   Attribute a("a", (Datatype)type.tiledb_type);
   CHECK(schema.add_attribute(make_shared<Attribute>(HERE(), a)).ok());
@@ -335,7 +337,8 @@ TEST_CASE(
 
   // Generate the array schema.
   uint64_t num_cells = empty_tile ? 0 : 20;
-  ArraySchema schema(create_test_memory_tracker(), ArrayType::DENSE);
+  ArraySchema schema(
+      tiledb::test::create_test_memory_tracker(), ArrayType::DENSE);
   schema.set_capacity(num_cells);
   Attribute a("a", Datatype::STRING_ASCII);
   a.set_cell_val_num(constants::var_num);
@@ -435,7 +438,8 @@ TEST_CASE(
     "TileMetadataGenerator: var data tiles same string, different lengths",
     "[tile-metadata-generator][var-data][same-length]") {
   // Generate the array schema.
-  ArraySchema schema(create_test_memory_tracker(), ArrayType::DENSE);
+  ArraySchema schema(
+      tiledb::test::create_test_memory_tracker(), ArrayType::DENSE);
   schema.set_capacity(2);
   Attribute a("a", Datatype::CHAR);
   a.set_cell_val_num(constants::var_num);

test/support/src/helpers.cc

@@ -1591,6 +1591,7 @@ int array_open_wrapper(
   // in the same way that rest_client does.
   auto st = tiledb::sm::serialization::array_deserialize(
       (*open_array)->array_.get(),
+      create_test_memory_tracker(),
       tiledb::sm::SerializationType::CAPNP,
       buff->buffer(),
       client_ctx->storage_manager());

tiledb/common/memory_tracker.h

@@ -124,9 +124,11 @@ enum class MemoryTrackerType {
   ARRAY_LOAD,
   ARRAY_READ,
   ARRAY_WRITE,
+  FRAGMENT_INFO_LOAD,
   QUERY_READ,
   QUERY_WRITE,
-  CONSOLIDATOR
+  CONSOLIDATOR,
+  REST_CLIENT
 };
 
 class MemoryTrackerResource : public tdb::pmr::memory_resource {

tiledb/sm/array_schema/array_schema.cc

@@ -1062,7 +1062,14 @@ void ArraySchema::add_dimension_label(
 
     // Create the dimension label reference.
     auto dim_label_ref = make_shared<DimensionLabel>(
-        HERE(), memory_tracker_, dim_id, name, uri, dim, label_order, label_type);
+        HERE(),
+        memory_tracker_,
+        dim_id,
+        name,
+        uri,
+        dim,
+        label_order,
+        label_type);
     dimension_labels_.emplace_back(dim_label_ref);
     dimension_label_map_[name] = dim_label_ref.get();
   } catch (...) {
@@ -1290,7 +1297,7 @@ void ArraySchema::drop_enumeration(const std::string& enmr_name) {
 
 // #TODO Add security validation on incoming URI
 shared_ptr<ArraySchema> ArraySchema::deserialize(
-    Deserializer& deserializer, 
+    Deserializer& deserializer,
     shared_ptr<MemoryTracker> memory_tracker,
     const URI& uri) {
   Status st;

tiledb/sm/array_schema/array_schema.h

@@ -479,7 +479,7 @@ class ArraySchema {
    * @return A new ArraySchema.
    */
   static shared_ptr<ArraySchema> deserialize(
-      Deserializer& deserializer, 
+      Deserializer& deserializer,
       shared_ptr<MemoryTracker> memory_tracker,
       const URI& uri);