blob: 85fde795f80f06a2b2de87aa47d7cc175e029f7b [file] [log] [blame] [edit]
// -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*-
// Copyright (c) 2005, Google Inc.
// 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.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// 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.
// ---
// Unittest for the TCMalloc implementation.
//
// * The test consists of a set of threads.
// * Each thread maintains a set of allocated objects, with
// a bound on the total amount of data in the set.
// * Each allocated object's contents are generated by
// hashing the object pointer, and a generation count
// in the object. This allows us to easily check for
// data corruption.
// * At any given step, the thread can do any of the following:
// a. Allocate an object
// b. Increment an object's generation count and update
// its contents.
// c. Pass the object to another thread
// d. Free an object
// Also, at the end of every step, object(s) are freed to maintain
// the memory upper-bound.
//
#include "config_for_unittests.h"
// Complicated ordering requirements. tcmalloc.h defines (indirectly)
// _POSIX_C_SOURCE, which it needs so stdlib.h defines posix_memalign.
// unistd.h, on the other hand, requires _POSIX_C_SOURCE to be unset,
// at least on FreeBSD, in order to define sbrk. The solution
// is to #include unistd.h first. This is safe because unistd.h
// doesn't sub-include stdlib.h, so we'll still get posix_memalign
// when we #include stdlib.h. Blah.
#ifdef HAVE_UNISTD_H
#include <unistd.h> // for testing sbrk hooks
#endif
#include "tcmalloc_internal.h" // must come early, to pick up posix_memalign
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <stdint.h> // for intptr_t
#include <sys/types.h> // for size_t
#ifdef HAVE_FCNTL_H
#include <fcntl.h> // for open; used with mmap-hook test
#endif
#ifdef HAVE_MALLOC_H
#include <malloc.h> // defines pvalloc/etc on cygwin
#endif
#include <assert.h>
#include <algorithm>
#include <mutex>
#include <new>
#include <string>
#include <thread>
#include <vector>
#include "gperftools/malloc_hook.h"
#include "gperftools/malloc_extension.h"
#include "gperftools/nallocx.h"
#include "gperftools/tcmalloc.h"
#include "base/function_ref.h"
#include "base/cleanup.h"
#include "base/static_storage.h"
#include "tests/testutil.h"
#include "testing_portal.h"
#include "gtest/gtest.h"
#include "base/logging.h"
using tcmalloc::TestingPortal;
namespace {
// SetFlag updates given variable to new value and returns
// tcmalloc::Cleanup that restores it to previous value.
template <typename T, typename V>
decltype(auto) SetFlag(T* ptr, V value) {
T old_value = *ptr;
*ptr = value;
return tcmalloc::Cleanup{[=] () {
*ptr = old_value;
}};
}
struct NumericProperty {
const char* const name;
constexpr NumericProperty(const char* name) : name(name) {}
// Override sets this property to new value and returns
// tcmalloc::Cleanup that returns it to previous setting.
decltype(auto) Override(size_t new_value) const {
MallocExtension *e = MallocExtension::instance();
size_t old_value;
CHECK(e->GetNumericProperty(name, &old_value));
CHECK(e->SetNumericProperty(name, new_value));
return tcmalloc::Cleanup{[old_value, name = name] () {
CHECK(MallocExtension::instance()->SetNumericProperty(name, old_value));
}};
}
};
constexpr NumericProperty kAggressiveDecommit{"tcmalloc.aggressive_memory_decommit"};
} // namespace
// Windows doesn't define pvalloc and a few other obsolete unix
// functions; nor does it define posix_memalign (which is not obsolete).
#if defined(_WIN32)
# define cfree free // don't bother to try to test these obsolete fns
# define valloc malloc
# define pvalloc malloc
// I'd like to map posix_memalign to _aligned_malloc, but _aligned_malloc
// must be paired with _aligned_free (not normal free), which is too
// invasive a change to how we allocate memory here. So just bail
static bool kOSSupportsMemalign = false;
static inline void* Memalign(size_t align, size_t size) {
//LOG(FATAL) << "memalign not supported on windows";
exit(1);
return NULL;
}
static inline int PosixMemalign(void** ptr, size_t align, size_t size) {
//LOG(FATAL) << "posix_memalign not supported on windows";
exit(1);
return -1;
}
// OS X defines posix_memalign in some OS versions but not others;
// it's confusing enough to check that it's easiest to just not to test.
#elif defined(__APPLE__)
static bool kOSSupportsMemalign = false;
static inline void* Memalign(size_t align, size_t size) {
//LOG(FATAL) << "memalign not supported on OS X";
exit(1);
return NULL;
}
static inline int PosixMemalign(void** ptr, size_t align, size_t size) {
//LOG(FATAL) << "posix_memalign not supported on OS X";
exit(1);
return -1;
}
#else
static bool kOSSupportsMemalign = true;
static inline void* Memalign(size_t align, size_t size) {
return noopt(memalign(align, noopt(size)));
}
static inline int PosixMemalign(void** ptr, size_t align, size_t size) {
return noopt(posix_memalign(ptr, align, noopt(size)));
}
#endif
static constexpr size_t kOveralignment = 64;
struct overaligned_type
{
alignas(kOveralignment)
unsigned char data[kOveralignment * 2]; // make the object size different from
// alignment to make sure the correct
// values are passed to the new/delete
// implementation functions
};
struct OOMAbleSysAlloc : public SysAllocator {
SysAllocator *child;
int simulate_oom;
void* Alloc(size_t size, size_t* actual_size, size_t alignment) {
if (simulate_oom) {
return NULL;
}
return child->Alloc(size, actual_size, alignment);
}
};
static OOMAbleSysAlloc* get_test_sys_alloc() {
static tcmalloc::StaticStorage<OOMAbleSysAlloc> storage;
return storage.get();
}
void setup_oomable_sys_alloc() {
SysAllocator *def = MallocExtension::instance()->GetSystemAllocator();
OOMAbleSysAlloc *alloc = get_test_sys_alloc();
new (alloc) OOMAbleSysAlloc;
alloc->child = def;
MallocExtension::instance()->SetSystemAllocator(alloc);
}
static const int FLAGS_numtests = 50000;
static const int FLAGS_log_every_n_tests = 50000; // log exactly once
// Testing parameters
static const int FLAGS_lgmaxsize = 16; // lg() of the max size object to alloc
static const int FLAGS_numthreads = 10; // Number of threads
static const int FLAGS_threadmb = 4; // Max memory size allocated by thread
static const int FLAGS_lg_max_memalign = 18; // lg of max alignment for memalign
static const double FLAGS_memalign_min_fraction = 0; // min expected%
static const double FLAGS_memalign_max_fraction = 0.4; // max expected%
static const double FLAGS_memalign_max_alignment_ratio = 6; // alignment/size
// Weights of different operations
static const int FLAGS_allocweight = 50; // Weight for picking allocation
static const int FLAGS_freeweight = 50; // Weight for picking free
static const int FLAGS_updateweight = 10; // Weight for picking update
static const int FLAGS_passweight = 1; // Weight for passing object
static const int kSizeBits = 8 * sizeof(size_t);
static const size_t kMaxSize = ~static_cast<size_t>(0);
static const size_t kMaxSignedSize = ((size_t(1) << (kSizeBits-1)) - 1);
static const size_t kNotTooBig = 100000;
// We want an allocation that is definitely more than main memory. OS
// X has special logic to discard very big allocs before even passing
// the request along to the user-defined memory allocator; we're not
// interested in testing their logic, so we have to make sure we're
// not *too* big.
static const size_t kTooBig = kMaxSize - 100000;
// To help with generating random numbers
class TestHarness {
private:
// Information kept per type
struct Type {
std::string name;
int type;
int weight;
};
public:
TestHarness(int seed) {
srandom(seed);
}
// Add operation type with specified weight. When starting a new
// iteration, an operation type is picked with probability
// proportional to its weight.
//
// "type" must be non-negative.
// "weight" must be non-negative.
void AddType(int type, int weight, const char* name);
// Call this to get the type of operation for the next iteration.
// It returns a random operation type from the set of registered
// operations. Returns -1 if tests should finish.
int PickType();
// If n == 0, returns the next pseudo-random number in the range [0 .. 0]
// If n != 0, returns the next pseudo-random number in the range [0 .. n)
int Uniform(int n) {
if (n == 0) {
return random() * 0;
} else {
return random() % n;
}
}
// Pick "base" uniformly from range [0,max_log] and then return
// "base" random bits. The effect is to pick a number in the range
// [0,2^max_log-1] with bias towards smaller numbers.
int Skewed(int max_log) {
const int base = random() % (max_log+1);
return random() % (1 << base);
}
private:
std::vector<Type> types_; // Registered types
int total_weight_ = 0; // Total weight of all types
int num_tests_ = 0; // Num tests run so far
};
void TestHarness::AddType(int type, int weight, const char* name) {
Type t;
t.name = name;
t.type = type;
t.weight = weight;
types_.push_back(t);
total_weight_ += weight;
}
int TestHarness::PickType() {
if (num_tests_ >= FLAGS_numtests) return -1;
num_tests_++;
CHECK(total_weight_ > 0);
// This is a little skewed if total_weight_ doesn't divide 2^31, but it's close
int v = Uniform(total_weight_);
int i;
for (i = 0; i < types_.size(); i++) {
v -= types_[i].weight;
if (v < 0) {
break;
}
}
CHECK(i < types_.size());
if ((num_tests_ % FLAGS_log_every_n_tests) == 0) {
printf(" Test %d out of %d: %s\n",
num_tests_, FLAGS_numtests, types_[i].name.c_str());
}
return types_[i].type;
}
class AllocatorState : public TestHarness {
public:
explicit AllocatorState(int seed) : TestHarness(seed), memalign_fraction_(0) {
if (kOSSupportsMemalign) {
CHECK_GE(FLAGS_memalign_max_fraction, 0);
CHECK_LE(FLAGS_memalign_max_fraction, 1);
CHECK_GE(FLAGS_memalign_min_fraction, 0);
CHECK_LE(FLAGS_memalign_min_fraction, 1);
double delta = FLAGS_memalign_max_fraction - FLAGS_memalign_min_fraction;
CHECK_GE(delta, 0);
memalign_fraction_ = (Uniform(10000)/10000.0 * delta +
FLAGS_memalign_min_fraction);
//printf("memalign fraction: %f\n", memalign_fraction_);
}
}
virtual ~AllocatorState() {}
// Allocate memory. Randomly choose between malloc() or posix_memalign().
void* alloc(size_t size) {
if (Uniform(100) < memalign_fraction_ * 100) {
// Try a few times to find a reasonable alignment, or fall back on malloc.
for (int i = 0; i < 5; i++) {
size_t alignment = size_t{1} << Uniform(FLAGS_lg_max_memalign);
if (alignment >= sizeof(intptr_t) &&
(size < sizeof(intptr_t) ||
alignment < FLAGS_memalign_max_alignment_ratio * size)) {
void *result = reinterpret_cast<void*>(static_cast<intptr_t>(0x1234));
int err = PosixMemalign(&result, alignment, size);
if (err != 0) {
CHECK_EQ(err, ENOMEM);
}
return err == 0 ? result : NULL;
}
}
}
return noopt(malloc(size));
}
private:
double memalign_fraction_;
};
// Info kept per thread
class TesterThread {
private:
// Info kept per allocated object
struct Object {
char* ptr; // Allocated pointer
int size; // Allocated size
int generation; // Generation counter of object contents
};
std::vector<std::unique_ptr<TesterThread>> &all_threads_;
std::mutex lock_; // For passing in another thread's obj
int id_; // My thread id
AllocatorState rnd_; // For generating random numbers
std::vector<Object> heap_; // This thread's heap
std::vector<Object> passed_; // Pending objects passed from others
size_t heap_size_; // Current heap size
// Type of operations
enum Type { ALLOC, FREE, UPDATE, PASS };
// ACM minimal standard random number generator. (re-entrant.)
class ACMRandom {
int32_t seed_;
public:
explicit ACMRandom(int32_t seed) { seed_ = seed; }
int32_t Next() {
const int32_t M = 2147483647L; // 2^31-1
const int32_t A = 16807;
// In effect, we are computing seed_ = (seed_ * A) % M, where M = 2^31-1
uint32_t lo = A * (int32_t)(seed_ & 0xFFFF);
uint32_t hi = A * (int32_t)((uint32_t)seed_ >> 16);
lo += (hi & 0x7FFF) << 16;
if (lo > M) {
lo &= M;
++lo;
}
lo += hi >> 15;
if (lo > M) {
lo &= M;
++lo;
}
return (seed_ = (int32_t) lo);
}
};
public:
TesterThread(std::vector<std::unique_ptr<TesterThread>>& all_threads, int id)
: all_threads_(all_threads),
id_(id),
rnd_(id+1),
heap_size_(0) {
}
virtual ~TesterThread() {
}
virtual void Run() {
rnd_.AddType(ALLOC, FLAGS_allocweight, "allocate");
rnd_.AddType(FREE, FLAGS_freeweight, "free");
rnd_.AddType(UPDATE, FLAGS_updateweight, "update");
rnd_.AddType(PASS, FLAGS_passweight, "pass");
while (true) {
AcquirePassedObjects();
switch (rnd_.PickType()) {
case ALLOC: AllocateObject(); break;
case FREE: FreeObject(); break;
case UPDATE: UpdateObject(); break;
case PASS: PassObject(); break;
case -1: goto done;
default: CHECK(nullptr == "Unknown type");
}
ShrinkHeap();
}
done:
DeleteHeap();
}
// Allocate a new object
void AllocateObject() {
Object object;
object.size = rnd_.Skewed(FLAGS_lgmaxsize);
object.ptr = static_cast<char*>(rnd_.alloc(object.size));
CHECK(object.ptr);
object.generation = 0;
FillContents(&object);
heap_.push_back(object);
heap_size_ += object.size;
}
// Mutate a random object
void UpdateObject() {
if (heap_.empty()) return;
const int index = rnd_.Uniform(heap_.size());
CheckContents(heap_[index]);
heap_[index].generation++;
FillContents(&heap_[index]);
}
// Free a random object
void FreeObject() {
if (heap_.empty()) return;
const int index = rnd_.Uniform(heap_.size());
Object object = heap_[index];
CheckContents(object);
free(object.ptr);
heap_size_ -= object.size;
heap_[index] = heap_[heap_.size()-1];
heap_.pop_back();
}
// Delete all objects in the heap
void DeleteHeap() {
while (!heap_.empty()) {
FreeObject();
}
}
// Free objects until our heap is small enough
void ShrinkHeap() {
while (heap_size_ > FLAGS_threadmb << 20) {
CHECK(!heap_.empty());
FreeObject();
}
}
// Pass a random object to another thread
void PassObject() {
// Pick object to pass
if (heap_.empty()) return;
const int index = rnd_.Uniform(heap_.size());
Object object = heap_[index];
CheckContents(object);
// Pick thread to pass
const int tid = rnd_.Uniform(FLAGS_numthreads);
TesterThread* thread = all_threads_[tid].get();
if (thread->lock_.try_lock()) {
// Pass the object
thread->passed_.push_back(object);
thread->lock_.unlock();
heap_size_ -= object.size;
heap_[index] = heap_[heap_.size()-1];
heap_.pop_back();
}
}
// Grab any objects passed to this thread by another thread
void AcquirePassedObjects() {
// We do not create unnecessary contention by always using
// TryLock(). Plus we unlock immediately after swapping passed
// objects into a local vector.
std::vector<Object> copy;
{ // Locking scope
if (!lock_.try_lock()) {
return;
}
swap(copy, passed_);
lock_.unlock();
}
for (int i = 0; i < copy.size(); ++i) {
const Object& object = copy[i];
CheckContents(object);
heap_.push_back(object);
heap_size_ += object.size;
}
}
// Fill object contents according to ptr/generation
void FillContents(Object* object) {
ACMRandom r(reinterpret_cast<intptr_t>(object->ptr) & 0x7fffffff);
for (int i = 0; i < object->generation; ++i) {
r.Next();
}
const char c = static_cast<char>(r.Next());
memset(object->ptr, c, object->size);
}
// Check object contents
void CheckContents(const Object& object) {
ACMRandom r(reinterpret_cast<intptr_t>(object.ptr) & 0x7fffffff);
for (int i = 0; i < object.generation; ++i) {
r.Next();
}
// For large objects, we just check a prefix/suffix
const char expected = static_cast<char>(r.Next());
const int limit1 = object.size < 32 ? object.size : 32;
const int start2 = limit1 > object.size - 32 ? limit1 : object.size - 32;
for (int i = 0; i < limit1; ++i) {
CHECK_EQ(object.ptr[i], expected);
}
for (int i = start2; i < object.size; ++i) {
CHECK_EQ(object.ptr[i], expected);
}
}
};
TEST(TCMallocTest, ManyThreads) {
printf("Testing threaded allocation/deallocation (%d threads)\n",
FLAGS_numthreads);
std::vector<std::unique_ptr<TesterThread>> ptrs;
ptrs.reserve(FLAGS_numthreads);
// Note, the logic inside PassObject requires us to create all
// TesterThreads first, before starting any of them.
for (int i = 0; i < FLAGS_numthreads; i++) {
ptrs.emplace_back(std::make_unique<TesterThread>(ptrs, i));
}
std::vector<std::thread> threads;
threads.reserve(FLAGS_numthreads);
for (int i = 0; i < FLAGS_numthreads; i++) {
threads.emplace_back([thr = ptrs[i].get()] () {
thr->Run();
});
}
for (auto& t : threads) {
t.join();
}
}
static void TryHugeAllocation(size_t s, AllocatorState* rnd) {
void* p = rnd->alloc(noopt(s));
CHECK(p == NULL); // huge allocation s should fail!
}
static void TestHugeAllocations(AllocatorState* rnd) {
// Check that asking for stuff tiny bit smaller than largest possible
// size returns NULL.
for (size_t i = 0; i < 70000; i += rnd->Uniform(20)) {
TryHugeAllocation(kMaxSize - i, rnd);
}
// Asking for memory sizes near signed/unsigned boundary (kMaxSignedSize)
// might work or not, depending on the amount of virtual memory.
if (!TestingPortal::Get()->IsDebuggingMalloc()) {
// debug allocation takes forever for huge allocs
for (size_t i = 0; i < 100; i++) {
void* p = NULL;
p = rnd->alloc(kMaxSignedSize + i);
if (p) free(p); // if: free(NULL) is not necessarily defined
p = rnd->alloc(kMaxSignedSize - i);
if (p) free(p);
}
}
// Check that ReleaseFreeMemory has no visible effect (aka, does not
// crash the test):
MallocExtension* inst = MallocExtension::instance();
CHECK(inst);
inst->ReleaseFreeMemory();
}
static void TestCalloc(size_t n, size_t s, bool ok) {
char* p = reinterpret_cast<char*>(noopt(calloc)(n, s));
if (!ok) {
CHECK(p == NULL); // calloc(n, s) should not succeed
} else {
CHECK(p != NULL); // calloc(n, s) should succeed
for (int i = 0; i < n*s; i++) {
CHECK(p[i] == '\0');
}
free(p);
}
}
// This makes sure that reallocing a small number of bytes in either
// direction doesn't cause us to allocate new memory.
TEST(TCMallocTest, Realloc) {
if (TestingPortal::Get()->IsDebuggingMalloc()) {
// debug alloc doesn't try to minimize reallocs
return;
}
// When sampling, we always allocate in units of page-size, which
// makes reallocs of small sizes do extra work (thus, failing these
// checks). Since sampling is random, we turn off sampling to make
// sure that doesn't happen to us here.
// turn off sampling
tcmalloc::Cleanup cleanup = SetFlag(&TestingPortal::Get()->GetSampleParameter(), 0);
int start_sizes[] = { 100, 1000, 10000, 100000 };
int deltas[] = { 1, -2, 4, -8, 16, -32, 64, -128 };
for (int s = 0; s < sizeof(start_sizes)/sizeof(*start_sizes); ++s) {
void* p = noopt(malloc(start_sizes[s]));
ASSERT_NE(p, nullptr);
// The larger the start-size, the larger the non-reallocing delta.
for (int d = 0; d < (s+1) * 2; ++d) {
void* new_p = noopt(realloc)(p, start_sizes[s] + deltas[d]);
ASSERT_EQ(p, new_p); // realloc should not allocate new memory
}
// Test again, but this time reallocing smaller first.
for (int d = 0; d < s*2; ++d) {
void* new_p = noopt(realloc)(p, start_sizes[s] - deltas[d]);
ASSERT_EQ(p, new_p); // realloc should not allocate new memory
}
free(p);
}
}
#if __cpp_exceptions
static int news_handled = 0;
static void TestNewHandler() {
++news_handled;
throw std::bad_alloc();
}
static void TestOneNew(void* (*func)(size_t)) {
func = noopt(func);
// success test
try {
void* ptr = (*func)(kNotTooBig);
if (0 == ptr) {
printf("allocation should not have failed.\n");
abort();
}
} catch (...) {
printf("allocation threw unexpected exception.\n");
abort();
}
// failure test
// we should always receive a bad_alloc exception
try {
(*func)(kTooBig);
printf("allocation should have failed.\n");
abort();
} catch (const std::bad_alloc&) {
// correct
} catch (...) {
printf("allocation threw unexpected exception.\n");
abort();
}
}
static void TestNew(void* (*func)(size_t)) {
news_handled = 0;
// test without new_handler:
std::new_handler saved_handler = std::set_new_handler(0);
TestOneNew(func);
// test with new_handler:
std::set_new_handler(TestNewHandler);
TestOneNew(func);
if (news_handled != 1) {
printf("new_handler was not called.\n");
abort();
}
std::set_new_handler(saved_handler);
}
static void TestOneNothrowNew(void* (*func)(size_t, const std::nothrow_t&)) {
func = noopt(func);
// success test
try {
void* ptr = (*func)(kNotTooBig, std::nothrow);
if (ptr == nullptr) {
printf("allocation should not have failed.\n");
abort();
}
} catch (...) {
printf("allocation threw unexpected exception.\n");
abort();
}
// failure test
// we should always receive a bad_alloc exception
try {
if ((*func)(kTooBig, std::nothrow) != 0) {
printf("allocation should have failed.\n");
abort();
}
} catch (...) {
printf("nothrow allocation threw unexpected exception.\n");
abort();
}
}
static void TestNothrowNew(void* (*func)(size_t, const std::nothrow_t&)) {
news_handled = 0;
// test without new_handler:
std::new_handler saved_handler = std::set_new_handler(0);
TestOneNothrowNew(func);
// test with new_handler:
std::set_new_handler(TestNewHandler);
TestOneNothrowNew(func);
if (news_handled != 1) {
printf("nothrow new_handler was not called.\n");
abort();
}
std::set_new_handler(saved_handler);
}
TEST(TCMallocTest, OperatorsNewOOMs) {
printf("Testing operator new(nothrow).\n");
TestNothrowNew(&::operator new);
printf("Testing operator new[](nothrow).\n");
TestNothrowNew(&::operator new[]);
printf("Testing operator new.\n");
TestNew(&::operator new);
printf("Testing operator new[].\n");
TestNew(&::operator new[]);
}
#endif // __cpp_exceptions
// These are used as callbacks by the sanity-check. Set* and Reset*
// register the hook that counts how many times the associated memory
// function is called. After each such call, call Verify* to verify
// that we used the tcmalloc version of the call, and not the libc.
// Note the ... in the hook signature: we don't care what arguments
// the hook takes.
#define MAKE_HOOK_CALLBACK(hook_type, ...) \
static volatile int g_##hook_type##_calls = 0; \
static void IncrementCallsTo##hook_type(__VA_ARGS__) { \
g_##hook_type##_calls++; \
} \
static void Verify##hook_type##WasCalled() { \
CHECK_GT(g_##hook_type##_calls, 0); \
g_##hook_type##_calls = 0; /* reset for next call */ \
} \
static void Set##hook_type() { \
CHECK(MallocHook::Add##hook_type( \
(MallocHook::hook_type)&IncrementCallsTo##hook_type)); \
} \
static void Reset##hook_type() { \
g_##hook_type##_calls = 0; \
CHECK(MallocHook::Remove##hook_type( \
(MallocHook::hook_type)&IncrementCallsTo##hook_type)); \
}
// We do one for each hook typedef in malloc_hook.h
MAKE_HOOK_CALLBACK(NewHook, const void*, size_t);
MAKE_HOOK_CALLBACK(DeleteHook, const void*);
static void TestAlignmentForSize(int size) {
const size_t min_align = TestingPortal::Get()->GetMinAlign();
printf("Testing alignment of malloc(%d)\n", size);
static const int kNum = 100;
void* ptrs[kNum];
for (int i = 0; i < kNum; i++) {
ptrs[i] = malloc(size);
uintptr_t p = reinterpret_cast<uintptr_t>(ptrs[i]);
CHECK((p % sizeof(void*)) == 0);
CHECK((p % sizeof(double)) == 0);
// Must have 16-byte (or 8-byte in case of -DTCMALLOC_ALIGN_8BYTES)
// alignment for large enough objects
if (size >= min_align) {
CHECK((p % min_align) == 0);
}
}
for (int i = 0; i < kNum; i++) {
free(ptrs[i]);
}
}
TEST(TCMallocTest, MallocAlignment) {
for (int lg = 0; lg < 16; lg++) {
TestAlignmentForSize((1<<lg) - 1);
TestAlignmentForSize((1<<lg) + 0);
TestAlignmentForSize((1<<lg) + 1);
}
}
TEST(TCMallocTest, HugeThreadCache) {
printf("==== Testing huge thread cache\n");
// More than 2^16 to cause integer overflow of 16 bit counters.
static const int kNum = 70000;
char** array = new char*[kNum];
for (int i = 0; i < kNum; ++i) {
array[i] = new char[10];
}
for (int i = 0; i < kNum; ++i) {
delete[] array[i];
}
delete[] array;
}
// Check that at least one of the callbacks from Ranges() contains
// the specified address with the specified type, and has size
// >= min_size.
static void CheckRangeCallback(void* ptr, base::MallocRange::Type type,
size_t min_size) {
bool matched = false;
const uintptr_t addr = reinterpret_cast<uintptr_t>(ptr);
auto callback = [&] (const base::MallocRange* r) -> void {
if (!(r->address <= addr && addr < r->address + r->length)) {
return;
}
if (type == base::MallocRange::FREE) {
// We are expecting r->type == FREE, but ReleaseMemory
// may have already moved us to UNMAPPED state instead (this happens in
// approximately 0.1% of executions). Accept either state.
CHECK(r->type == base::MallocRange::FREE ||
r->type == base::MallocRange::UNMAPPED);
} else {
CHECK_EQ(r->type, type);
}
CHECK_GE(r->length, min_size);
matched = true;
};
tcmalloc::FunctionRefFirstDataArg<void(const base::MallocRange*)> ref(callback);
MallocExtension::instance()->Ranges(ref.data, ref.fn);
EXPECT_TRUE(matched);
}
TEST(TCMallocTest, Ranges) {
static const int MB = 1048576;
void* a = malloc(MB);
void* b = malloc(MB);
base::MallocRange::Type releasedType =
TestingPortal::Get()->HaveSystemRelease() ? base::MallocRange::UNMAPPED : base::MallocRange::FREE;
CheckRangeCallback(a, base::MallocRange::INUSE, MB);
CheckRangeCallback(b, base::MallocRange::INUSE, MB);
(noopt(free))(a);
CheckRangeCallback(a, base::MallocRange::FREE, MB);
CheckRangeCallback(b, base::MallocRange::INUSE, MB);
MallocExtension::instance()->ReleaseFreeMemory();
CheckRangeCallback(a, releasedType, MB);
CheckRangeCallback(b, base::MallocRange::INUSE, MB);
(noopt(free))(b);
CheckRangeCallback(a, releasedType, MB);
CheckRangeCallback(b, base::MallocRange::FREE, MB);
}
static size_t GetUnmappedBytes() {
size_t bytes;
CHECK(MallocExtension::instance()->GetNumericProperty(
"tcmalloc.pageheap_unmapped_bytes", &bytes));
return bytes;
}
TEST(TCMallocTest, ReleaseToSystem) {
// Debug allocation mode adds overhead to each allocation which
// messes up all the equality tests here. I just disable the
// teset in this mode.
if (TestingPortal::Get()->IsDebuggingMalloc()) {
return;
}
if(!TestingPortal::Get()->HaveSystemRelease()) return;
tcmalloc::Cleanup release_rate_cleanup = SetFlag(&TestingPortal::Get()->GetReleaseRate(), 0);
tcmalloc::Cleanup decommit_cleanup = kAggressiveDecommit.Override(0);
static const int MB = 1048576;
void* a = noopt(malloc(MB));
void* b = noopt(malloc(MB));
MallocExtension::instance()->ReleaseFreeMemory();
size_t starting_bytes = GetUnmappedBytes();
// Calling ReleaseFreeMemory() a second time shouldn't do anything.
MallocExtension::instance()->ReleaseFreeMemory();
EXPECT_EQ(starting_bytes, GetUnmappedBytes());
// ReleaseToSystem shouldn't do anything either.
MallocExtension::instance()->ReleaseToSystem(MB);
EXPECT_EQ(starting_bytes, GetUnmappedBytes());
free(a);
// The span to release should be 1MB.
MallocExtension::instance()->ReleaseToSystem(MB/2);
EXPECT_EQ(starting_bytes + MB, GetUnmappedBytes());
// Should do nothing since the previous call released too much.
MallocExtension::instance()->ReleaseToSystem(MB/4);
EXPECT_EQ(starting_bytes + MB, GetUnmappedBytes());
free(b);
// Use up the extra MB/4 bytes from 'a' and also release 'b'.
MallocExtension::instance()->ReleaseToSystem(MB/2);
EXPECT_EQ(starting_bytes + 2*MB, GetUnmappedBytes());
// Should do nothing since the previous call released too much.
MallocExtension::instance()->ReleaseToSystem(MB/2);
EXPECT_EQ(starting_bytes + 2*MB, GetUnmappedBytes());
// Nothing else to release.
MallocExtension::instance()->ReleaseFreeMemory();
EXPECT_EQ(starting_bytes + 2*MB, GetUnmappedBytes());
a = noopt(malloc(MB));
free(a);
EXPECT_EQ(starting_bytes + MB, GetUnmappedBytes());
// Releasing less than a page should still trigger a release.
MallocExtension::instance()->ReleaseToSystem(1);
EXPECT_EQ(starting_bytes + 2*MB, GetUnmappedBytes());
}
TEST(TCMallocTest, AggressiveDecommit) {
// Debug allocation mode adds overhead to each allocation which
// messes up all the equality tests here. I just disable the
// teset in this mode.
if(TestingPortal::Get()->IsDebuggingMalloc() || !TestingPortal::Get()->HaveSystemRelease()) {
return;
}
printf("Testing aggressive de-commit\n");
MallocExtension::instance()->ReleaseFreeMemory();
tcmalloc::Cleanup cleanup = kAggressiveDecommit.Override(1);
static const int MB = 1048576;
void* a = noopt(malloc(MB));
void* b = noopt(malloc(MB));
size_t starting_bytes = GetUnmappedBytes();
// ReleaseToSystem shouldn't do anything either.
MallocExtension::instance()->ReleaseToSystem(MB);
EXPECT_EQ(starting_bytes, GetUnmappedBytes());
free(a);
// The span to release should be 1MB.
EXPECT_EQ(starting_bytes + MB, GetUnmappedBytes());
free(b);
EXPECT_EQ(starting_bytes + 2*MB, GetUnmappedBytes());
// Nothing else to release.
MallocExtension::instance()->ReleaseFreeMemory();
EXPECT_EQ(starting_bytes + 2*MB, GetUnmappedBytes());
a = noopt(malloc(MB));
free(a);
EXPECT_EQ(starting_bytes + 2*MB, GetUnmappedBytes());
printf("Done testing aggressive de-commit\n");
}
// On MSVC10, in release mode, the optimizer convinces itself
// g_no_memory is never changed (I guess it doesn't realize OnNoMemory
// might be called). Work around this by setting the var volatile.
volatile bool g_no_memory = false;
std::new_handler g_old_handler = NULL;
static void OnNoMemory() {
g_no_memory = true;
std::set_new_handler(g_old_handler);
}
TEST(TCMallocTest, SetNewMode) {
int old_mode = tc_set_new_mode(1);
g_old_handler = std::set_new_handler(&OnNoMemory);
g_no_memory = false;
void* ret = noopt(malloc(noopt(kTooBig)));
EXPECT_EQ(NULL, ret);
EXPECT_TRUE(g_no_memory);
g_old_handler = std::set_new_handler(&OnNoMemory);
g_no_memory = false;
ret = noopt(calloc(1, noopt(kTooBig)));
EXPECT_EQ(NULL, ret);
EXPECT_TRUE(g_no_memory);
g_old_handler = std::set_new_handler(&OnNoMemory);
g_no_memory = false;
ret = noopt(realloc(nullptr, noopt(kTooBig)));
EXPECT_EQ(NULL, ret);
EXPECT_TRUE(g_no_memory);
if (kOSSupportsMemalign) {
// Not really important, but must be small enough such that
// kAlignment + kTooBig does not overflow.
const int kAlignment = 1 << 5;
g_old_handler = std::set_new_handler(&OnNoMemory);
g_no_memory = false;
ret = Memalign(kAlignment, kTooBig);
EXPECT_EQ(NULL, ret);
EXPECT_TRUE(g_no_memory);
g_old_handler = std::set_new_handler(&OnNoMemory);
g_no_memory = false;
EXPECT_EQ(ENOMEM,
PosixMemalign(&ret, kAlignment, kTooBig));
EXPECT_EQ(NULL, ret);
EXPECT_TRUE(g_no_memory);
}
tc_set_new_mode(old_mode);
}
TEST(TCMallocTest, TestErrno) {
void* ret;
if (kOSSupportsMemalign) {
errno = 0;
ret = Memalign(128, kTooBig);
EXPECT_EQ(NULL, ret);
EXPECT_EQ(ENOMEM, errno);
}
errno = 0;
ret = noopt(malloc(noopt(kTooBig)));
EXPECT_EQ(NULL, ret);
EXPECT_EQ(ENOMEM, errno);
errno = 0;
ret = tc_malloc_skip_new_handler(kTooBig);
EXPECT_EQ(NULL, ret);
EXPECT_EQ(ENOMEM, errno);
}
// Ensure that nallocx works before main.
struct GlobalNallocx {
GlobalNallocx() {
if (!TestingPortal::Get()->IsDebuggingMalloc()) {
CHECK_GT(nallocx(99, 0), 99);
}
}
} global_nallocx;
#if defined(__GNUC__)
static void check_global_nallocx() __attribute__((constructor));
static void check_global_nallocx() {
if (TestingPortal::Get()->IsDebuggingMalloc()) {
return;
}
CHECK_GT(nallocx(99, 0), 99);
}
#endif // __GNUC__
static size_t GrowNallocxTestSize(size_t sz) {
if (sz < 1024) {
return sz + 7;
}
size_t divided = sz >> 7;
divided |= (divided >> 1);
divided |= (divided >> 2);
divided |= (divided >> 4);
divided |= (divided >> 8);
divided |= (divided >> 16);
divided += 1;
return sz + divided;
}
TEST(TCMallocTest, NAllocX) {
if (TestingPortal::Get()->IsDebuggingMalloc()) {
return;
}
for (size_t size = 0; size <= (1 << 20); size = GrowNallocxTestSize(size)) {
size_t rounded = nallocx(size, 0);
ASSERT_GE(rounded, size);
void* ptr = malloc(size);
ASSERT_EQ(rounded, MallocExtension::instance()->GetAllocatedSize(ptr));
free(ptr);
}
}
TEST(TCMallocTest, NAllocXAlignment) {
if (TestingPortal::Get()->IsDebuggingMalloc()) {
return;
}
for (size_t size = 0; size <= (1 << 20); size = GrowNallocxTestSize(size)) {
for (size_t align_log = 0; align_log < 10; align_log++) {
size_t rounded = nallocx(size, MALLOCX_LG_ALIGN(align_log));
size_t align = size_t{1} << align_log;
ASSERT_GE(rounded, size);
ASSERT_EQ(rounded % align, 0);
void* ptr = tc_memalign(align, size);
ASSERT_EQ(rounded, MallocExtension::instance()->GetAllocatedSize(ptr));
free(ptr);
}
}
}
struct NewHandlerHelper {
NewHandlerHelper(NewHandlerHelper* prev) : prev(prev) {
memset(filler, 0, sizeof(filler));
}
NewHandlerHelper* Pop() {
NewHandlerHelper* prev = this->prev;
delete this;
return prev;
}
NewHandlerHelper* const prev;
char filler[512];
};
static int saw_new_handler_runs;
static NewHandlerHelper* oom_test_last_ptr;
static void test_new_handler() {
oom_test_last_ptr = oom_test_last_ptr->Pop();
saw_new_handler_runs++;
}
TEST(TCMallocTest, NewHandler) {
// debug allocator does internal allocations and crashes when such
// internal allocation fails. So don't test it.
if (TestingPortal::Get()->IsDebuggingMalloc()) {
return;
}
ASSERT_EQ(oom_test_last_ptr, nullptr);
ASSERT_EQ(saw_new_handler_runs, 0);
tcmalloc::Cleanup clean_oom_testers([] () {
while (oom_test_last_ptr) {
oom_test_last_ptr = oom_test_last_ptr->Pop();
}
});
setup_oomable_sys_alloc();
std::new_handler old = std::set_new_handler(test_new_handler);
get_test_sys_alloc()->simulate_oom = true;
tcmalloc::Cleanup restore_oom([] () {
get_test_sys_alloc()->simulate_oom = false;
});
ASSERT_EQ(saw_new_handler_runs, 0);
// After we enabled "simulate oom" behavior in sys allocator, we may
// need to allocate a lot of NewHandlerHelper instances until all
// the page heap free reserves are consumed and we're hitting
// sysallocator. So we have a linked list of thoses and keep
// allocating until we see our test_new_handler runs.
//
// Note, there is also slight chance that we'll hit crash while
// failing to allocate internal metadata. It doesn't happen often
// (and not with default order of tests), but something we'll need
// to fix one day.
for (int i = 1<<24; i > 0; i--) {
oom_test_last_ptr = noopt(new NewHandlerHelper(oom_test_last_ptr));
ASSERT_NE(oom_test_last_ptr, nullptr);
if (saw_new_handler_runs) {
break;
}
}
ASSERT_EQ(saw_new_handler_runs, 1);
std::set_new_handler(old);
}
TEST(TCMallocTest, AllTests) {
AllocatorState rnd(100);
// Check that empty allocation works
printf("Testing empty allocation\n");
{
void* p1 = rnd.alloc(0);
ASSERT_NE(p1, nullptr);
void* p2 = rnd.alloc(0);
ASSERT_NE(p2, nullptr);
ASSERT_NE(p1, p2);
free(p1);
free(p2);
}
// This code stresses some of the memory allocation via STL.
// It may call operator delete(void*, nothrow_t).
printf("Testing STL use\n");
{
std::vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(0);
std::stable_sort(v.begin(), v.end());
}
#ifdef ENABLE_SIZED_DELETE
{
printf("Testing large sized delete is not crashing\n");
// Large sized delete
// case. https://github.com/gperftools/gperftools/issues/1254
std::vector<char*> addresses;
constexpr int kSizedDepth = 1024;
addresses.reserve(kSizedDepth);
for (int i = 0; i < kSizedDepth; i++) {
addresses.push_back(noopt(new char[12686]));
}
for (int i = 0; i < kSizedDepth; i++) {
::operator delete[](addresses[i], 12686);
}
}
#endif
// Test each of the memory-allocation functions once, just as a sanity-check
printf("Sanity-testing all the memory allocation functions\n");
{
// We use new-hook and delete-hook to verify we actually called the
// tcmalloc version of these routines, and not the libc version.
SetNewHook(); // defined as part of MAKE_HOOK_CALLBACK, above
SetDeleteHook(); // ditto
tcmalloc::Cleanup unhook([] () {
// Reset the hooks to what they used to be. These are all
// defined as part of MAKE_HOOK_CALLBACK, above.
ResetNewHook();
ResetDeleteHook();
});
void* p1 = noopt(malloc)(10);
ASSERT_NE(p1, nullptr); // force use of this variable
VerifyNewHookWasCalled();
// Also test the non-standard tc_malloc_size
size_t actual_p1_size = tc_malloc_size(p1);
ASSERT_GE(actual_p1_size, 10);
ASSERT_LT(actual_p1_size, 100000); // a reasonable upper-bound, I think
free(p1);
VerifyDeleteHookWasCalled();
p1 = tc_malloc_skip_new_handler(10);
ASSERT_NE(p1, nullptr);
VerifyNewHookWasCalled();
free(p1);
VerifyDeleteHookWasCalled();
p1 = noopt(calloc)(10, 2);
ASSERT_NE(p1, nullptr);
VerifyNewHookWasCalled();
// We make sure we realloc to a big size, since some systems (OS
// X) will notice if the realloced size continues to fit into the
// malloc-block and make this a noop if so.
p1 = noopt(realloc)(p1, 30000);
ASSERT_NE(p1, nullptr);
VerifyNewHookWasCalled();
VerifyDeleteHookWasCalled();
cfree(p1); // synonym for free
VerifyDeleteHookWasCalled();
if (kOSSupportsMemalign) {
ASSERT_EQ(noopt(PosixMemalign)(&p1, sizeof(p1), 40), 0);
ASSERT_NE(p1, nullptr);
VerifyNewHookWasCalled();
free(p1);
VerifyDeleteHookWasCalled();
p1 = noopt(Memalign)(sizeof(p1) * 2, 50);
ASSERT_NE(p1, nullptr);
VerifyNewHookWasCalled();
free(p1);
VerifyDeleteHookWasCalled();
}
// Windows has _aligned_malloc. Let's test that that's captured too.
#if (defined(_MSC_VER) || defined(__MINGW32__)) && !defined(PERFTOOLS_NO_ALIGNED_MALLOC)
p1 = noopt(_aligned_malloc)(sizeof(p1) * 2, 64);
ASSERT_NE(p1, nullptr);
VerifyNewHookWasCalled();
_aligned_free(p1);
VerifyDeleteHookWasCalled();
#endif
p1 = noopt(valloc(60));
ASSERT_NE(p1, nullptr);
VerifyNewHookWasCalled();
free(p1);
VerifyDeleteHookWasCalled();
p1 = noopt(pvalloc(70));
ASSERT_NE(p1, nullptr);
VerifyNewHookWasCalled();
free(p1);
VerifyDeleteHookWasCalled();
char* p2 = noopt(new char);
ASSERT_NE(p2, nullptr);
VerifyNewHookWasCalled();
delete p2;
VerifyDeleteHookWasCalled();
p2 = noopt(new char[100]);
ASSERT_NE(p2, nullptr);
VerifyNewHookWasCalled();
delete[] p2;
VerifyDeleteHookWasCalled();
p2 = noopt(new (std::nothrow) char);
ASSERT_NE(p2, nullptr);
VerifyNewHookWasCalled();
delete p2;
VerifyDeleteHookWasCalled();
p2 = noopt(new (std::nothrow) char[100]);
ASSERT_NE(p2, nullptr);
VerifyNewHookWasCalled();
delete[] p2;
VerifyDeleteHookWasCalled();
// Another way of calling operator new
p2 = noopt(static_cast<char*>(::operator new(100)));
ASSERT_NE(p2, nullptr);
VerifyNewHookWasCalled();
::operator delete(p2);
VerifyDeleteHookWasCalled();
// Try to call nothrow's delete too. Compilers use this.
p2 = noopt(static_cast<char*>(::operator new(100, std::nothrow)));
ASSERT_NE(p2, nullptr);
VerifyNewHookWasCalled();
::operator delete(p2, std::nothrow);
VerifyDeleteHookWasCalled();
#ifdef ENABLE_SIZED_DELETE
p2 = noopt(new char);
ASSERT_NE(p2, nullptr);
VerifyNewHookWasCalled();
::operator delete(p2, sizeof(char));
VerifyDeleteHookWasCalled();
p2 = noopt(new char[100]);
ASSERT_NE(p2, nullptr);
VerifyNewHookWasCalled();
::operator delete[](p2, sizeof(char) * 100);
VerifyDeleteHookWasCalled();
#endif
overaligned_type* poveraligned = noopt(new overaligned_type);
ASSERT_NE(poveraligned, nullptr);
ASSERT_EQ((((size_t)poveraligned) % kOveralignment), 0);
VerifyNewHookWasCalled();
delete poveraligned;
VerifyDeleteHookWasCalled();
poveraligned = noopt(new overaligned_type[10]);
ASSERT_NE(poveraligned, nullptr);
ASSERT_EQ((((size_t)poveraligned) % kOveralignment), 0);
VerifyNewHookWasCalled();
delete[] poveraligned;
VerifyDeleteHookWasCalled();
poveraligned = noopt(new(std::nothrow) overaligned_type);
ASSERT_NE(poveraligned, nullptr);
ASSERT_EQ((((size_t)poveraligned) % kOveralignment), 0);
VerifyNewHookWasCalled();
delete poveraligned;
VerifyDeleteHookWasCalled();
poveraligned = noopt(new(std::nothrow) overaligned_type[10]);
ASSERT_NE(poveraligned, nullptr);
ASSERT_EQ((((size_t)poveraligned) % kOveralignment), 0);
VerifyNewHookWasCalled();
delete[] poveraligned;
VerifyDeleteHookWasCalled();
// Another way of calling operator new
p2 = noopt(static_cast<char*>(::operator new(100, std::align_val_t(kOveralignment))));
ASSERT_NE(p2, nullptr);
ASSERT_EQ((((size_t)p2) % kOveralignment), 0);
VerifyNewHookWasCalled();
::operator delete(p2, std::align_val_t(kOveralignment));
VerifyDeleteHookWasCalled();
p2 = noopt(static_cast<char*>(::operator new(100, std::align_val_t(kOveralignment), std::nothrow)));
ASSERT_NE(p2, nullptr);
ASSERT_EQ((((size_t)p2) % kOveralignment), 0);
VerifyNewHookWasCalled();
::operator delete(p2, std::align_val_t(kOveralignment), std::nothrow);
VerifyDeleteHookWasCalled();
poveraligned = noopt(new overaligned_type);
ASSERT_NE(poveraligned, nullptr);
ASSERT_EQ((((size_t)poveraligned) % kOveralignment), 0);
VerifyNewHookWasCalled();
::operator delete(poveraligned, sizeof(overaligned_type), std::align_val_t(kOveralignment));
VerifyDeleteHookWasCalled();
poveraligned = noopt(new overaligned_type[10]);
ASSERT_NE(poveraligned, nullptr);
ASSERT_EQ((((size_t)poveraligned) % kOveralignment), 0);
VerifyNewHookWasCalled();
::operator delete[](poveraligned, sizeof(overaligned_type) * 10, std::align_val_t(kOveralignment));
VerifyDeleteHookWasCalled();
// On AIX user defined malloc replacement of libc routines
// cannot be done at link time must be done a runtime via
// environment variable MALLOCTYPE
#if !defined(_AIX)
// Try strdup(), which the system allocates but we must free. If
// all goes well, libc will use our malloc!
p2 = noopt(strdup("in memory of James Golick"));
ASSERT_NE(p2, nullptr);
VerifyNewHookWasCalled();
free(p2);
VerifyDeleteHookWasCalled();
#endif
}
// Check that "lots" of memory can be allocated
printf("Testing large allocation\n");
{
const int mb_to_allocate = 100;
void* p = rnd.alloc(mb_to_allocate << 20);
ASSERT_NE(p, nullptr); // could not allocate
free(p);
}
// Check calloc() with various arguments
printf("Testing calloc\n");
TestCalloc(0, 0, true);
TestCalloc(0, 1, true);
TestCalloc(1, 1, true);
TestCalloc(1<<10, 0, true);
TestCalloc(1<<20, 0, true);
TestCalloc(0, 1<<10, true);
TestCalloc(0, 1<<20, true);
TestCalloc(1<<20, 2, true);
TestCalloc(2, 1<<20, true);
TestCalloc(1000, 1000, true);
TestCalloc(kMaxSize, 2, false);
TestCalloc(2, kMaxSize, false);
TestCalloc(kMaxSize, kMaxSize, false);
TestCalloc(kMaxSignedSize, 3, false);
TestCalloc(3, kMaxSignedSize, false);
TestCalloc(kMaxSignedSize, kMaxSignedSize, false);
// Do the memory intensive tests after threads are done, since exhausting
// the available address space can make pthread_create to fail.
// Check that huge allocations fail with NULL instead of crashing
printf("Testing huge allocations\n");
TestHugeAllocations(&rnd);
// Check that large allocations fail with NULL instead of crashing
//
// debug allocation takes forever for huge allocs
if (!TestingPortal::Get()->IsDebuggingMalloc()) {
constexpr NumericProperty kHeapLimitMB{"tcmalloc.heap_limit_mb"};
printf("Testing out of memory\n");
tcmalloc::Cleanup cleanup_limit = kHeapLimitMB.Override(1<<10); // 1 gig. Note, this is in megs.
// Don't exercise more than 1 gig, no need to.
for (int s = 0; ; s += (10<<20)) {
void* large_object = rnd.alloc(s);
if (large_object == nullptr) {
break;
}
free(large_object);
}
}
}
TEST(TCMallocTest, EmergencyMalloc) {
auto portal = TestingPortal::Get();
if (!portal->HasEmergencyMalloc()) {
printf("EmergencyMalloc test skipped\n");
return;
}
SetNewHook();
SetDeleteHook();
tcmalloc::Cleanup unhook([] () {
ResetNewHook();
ResetDeleteHook();
});
void* p1 = noopt(tc_malloc)(32);
void* p2 = nullptr;
VerifyNewHookWasCalled();
portal->WithEmergencyMallocEnabled([&] () {
p2 = noopt(malloc)(32);
});
ASSERT_NE(p2, nullptr);
// Emergency malloc doesn't call hook
ASSERT_EQ(g_NewHook_calls, 0);
// Emergency malloc doesn't return pointers recognized by MallocExtension
ASSERT_EQ(MallocExtension::instance()->GetOwnership(p1), MallocExtension::kOwned);
ASSERT_EQ(MallocExtension::instance()->GetOwnership(p2), MallocExtension::kNotOwned);
// Emergency malloc automagically does the right thing for free()
// calls and doesn't invoke hooks.
tc_free(p2);
ASSERT_EQ(g_DeleteHook_calls, 0);
tc_free(p1);
VerifyDeleteHookWasCalled();
}
TEST(TCMallocTest, EmergencyMallocNoHook) {
auto portal = TestingPortal::Get();
if (!portal->HasEmergencyMalloc()) {
printf("EmergencyMallocNoHook test skipped\n");
return;
}
void* p1 = noopt(tc_malloc)(32);
void* p2 = nullptr;
void* p3 = nullptr;
portal->WithEmergencyMallocEnabled([&] () {
p2 = noopt(malloc)(32);
p3 = tc_calloc(4096, 1024);
});
ASSERT_NE(p2, nullptr);
ASSERT_NE(p3, nullptr);
// Emergency malloc doesn't return pointers recognized by MallocExtension
ASSERT_EQ(MallocExtension::instance()->GetOwnership(p1), MallocExtension::kOwned);
ASSERT_EQ(MallocExtension::instance()->GetOwnership(p2), MallocExtension::kNotOwned);
ASSERT_EQ(MallocExtension::instance()->GetOwnership(p3), MallocExtension::kNotOwned);
SetNewHook();
SetDeleteHook();
tcmalloc::Cleanup unhook([] () {
ResetNewHook();
ResetDeleteHook();
});
// Emergency malloc automagically does the right thing for free()
// calls and doesn't invoke hooks.
tc_free(p2);
ASSERT_EQ(g_DeleteHook_calls, 0);
tc_free(p1);
VerifyDeleteHookWasCalled();
}
TEST(TCMallocTest, Version) {
// Test tc_version()
int major;
int minor;
const char* patch;
char mmp[64];
const char* human_version = tc_version(&major, &minor, &patch);
int used = snprintf(mmp, sizeof(mmp), "gperftools %d.%d%s", major, minor, patch);
ASSERT_LT(used, sizeof(mmp));
ASSERT_EQ(strcmp(TC_VERSION_STRING, human_version), 0);
}
#ifdef _WIN32
#undef environ
#undef execle
#define environ _environ
#define execle tcmalloc_windows_execle
static intptr_t tcmalloc_windows_execle(const char* pathname, const char* argv0, const char* nl, const char* envp[]) {
CHECK_EQ(nl, nullptr);
const char* args[2] = {argv0, nullptr};
MallocExtension::instance()->MarkThreadIdle();
MallocExtension::instance()->ReleaseFreeMemory();
// MS's CRT _execle while kinda "similar" to real thing, is totally
// wrong (!!!). So we simulate it by doing spawn with _P_WAIT and
// exiting with status that we got.
intptr_t rv = _spawnve(_P_WAIT, pathname, args, envp);
if (rv < 0) {
perror("_spawnve");
abort();
}
_exit(static_cast<int>(rv));
}
#endif // _WIN32
// POSIX standard oddly requires users to define environ variable
// themselves. 3 of 3 bsd-derived systems I tested on actually
// don't bother having environ in their headers. Relevant ticket has
// been closed as "won't fix" in FreeBSD ticket tracker:
// https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=238672
//
// Just in case, we wrap this declaration with ifdef, so that if
// anyone has environ as macro (see windows case above), we won't be
// breaking anything.
#if !defined(environ)
extern "C" {
extern char** environ;
}
#endif
struct EnvProperty {
const char* const name;
constexpr EnvProperty(const char* name) : name(name) {}
std::string_view Get() const {
const char* v = getenv(name);
if (v == nullptr) {
return {};
}
return {v};
}
using override_set = std::vector<std::pair<std::string, std::string>>;
using env_override_fn = std::function<void(override_set*)>;
static std::function<std::vector<const char*>()> DuplicateAndUpdateEnv(env_override_fn fn) {
return [fn] () {
override_set overrides;
fn(&overrides);
return DoDuplicateAndUpdateEnv(std::move(overrides));
};
}
static std::vector<const char*> DoDuplicateAndUpdateEnv(override_set overrides) {
std::vector<const char*> vec;
for (const char* const *p = environ; *p; p++) {
std::string_view k_and_v{*p};
auto pos = k_and_v.find('=');
CHECK(pos != std::string_view::npos);
std::string_view k = k_and_v.substr(0, pos);
int i = overrides.size() - 1;;
for (; i >= 0; i--) {
if (overrides[i].first == k) {
break;
}
}
if (i < 0) {
vec.push_back(*p);
}
}
for (const auto& [k, v] : overrides) {
if (v.empty()) {
continue;
}
size_t sz = k.size() + v.size() + 1 + 1;
char* new_k_and_v = new char[sz];
auto it = std::copy(k.begin(), k.end(), new_k_and_v);
*it++ = '=';
it = std::copy(v.begin(), v.end(), it);
*it++ = '\0';
CHECK_EQ(it, new_k_and_v + sz);
vec.push_back(new_k_and_v);
}
vec.push_back(nullptr);
return vec;
}
void Set(override_set* overrides, const char* new_value) const {
overrides->emplace_back(std::string(name), std::string(new_value));
}
void SetAndPrint(override_set* overrides, const char* new_value) const {
printf("Testing %s=%s\n", name, new_value);
return Set(overrides, new_value);
}
};
// We want to run tests with several runtime configuration tweaks. For
// improved test coverage. Previously we had shell script driving
// this, now we handle this by exec-ing just at the end of all tests.
//
// Do note, though, that this logic is only activated if test program
// is run with no args. I.e. if you're debugging specific unit-test(s)
// by passing --gtest_filter or other flags, you'll need to set up
// environment variables yourself. See SetupExec below.
//
// We test 4 extra settings:
//
// * TCMALLOC_TRANSFER_NUM_OBJ = 40
//
// * TCMALLOC_TRANSFER_NUM_OBJ = 4096
//
// * TCMALLOC_AGGRESSIVE_DECOMMIT = t
//
// * TCMALLOC_HEAP_LIMIT_MB = 512
//
// * TCMALLOC_ENABLE_SIZED_DELETE = t (note, this one is no-op in most
// common builds)
std::function<std::vector<const char*>()> PrepareEnv() {
static constexpr EnvProperty kUpdateNoEnv{"TCMALLOC_UNITTEST_ENV_UPDATE_NO"};
static constexpr EnvProperty kTransferNumObjEnv{"TCMALLOC_TRANSFER_NUM_OBJ"};
static constexpr EnvProperty kAggressiveDecommitEnv{"TCMALLOC_AGGRESSIVE_DECOMMIT"};
static constexpr EnvProperty kHeapLimitEnv{"TCMALLOC_HEAP_LIMIT_MB"};
static constexpr EnvProperty kEnableSizedDeleteEnv{"TCMALLOC_ENABLE_SIZED_DELETE"};
std::string_view testno = kUpdateNoEnv.Get();
using override_set = EnvProperty::override_set;
if (testno == "") {
return EnvProperty::DuplicateAndUpdateEnv([] (override_set* overrides) {
kTransferNumObjEnv.SetAndPrint(overrides, "40");
kUpdateNoEnv.Set(overrides, "1");
});
}
if (testno == "1") {
return EnvProperty::DuplicateAndUpdateEnv([] (override_set* overrides) {
kTransferNumObjEnv.SetAndPrint(overrides, "4096");
kUpdateNoEnv.Set(overrides, "2");
});
}
if (testno == "2") {
return EnvProperty::DuplicateAndUpdateEnv([] (override_set* overrides) {
kTransferNumObjEnv.Set(overrides, "");
kAggressiveDecommitEnv.SetAndPrint(overrides, "t");
kUpdateNoEnv.Set(overrides, "3");
});
}
if (testno == "3") {
return EnvProperty::DuplicateAndUpdateEnv([] (override_set* overrides) {
kAggressiveDecommitEnv.Set(overrides, "");
kHeapLimitEnv.SetAndPrint(overrides, "512");
kUpdateNoEnv.Set(overrides, "4");
});
}
if (testno == "4") {
return EnvProperty::DuplicateAndUpdateEnv([] (override_set* overrides) {
kHeapLimitEnv.Set(overrides, "");
kEnableSizedDeleteEnv.SetAndPrint(overrides, "t");
kUpdateNoEnv.Set(overrides, "5");
});
}
if (testno == "5") {
return {};
}
printf("Unknown %s: %.*s\n", kUpdateNoEnv.name, static_cast<int>(testno.size()), testno.data());
abort();
}
std::function<void()> SetupExec(int argc, char** argv) {
if (argc != 1) {
return {};
}
std::function<std::vector<const char*>()> env_fn = PrepareEnv();
if (!env_fn) {
return env_fn;
}
const char* program_name = strdup(argv[0]);
// printf("program_name = %s\n", program_name);
return [program_name, env_fn] () {
std::vector<const char*> vec = env_fn();
// printf("pre-exec:\n");
// for (const char* k_and_v : vec) {
// if (k_and_v) {
// printf("%s\n", k_and_v);
// }
// }
// printf("\n");
CHECK_EQ(execle(program_name, program_name, nullptr, vec.data()), 0);
};
}
int main(int argc, char** argv) {
std::function<void()> exec_fn = SetupExec(argc, argv);
if (TestingPortal::Get()->IsDebuggingMalloc()) {
// return freed blocks to tcmalloc immediately
TestingPortal::Get()->GetMaxFreeQueueSize() = 0;
}
#if defined(__linux) || defined(_WIN32)
// We know that Linux and Windows have functional memory releasing
// support. So don't let us degrade on that.
if (!getenv("DONT_TEST_SYSTEM_RELEASE")) {
CHECK(TestingPortal::Get()->HaveSystemRelease());
}
#endif
testing::InitGoogleTest(&argc, argv);
int err_code = RUN_ALL_TESTS();
if (err_code || !exec_fn) {
return err_code;
}
// if exec_fn is not empty and we've passed tests so far, lets try
// to continue testing by updating environment variables and
// self-execing.
exec_fn();
printf("Shouldn't be reachable\n");
}