Add a malloc rss benchmark
The behavior of this benchmark includes three steps: 1. Use up to 16 MB by allocating blocks with given size in each thread. 2. Release the all blocks in random order. 3. Use up to 1.6 MB by allocating blocks with given size in each thread. This is used to see how the allocator manages the free blocks and we can measure the impact of randomization property used by the allocator. Test: Run malloc-rss-benchmark $NUM_THREADS $ALLOC_SIZE Change-Id: Ib68562996905839ee4367b1b059714e2325ca03e
This commit is contained in:
parent
137ecdd059
commit
a15d5c4f86
|
@ -156,3 +156,23 @@ cc_test {
|
|||
],
|
||||
data: ["test_suites/*"],
|
||||
}
|
||||
|
||||
cc_binary {
|
||||
name: "malloc-rss-benchmark",
|
||||
srcs: [
|
||||
"malloc_rss_benchmark.cpp",
|
||||
],
|
||||
|
||||
shared_libs: [
|
||||
"libbase",
|
||||
],
|
||||
|
||||
target: {
|
||||
android: {
|
||||
static_libs: [
|
||||
"libmeminfo",
|
||||
"libprocinfo",
|
||||
],
|
||||
},
|
||||
},
|
||||
}
|
||||
|
|
|
@ -178,3 +178,31 @@ SUCH DAMAGE.
|
|||
|
||||
-------------------------------------------------------------------
|
||||
|
||||
Copyright (C) 2022 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.
|
||||
|
||||
-------------------------------------------------------------------
|
||||
|
||||
|
|
|
@ -0,0 +1,165 @@
|
|||
/*
|
||||
* Copyright (C) 2022 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 <string.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#include <algorithm>
|
||||
#include <chrono>
|
||||
#include <iostream>
|
||||
#include <memory>
|
||||
#include <random>
|
||||
#include <thread>
|
||||
#include <vector>
|
||||
|
||||
#include <android-base/strings.h>
|
||||
#if defined(__BIONIC__)
|
||||
#include <malloc.h>
|
||||
#include <meminfo/procmeminfo.h>
|
||||
#include <procinfo/process_map.h>
|
||||
#endif
|
||||
|
||||
constexpr size_t kMaxThreads = 8;
|
||||
// The max number of bytes that can be allocated by a thread. Note that each
|
||||
// allocator may have its own limitation on each size allocation. For example,
|
||||
// Scudo has a 256 MB limit for each size-class in the primary allocator. The
|
||||
// amount of memory allocated should not exceed the limit in each allocator.
|
||||
constexpr size_t kMaxBytes = 1 << 24;
|
||||
constexpr size_t kMaxLen = kMaxBytes;
|
||||
void* MemPool[kMaxThreads][kMaxLen];
|
||||
|
||||
void dirtyMem(void* ptr, size_t bytes) {
|
||||
memset(ptr, 1U, bytes);
|
||||
}
|
||||
|
||||
void ThreadTask(int id, size_t allocSize) {
|
||||
// In the following, we will first allocate blocks with kMaxBytes of memory
|
||||
// and release all of them in random order. In the end, we will do another
|
||||
// round of allocations until it reaches 1/10 kMaxBytes.
|
||||
|
||||
// Total number of blocks
|
||||
const size_t maxCounts = kMaxBytes / allocSize;
|
||||
// The number of blocks in the end
|
||||
const size_t finalCounts = maxCounts / 10;
|
||||
|
||||
for (size_t i = 0; i < maxCounts; ++i) {
|
||||
MemPool[id][i] = malloc(allocSize);
|
||||
if (MemPool[id][i] == 0) {
|
||||
std::cout << "Allocation failure."
|
||||
"Please consider reducing the number of threads"
|
||||
<< std::endl;
|
||||
exit(1);
|
||||
}
|
||||
dirtyMem(MemPool[id][i], allocSize);
|
||||
}
|
||||
|
||||
// Each allocator may apply different strategies to manage the free blocks and
|
||||
// each strategy may have different impacts on future memory usage. For
|
||||
// example, managing free blocks in simple FIFO list may have its memory usage
|
||||
// highly correlated with the blocks releasing pattern. Therefore, release the
|
||||
// blocks in random order to observe the impact of free blocks handling.
|
||||
unsigned seed = std::chrono::system_clock::now().time_since_epoch().count();
|
||||
std::shuffle(MemPool[id], MemPool[id] + maxCounts, std::default_random_engine(seed));
|
||||
for (size_t i = 0; i < maxCounts; ++i) {
|
||||
free(MemPool[id][i]);
|
||||
MemPool[id][i] = nullptr;
|
||||
}
|
||||
|
||||
for (size_t i = 0; i < finalCounts; ++i) {
|
||||
MemPool[id][i] = malloc(allocSize);
|
||||
dirtyMem(MemPool[id][i], allocSize);
|
||||
}
|
||||
}
|
||||
|
||||
void StressSizeClass(size_t numThreads, size_t allocSize) {
|
||||
// We would like to see the minimum memory usage under aggressive page
|
||||
// releasing.
|
||||
mallopt(M_DECAY_TIME, 0);
|
||||
|
||||
std::thread* threads[kMaxThreads];
|
||||
for (size_t i = 0; i < numThreads; ++i) threads[i] = new std::thread(ThreadTask, i, allocSize);
|
||||
|
||||
for (size_t i = 0; i < numThreads; ++i) {
|
||||
threads[i]->join();
|
||||
delete threads[i];
|
||||
}
|
||||
|
||||
// Do an explicit purge to ensure we will be more likely to get the actual
|
||||
// in-use memory.
|
||||
mallopt(M_PURGE, 0);
|
||||
|
||||
android::meminfo::ProcMemInfo proc_mem(getpid());
|
||||
const std::vector<android::meminfo::Vma>& maps = proc_mem.MapsWithoutUsageStats();
|
||||
uint64_t rss_bytes = 0;
|
||||
uint64_t vss_bytes = 0;
|
||||
|
||||
for (auto& vma : maps) {
|
||||
if (vma.name == "[anon:libc_malloc]" || android::base::StartsWith(vma.name, "[anon:scudo:") ||
|
||||
android::base::StartsWith(vma.name, "[anon:GWP-ASan")) {
|
||||
android::meminfo::Vma update_vma(vma);
|
||||
if (!proc_mem.FillInVmaStats(update_vma)) {
|
||||
std::cout << "Failed to parse VMA" << std::endl;
|
||||
exit(1);
|
||||
}
|
||||
rss_bytes += update_vma.usage.rss;
|
||||
vss_bytes += update_vma.usage.vss;
|
||||
}
|
||||
}
|
||||
|
||||
std::cout << "RSS: " << rss_bytes / (1024.0 * 1024.0) << " MB" << std::endl;
|
||||
std::cout << "VSS: " << vss_bytes / (1024.0 * 1024.0) << " MB" << std::endl;
|
||||
|
||||
for (size_t i = 0; i < numThreads; ++i) {
|
||||
for (size_t j = 0; j < kMaxLen; ++j) free(MemPool[i][j]);
|
||||
}
|
||||
}
|
||||
|
||||
int main(int argc, char* argv[]) {
|
||||
if (argc != 3) {
|
||||
std::cerr << "usage: " << argv[0] << " $NUM_THREADS $ALLOC_SIZE" << std::endl;
|
||||
return 1;
|
||||
}
|
||||
|
||||
size_t numThreads = atoi(argv[1]);
|
||||
size_t allocSize = atoi(argv[2]);
|
||||
|
||||
if (numThreads == 0 || allocSize == 0) {
|
||||
std::cerr << "Please provide valid $NUM_THREADS and $ALLOC_SIZE" << std::endl;
|
||||
return 1;
|
||||
}
|
||||
|
||||
if (numThreads > kMaxThreads) {
|
||||
std::cerr << "The max number of threads is " << kMaxThreads << std::endl;
|
||||
return 1;
|
||||
}
|
||||
|
||||
StressSizeClass(numThreads, allocSize);
|
||||
|
||||
return 0;
|
||||
}
|
Loading…
Reference in New Issue