diff --git a/example/memory_growing.ditto b/example/memory_growing.ditto
new file mode 100644
index 0000000..fa0965e
--- /dev/null
+++ b/example/memory_growing.ditto
@@ -0,0 +1,26 @@
+main: {
+  multithreading: {
+    fork: true,
+    threads: [
+      {
+        name: "MemGrow"
+        instruction: {
+          instruction_set: {
+            instructions: [
+              {
+                  mem_alloc: {
+                    size: 40000000
+                    free_policy: FREE_POLICY_LAST_PERIOD
+                  }
+                  repeat: 10,
+                  period_us: 1000000
+              }
+            ]
+          }
+          repeat: 3
+        }
+      }
+    ]
+  }
+}
+global: {}
diff --git a/include/ditto/instruction.h b/include/ditto/instruction.h
index 5e907a8..8f96d55 100644
--- a/include/ditto/instruction.h
+++ b/include/ditto/instruction.h
@@ -30,6 +30,7 @@
 
 enum class Order { kSequential, kRandom };
 enum class Reseeding { kOnce, kEachRoundOfCycles, kEachCycle };
+enum class FreePolicy { kKeep, kFreeLastPeriod, kFreeEveryPeriod };
 
 class Instruction {
  public:
diff --git a/include/ditto/instruction_factory.h b/include/ditto/instruction_factory.h
index 213eaa3..396ad9f 100644
--- a/include/ditto/instruction_factory.h
+++ b/include/ditto/instruction_factory.h
@@ -41,6 +41,7 @@
   static Order ConvertOrder(dittosuiteproto::Order proto_order);
   static int ConvertReadFAdvise(Order access_order,
                                 dittosuiteproto::ReadFile_ReadFAdvise proto_fadvise);
+  static FreePolicy ConvertFreePolicy(const dittosuiteproto::FreePolicy proto_policy);
 
   static int current_thread_id_;
 };
diff --git a/include/ditto/memory_allocation.h b/include/ditto/memory_allocation.h
index af32220..dd2b633 100644
--- a/include/ditto/memory_allocation.h
+++ b/include/ditto/memory_allocation.h
@@ -14,6 +14,8 @@
 
 #pragma once
 
+#include <stack>
+
 #include <ditto/instruction.h>
 
 namespace dittosuite {
@@ -22,14 +24,17 @@
  public:
   inline static const std::string kName = "memory_allocation";
 
-  explicit MemoryAllocation(const Params& params, const uint64_t size);
+  explicit MemoryAllocation(const Params& params, const uint64_t size,
+                            const FreePolicy free_policy);
   ~MemoryAllocation();
 
  private:
   size_t size_;
-  char* allocated_memory_;
+  dittosuite::FreePolicy free_policy_;
+  std::stack<void*> allocated_addresses_;
 
   void RunSingle();
+  void TearDownSingle(bool is_last);
 };
 
 }  // namespace dittosuite
diff --git a/schema/benchmark.proto b/schema/benchmark.proto
index fbc8169..3941360 100644
--- a/schema/benchmark.proto
+++ b/schema/benchmark.proto
@@ -19,8 +19,16 @@
   READ_WRITE = 3;
 }
 
+enum FreePolicy {
+  FREE_POLICY_UNSPECIFIED = 0;
+  FREE_POLICY_EVERY_PERIOD = 1;
+  FREE_POLICY_LAST_PERIOD = 2;
+  FREE_POLICY_KEEP = 3;
+}
+
 message MemoryAllocate {
   optional uint64 size = 1;
+  optional FreePolicy free_policy = 2 [default = FREE_POLICY_KEEP];
 }
 
 message CpuWork {
diff --git a/src/instruction_factory.cpp b/src/instruction_factory.cpp
index 2009a33..6d4a8a1 100644
--- a/src/instruction_factory.cpp
+++ b/src/instruction_factory.cpp
@@ -299,7 +299,9 @@
     }
     case InstructionType::kMemAlloc: {
       const auto& options = proto_instruction.mem_alloc();
-      return std::make_unique<MemoryAllocation>(instruction_params, options.size());
+
+      dittosuite::FreePolicy free_policy = ConvertFreePolicy(options.free_policy());
+      return std::make_unique<MemoryAllocation>(instruction_params, options.size(), free_policy);
       break;
     }
     case InstructionType::INSTRUCTION_ONEOF_NOT_SET: {
@@ -377,4 +379,18 @@
   }
 }
 
+FreePolicy InstructionFactory::ConvertFreePolicy(const dittosuiteproto::FreePolicy proto_policy) {
+  switch (proto_policy) {
+    case dittosuiteproto::FreePolicy::FREE_POLICY_EVERY_PERIOD:
+      return FreePolicy::kFreeEveryPeriod;
+    case dittosuiteproto::FreePolicy::FREE_POLICY_LAST_PERIOD:
+      return FreePolicy::kFreeLastPeriod;
+    case dittosuiteproto::FreePolicy::FREE_POLICY_KEEP:
+      return FreePolicy::kKeep;
+    default: {
+      LOGF("Invalid FreePolicy");
+    }
+  }
+}
+
 }  // namespace dittosuite
diff --git a/src/memory_allocation.cpp b/src/memory_allocation.cpp
index d54c64a..a37ac47 100644
--- a/src/memory_allocation.cpp
+++ b/src/memory_allocation.cpp
@@ -16,23 +16,59 @@
 
 #include <ditto/logger.h>
 
-#include <unistd.h>
+#include <sys/mman.h>
 
 namespace dittosuite {
 
-MemoryAllocation::MemoryAllocation(const Params& params, const uint64_t size)
-    : Instruction(kName, params), size_(size), allocated_memory_(nullptr) {}
+void allocate_memory(std::stack<void*>* addresses, size_t size) {
+  const int protection = PROT_READ | PROT_WRITE;
+  const int flags = MAP_PRIVATE | MAP_ANONYMOUS | MAP_LOCKED;
+  void* addr = nullptr;
+
+  addr = mmap(NULL, size, protection, flags, -1, 0);
+  if (addr == MAP_FAILED) {
+    PLOGF("mmap failed");
+  }
+
+  addresses->push(addr);
+  LOGD("mmap successful, stack size: " + std::to_string(addresses->size()));
+}
+
+void deallocate_memory(std::stack<void*>* addresses, size_t size) {
+  while (!addresses->empty()) {
+    void* addr = addresses->top();
+    addresses->pop();
+    if (munmap(addr, size) == -1) {
+      PLOGF("munmap failed");
+    }
+    LOGD("munmap successful, stack size: " + std::to_string(addresses->size()));
+  }
+}
+
+MemoryAllocation::MemoryAllocation(const Params& params, const uint64_t size,
+                                   const FreePolicy free_policy)
+    : Instruction(kName, params), size_(size), free_policy_(free_policy) {}
 
 MemoryAllocation::~MemoryAllocation() {
-  free(allocated_memory_);
+  deallocate_memory(&allocated_addresses_, size_);
 }
 
 void MemoryAllocation::RunSingle() {
-  int page_size = getpagesize();
-  allocated_memory_ = static_cast<char*>(malloc(size_));
+  allocate_memory(&allocated_addresses_, size_);
+}
 
-  for (size_t i = 0; i < size_; i += page_size) {
-    allocated_memory_[i] = 1;
+void MemoryAllocation::TearDownSingle(bool is_last) {
+  switch (free_policy_) {
+    case dittosuite::FreePolicy::kKeep:
+      break;
+    case dittosuite::FreePolicy::kFreeEveryPeriod:
+      deallocate_memory(&allocated_addresses_, size_);
+      break;
+    case dittosuite::FreePolicy::kFreeLastPeriod:
+      if (is_last) {
+        deallocate_memory(&allocated_addresses_, size_);
+      }
+      break;
   }
 }