blob: 4c5e603b56d2a640c14e2a98c5d07819044427db [file] [log] [blame]
/*
* Copyright (C) 2020 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <atomic>
#include <cinttypes>
#include <condition_variable>
#include <iterator>
#include <mutex>
#include <thread>
#include <vector>
#include "perfetto/base/logging.h"
#include "perfetto/base/time.h"
#include "perfetto/ext/base/getopt.h"
#include "perfetto/ext/base/optional.h"
#include "perfetto/ext/base/string_utils.h"
#include "perfetto/heap_profile.h"
namespace {
void EnabledCallback(void*, const AHeapProfileEnableCallbackInfo*);
std::atomic<bool> done;
std::atomic<uint64_t> allocs{0};
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wglobal-constructors"
#pragma GCC diagnostic ignored "-Wexit-time-destructors"
std::mutex g_wake_up_mutex;
std::condition_variable g_wake_up_cv;
uint64_t g_rate = 0;
uint32_t g_heap_id = AHeapProfile_registerHeap(
AHeapInfo_setEnabledCallback(AHeapInfo_create("test_heap"),
EnabledCallback,
nullptr));
#pragma GCC diagnostic pop
void EnabledCallback(void*, const AHeapProfileEnableCallbackInfo* info) {
std::lock_guard<std::mutex> l(g_wake_up_mutex);
g_rate = AHeapProfileEnableCallbackInfo_getSamplingInterval(info);
g_wake_up_cv.notify_all();
}
uint64_t ScrambleAllocId(uint64_t alloc_id, uint32_t thread_idx) {
return thread_idx | (~alloc_id << 24);
}
void Thread(uint32_t thread_idx, uint64_t pending_allocs) {
PERFETTO_CHECK(thread_idx < 1 << 24);
uint64_t alloc_id = 0;
size_t thread_allocs = 0;
while (!done.load(std::memory_order_relaxed)) {
AHeapProfile_reportAllocation(g_heap_id,
ScrambleAllocId(alloc_id, thread_idx), 1);
if (alloc_id > pending_allocs)
AHeapProfile_reportFree(
g_heap_id, ScrambleAllocId(alloc_id - pending_allocs, thread_idx));
alloc_id++;
thread_allocs++;
}
allocs.fetch_add(thread_allocs, std::memory_order_relaxed);
}
} // namespace
int main(int argc, char** argv) {
if (argc != 4) {
PERFETTO_FATAL("%s NUMBER_THREADS RUNTIME_MS PENDING_ALLOCS", argv[0]);
}
perfetto::base::Optional<uint64_t> opt_no_threads =
perfetto::base::CStringToUInt64(argv[1]);
if (!opt_no_threads) {
PERFETTO_FATAL("Invalid number of threads: %s", argv[1]);
}
uint64_t no_threads = *opt_no_threads;
perfetto::base::Optional<uint64_t> opt_runtime_ms =
perfetto::base::CStringToUInt64(argv[2]);
if (!opt_runtime_ms) {
PERFETTO_FATAL("Invalid runtime: %s", argv[2]);
}
uint64_t runtime_ms = *opt_runtime_ms;
perfetto::base::Optional<uint64_t> opt_pending_allocs =
perfetto::base::CStringToUInt64(argv[3]);
if (!opt_runtime_ms) {
PERFETTO_FATAL("Invalid number of pending allocs: %s", argv[3]);
}
uint64_t pending_allocs = *opt_pending_allocs;
std::unique_lock<std::mutex> l(g_wake_up_mutex);
g_wake_up_cv.wait(l, [] { return g_rate > 0; });
perfetto::base::TimeMillis end =
perfetto::base::GetWallTimeMs() + perfetto::base::TimeMillis(runtime_ms);
std::vector<std::thread> threads;
for (size_t i = 0; i < static_cast<size_t>(no_threads); ++i)
threads.emplace_back(Thread, i, pending_allocs);
perfetto::base::TimeMillis current = perfetto::base::GetWallTimeMs();
while (current < end) {
usleep(useconds_t((end - current).count()) * 1000);
current = perfetto::base::GetWallTimeMs();
}
done.store(true, std::memory_order_relaxed);
for (std::thread& th : threads)
th.join();
printf("%" PRIu64 ",%" PRIu64 ",%" PRIu64 ",%" PRIu64 ",%" PRIu64 "\n",
no_threads, runtime_ms, pending_allocs, g_rate,
allocs.load(std::memory_order_relaxed));
return 0;
}