diff --git a/benchmarks/Android.bp b/benchmarks/Android.bp
index a7be965..b4176de 100644
--- a/benchmarks/Android.bp
+++ b/benchmarks/Android.bp
@@ -33,6 +33,7 @@
         "get_heap_size_benchmark.cpp",
         "inttypes_benchmark.cpp",
         "malloc_benchmark.cpp",
+        "malloc_sql_benchmark.cpp",
         "math_benchmark.cpp",
         "property_benchmark.cpp",
         "pthread_benchmark.cpp",
diff --git a/benchmarks/malloc_benchmark.cpp b/benchmarks/malloc_benchmark.cpp
index ca54f11..18ba523 100644
--- a/benchmarks/malloc_benchmark.cpp
+++ b/benchmarks/malloc_benchmark.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2018 The Android Open Source Project
+ * Copyright (C) 2019 The Android Open Source Project
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -27,102 +27,46 @@
  */
 
 #include <malloc.h>
-#include <stdlib.h>
+#include <unistd.h>
+
+#include <vector>
 
 #include <benchmark/benchmark.h>
 #include "util.h"
 
 #if defined(__BIONIC__)
 
-enum AllocEnum : uint8_t {
-  MALLOC = 0,
-  CALLOC,
-  MEMALIGN,
-  REALLOC,
-  FREE,
-};
-
-struct MallocEntry {
-  AllocEnum type;
-  size_t idx;
-  size_t size;
-  size_t arg2;
-};
-
-void BenchmarkMalloc(MallocEntry entries[], size_t total_entries, size_t max_allocs) {
-  void* ptrs[max_allocs];
-
-  for (size_t i = 0; i < total_entries; i++) {
-    switch (entries[i].type) {
-    case MALLOC:
-      ptrs[entries[i].idx] = malloc(entries[i].size);
-      // Touch at least one byte of the allocation to make sure that
-      // PSS for this allocation is counted.
-      reinterpret_cast<uint8_t*>(ptrs[entries[i].idx])[0] = 10;
-      break;
-    case CALLOC:
-      ptrs[entries[i].idx] = calloc(entries[i].arg2, entries[i].size);
-      // Touch at least one byte of the allocation to make sure that
-      // PSS for this allocation is counted.
-      reinterpret_cast<uint8_t*>(ptrs[entries[i].idx])[0] = 20;
-      break;
-    case MEMALIGN:
-      ptrs[entries[i].idx] = memalign(entries[i].arg2, entries[i].size);
-      // Touch at least one byte of the allocation to make sure that
-      // PSS for this allocation is counted.
-      reinterpret_cast<uint8_t*>(ptrs[entries[i].idx])[0] = 30;
-      break;
-    case REALLOC:
-      if (entries[i].arg2 == 0) {
-        ptrs[entries[i].idx] = realloc(nullptr, entries[i].size);
-      } else {
-        ptrs[entries[i].idx] = realloc(ptrs[entries[i].arg2 - 1], entries[i].size);
-      }
-      // Touch at least one byte of the allocation to make sure that
-      // PSS for this allocation is counted.
-      reinterpret_cast<uint8_t*>(ptrs[entries[i].idx])[0] = 40;
-      break;
-    case FREE:
-      free(ptrs[entries[i].idx]);
-      break;
-    }
-  }
-}
-
-// This codifies playing back a single threaded trace of the allocations
-// when running the SQLite BenchMark app.
-// Instructions for recreating:
-//   - Enable malloc debug
-//       setprop wrap.com.wtsang02.sqliteutil "LIBC_DEBUG_MALLOC_OPTIONS=record_allocs logwrapper"
-//   - Start the SQLite BenchMark app
-//   - Dump allocs using the signal to get rid of non sql allocs(kill -47 <SQLITE_PID>)
-//   - Run the benchmark.
-//   - Dump allocs using the signal again.
-//   - Find the thread that has the most allocs and run the helper script
-//       bionic/libc/malloc_debug/tools/gen_malloc.pl -i <THREAD_ID> g_sql_entries kMaxSqlAllocSlots < <ALLOC_FILE> > malloc_sql.h
-#include "malloc_sql.h"
-
-static void BM_malloc_sql_trace_default(benchmark::State& state) {
-  // The default is expected to be a zero decay time.
-  mallopt(M_DECAY_TIME, 0);
-
-  for (auto _ : state) {
-    BenchmarkMalloc(g_sql_entries, sizeof(g_sql_entries) / sizeof(MallocEntry),
-                    kMaxSqlAllocSlots);
-  }
-}
-BIONIC_BENCHMARK(BM_malloc_sql_trace_default);
-
-static void BM_malloc_sql_trace_decay1(benchmark::State& state) {
+static void BM_mallopt_purge(benchmark::State& state) {
+  static size_t sizes[] = {8, 16, 32, 64, 128, 1024, 4096, 16384, 65536, 131072, 1048576};
+  static int pagesize = getpagesize();
   mallopt(M_DECAY_TIME, 1);
-
+  mallopt(M_PURGE, 0);
   for (auto _ : state) {
-    BenchmarkMalloc(g_sql_entries, sizeof(g_sql_entries) / sizeof(MallocEntry),
-                    kMaxSqlAllocSlots);
-  }
+    state.PauseTiming();
+    std::vector<void*> ptrs;
+    for (auto size : sizes) {
+      // Allocate at least two pages worth of the allocations.
+      for (size_t allocated = 0; allocated < 2 * static_cast<size_t>(pagesize); allocated += size) {
+        void* ptr = malloc(size);
+        if (ptr == nullptr) {
+          state.SkipWithError("Failed to allocate memory");
+        }
+        MakeAllocationResident(ptr, size, pagesize);
+        ptrs.push_back(ptr);
+      }
+    }
+    // Free the memory, which should leave many of the pages resident until
+    // the purge call.
+    for (auto ptr : ptrs) {
+      free(ptr);
+    }
+    ptrs.clear();
+    state.ResumeTiming();
 
+    mallopt(M_PURGE, 0);
+  }
   mallopt(M_DECAY_TIME, 0);
 }
-BIONIC_BENCHMARK(BM_malloc_sql_trace_decay1);
+BIONIC_BENCHMARK(BM_mallopt_purge);
 
 #endif
diff --git a/benchmarks/malloc_sql_benchmark.cpp b/benchmarks/malloc_sql_benchmark.cpp
new file mode 100644
index 0000000..383325c
--- /dev/null
+++ b/benchmarks/malloc_sql_benchmark.cpp
@@ -0,0 +1,129 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <malloc.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include <benchmark/benchmark.h>
+#include "util.h"
+
+#if defined(__BIONIC__)
+
+enum AllocEnum : uint8_t {
+  MALLOC = 0,
+  CALLOC,
+  MEMALIGN,
+  REALLOC,
+  FREE,
+};
+
+struct MallocEntry {
+  AllocEnum type;
+  size_t idx;
+  size_t size;
+  size_t arg2;
+};
+
+void BenchmarkMalloc(MallocEntry entries[], size_t total_entries, size_t max_allocs) {
+  void* ptrs[max_allocs];
+
+  for (size_t i = 0; i < total_entries; i++) {
+    switch (entries[i].type) {
+    case MALLOC:
+      ptrs[entries[i].idx] = malloc(entries[i].size);
+      // Touch at least one byte of the allocation to make sure that
+      // PSS for this allocation is counted.
+      reinterpret_cast<uint8_t*>(ptrs[entries[i].idx])[0] = 10;
+      break;
+    case CALLOC:
+      ptrs[entries[i].idx] = calloc(entries[i].arg2, entries[i].size);
+      // Touch at least one byte of the allocation to make sure that
+      // PSS for this allocation is counted.
+      reinterpret_cast<uint8_t*>(ptrs[entries[i].idx])[0] = 20;
+      break;
+    case MEMALIGN:
+      ptrs[entries[i].idx] = memalign(entries[i].arg2, entries[i].size);
+      // Touch at least one byte of the allocation to make sure that
+      // PSS for this allocation is counted.
+      reinterpret_cast<uint8_t*>(ptrs[entries[i].idx])[0] = 30;
+      break;
+    case REALLOC:
+      if (entries[i].arg2 == 0) {
+        ptrs[entries[i].idx] = realloc(nullptr, entries[i].size);
+      } else {
+        ptrs[entries[i].idx] = realloc(ptrs[entries[i].arg2 - 1], entries[i].size);
+      }
+      // Touch at least one byte of the allocation to make sure that
+      // PSS for this allocation is counted.
+      reinterpret_cast<uint8_t*>(ptrs[entries[i].idx])[0] = 40;
+      break;
+    case FREE:
+      free(ptrs[entries[i].idx]);
+      break;
+    }
+  }
+}
+
+// This codifies playing back a single threaded trace of the allocations
+// when running the SQLite BenchMark app.
+// Instructions for recreating:
+//   - Enable malloc debug
+//       setprop wrap.com.wtsang02.sqliteutil "LIBC_DEBUG_MALLOC_OPTIONS=record_allocs logwrapper"
+//   - Start the SQLite BenchMark app
+//   - Dump allocs using the signal to get rid of non sql allocs(kill -47 <SQLITE_PID>)
+//   - Run the benchmark.
+//   - Dump allocs using the signal again.
+//   - Find the thread that has the most allocs and run the helper script
+//       bionic/libc/malloc_debug/tools/gen_malloc.pl -i <THREAD_ID> g_sql_entries kMaxSqlAllocSlots < <ALLOC_FILE> > malloc_sql.h
+#include "malloc_sql.h"
+
+static void BM_malloc_sql_trace_default(benchmark::State& state) {
+  // The default is expected to be a zero decay time.
+  mallopt(M_DECAY_TIME, 0);
+
+  for (auto _ : state) {
+    BenchmarkMalloc(g_sql_entries, sizeof(g_sql_entries) / sizeof(MallocEntry),
+                    kMaxSqlAllocSlots);
+  }
+}
+BIONIC_BENCHMARK(BM_malloc_sql_trace_default);
+
+static void BM_malloc_sql_trace_decay1(benchmark::State& state) {
+  mallopt(M_DECAY_TIME, 1);
+
+  for (auto _ : state) {
+    BenchmarkMalloc(g_sql_entries, sizeof(g_sql_entries) / sizeof(MallocEntry),
+                    kMaxSqlAllocSlots);
+  }
+
+  mallopt(M_DECAY_TIME, 0);
+}
+BIONIC_BENCHMARK(BM_malloc_sql_trace_decay1);
+
+#endif
diff --git a/benchmarks/stdlib_benchmark.cpp b/benchmarks/stdlib_benchmark.cpp
index ffcedf0..61b51fa 100644
--- a/benchmarks/stdlib_benchmark.cpp
+++ b/benchmarks/stdlib_benchmark.cpp
@@ -24,13 +24,6 @@
 #include <benchmark/benchmark.h>
 #include "util.h"
 
-static __always_inline void MakeAllocationResident(void* ptr, size_t nbytes, int pagesize) {
-  uint8_t* data = reinterpret_cast<uint8_t*>(ptr);
-  for (size_t i = 0; i < nbytes; i += pagesize) {
-    data[i] = 1;
-  }
-}
-
 static void MallocFree(benchmark::State& state) {
   const size_t nbytes = state.range(0);
   int pagesize = getpagesize();
diff --git a/benchmarks/util.h b/benchmarks/util.h
index ef4892d..99eed5f 100644
--- a/benchmarks/util.h
+++ b/benchmarks/util.h
@@ -16,6 +16,8 @@
 
 #pragma once
 
+#include <stdint.h>
+
 #include <map>
 #include <mutex>
 #include <string>
@@ -68,3 +70,11 @@
 char* GetAlignedPtrFilled(std::vector<char>* buf, size_t alignment, size_t nbytes, char fill_byte);
 
 bool LockToCPU(int cpu_to_lock);
+
+static __inline __attribute__ ((__always_inline__)) void MakeAllocationResident(
+    void* ptr, size_t nbytes, int pagesize) {
+  uint8_t* data = reinterpret_cast<uint8_t*>(ptr);
+  for (size_t i = 0; i < nbytes; i += pagesize) {
+    data[i] = 1;
+  }
+}
diff --git a/docs/native_allocator.md b/docs/native_allocator.md
index 249b144..139d664 100644
--- a/docs/native_allocator.md
+++ b/docs/native_allocator.md
@@ -160,7 +160,7 @@
 any issue related to the code migrating from one core to another
 with different characteristics. For example, on a big-little cpu, if the
 benchmark moves from big to little or vice-versa, this can cause scores
-to fluctuate in indeterminte ways.
+to fluctuate in indeterminate ways.
 
 For most runs, the best set of options to add is:
 
@@ -278,6 +278,18 @@
 Calls to mallinfo are used in ART so a new allocator is required to be
 nearly as performant as the current allocator.
 
+#### mallopt M\_PURGE Benchmark
+This benchmark tracks the cost of calling `mallopt(M_PURGE, 0)`. As with the
+mallinfo benchmark, it's not necessary for this to be better than the previous
+allocator, only that the performance be in the same order of magnitude.
+
+To run the benchmark, use these commands:
+
+    adb shell /data/benchmarktest64/bionic-benchmarks/bionic-benchmarks --benchmark_filter=BM_mallopt_purge
+    adb shell /data/benchmarktest/bionic-benchmarks/bionic-benchmarks --benchmark_filter=BM_mallopt_purge
+
+These calls are used to free unused memory pages back to the kernel.
+
 ### Memory Trace Benchmarks
 These benchmarks measure all three axes of a native allocator, RSS, virtual
 address space consumed, speed of allocation. They are designed to