Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(205)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: base/tracked_objects_unittest.cc

Issue 2386123003: Add heap allocator usage to task profiler. (Closed)
Patch Set: Figure out where the @#$%! corruption is coming from. Move heap tracking to TaskStopwatch." Created 4 years, 2 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« base/tracked_objects.cc ('K') | « base/tracked_objects.cc ('k') | chrome/browser/chrome_browser_main.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: base/tracked_objects_unittest.cc
diff --git a/base/tracked_objects_unittest.cc b/base/tracked_objects_unittest.cc
index 70d9601cd0f9be78570cabab1ce23d7b6413917e..5caf7356640356493432de842f5ffaaea8563f89 100644
--- a/base/tracked_objects_unittest.cc
+++ b/base/tracked_objects_unittest.cc
@@ -11,6 +11,7 @@
#include <memory>
+#include "base/debug/scoped_thread_heap_usage.h"
#include "base/process/process_handle.h"
#include "base/time/time.h"
#include "base/tracking_info.h"
@@ -22,6 +23,13 @@ const char kWorkerThreadName[] = "WorkerThread-1";
const char kMainThreadName[] = "SomeMainThreadName";
const char kStillAlive[] = "Still_Alive";
+const uint32_t kAllocOps = 23;
+const uint32_t kFreeOps = 27;
+const uint32_t kAllocatedBytes = 59934;
+const uint32_t kFreedBytes = 2 * kAllocatedBytes;
+const uint32_t kAllocOverheadBytes = kAllocOps * 8;
+const uint32_t kMaxAllocatedBytes = kAllocatedBytes / 2;
+
namespace tracked_objects {
class TrackedObjectsTest : public testing::Test {
@@ -237,7 +245,7 @@ TEST_F(TrackedObjectsTest, TinyStartupShutdown) {
EXPECT_EQ(kWorkerThreadName, process_data_phase.tasks[0].death_thread_name);
}
-TEST_F(TrackedObjectsTest, DeathDataTestRecordDeath) {
+TEST_F(TrackedObjectsTest, DeathDataTestRecordDurations) {
ThreadData::InitializeAndSetTrackingStatus(ThreadData::PROFILING_ACTIVE);
std::unique_ptr<DeathData> data(new DeathData());
@@ -255,7 +263,7 @@ TEST_F(TrackedObjectsTest, DeathDataTestRecordDeath) {
int32_t queue_ms = 8;
const int kUnrandomInt = 0; // Fake random int that ensure we sample data.
- data->RecordDeath(queue_ms, run_ms, kUnrandomInt);
+ data->RecordDurations(queue_ms, run_ms, kUnrandomInt);
EXPECT_EQ(data->run_duration_sum(), run_ms);
EXPECT_EQ(data->run_duration_max(), run_ms);
EXPECT_EQ(data->run_duration_sample(), run_ms);
@@ -265,7 +273,7 @@ TEST_F(TrackedObjectsTest, DeathDataTestRecordDeath) {
EXPECT_EQ(data->count(), 1);
EXPECT_EQ(nullptr, data->last_phase_snapshot());
- data->RecordDeath(queue_ms, run_ms, kUnrandomInt);
+ data->RecordDurations(queue_ms, run_ms, kUnrandomInt);
EXPECT_EQ(data->run_duration_sum(), run_ms + run_ms);
EXPECT_EQ(data->run_duration_max(), run_ms);
EXPECT_EQ(data->run_duration_sample(), run_ms);
@@ -276,18 +284,77 @@ TEST_F(TrackedObjectsTest, DeathDataTestRecordDeath) {
EXPECT_EQ(nullptr, data->last_phase_snapshot());
}
+TEST_F(TrackedObjectsTest, DeathDataTestRecordAllocations) {
+ ThreadData::InitializeAndSetTrackingStatus(ThreadData::PROFILING_ACTIVE);
+
+ std::unique_ptr<DeathData> data(new DeathData());
+ ASSERT_NE(data, nullptr);
+
+ EXPECT_EQ(data->alloc_ops(), 0);
+ EXPECT_EQ(data->free_ops(), 0);
+ EXPECT_EQ(data->allocated_bytes(), 0);
+ EXPECT_EQ(data->freed_bytes(), 0);
+ EXPECT_EQ(data->alloc_overhead_bytes(), 0);
+ EXPECT_EQ(data->max_allocated_bytes(), 0);
+
+ EXPECT_EQ(nullptr, data->last_phase_snapshot());
+
+ data->RecordAllocations(kAllocOps, kFreeOps, kAllocatedBytes, kFreedBytes,
+ kAllocOverheadBytes, kMaxAllocatedBytes);
+ EXPECT_EQ(data->alloc_ops(), kAllocOps);
+ EXPECT_EQ(data->free_ops(), kFreeOps);
+ EXPECT_EQ(data->allocated_bytes(), kAllocatedBytes);
+ EXPECT_EQ(data->freed_bytes(), kFreedBytes);
+ EXPECT_EQ(data->alloc_overhead_bytes(), kAllocOverheadBytes);
+ EXPECT_EQ(data->max_allocated_bytes(), kMaxAllocatedBytes);
+
+ // Record another batch, with a smaller max.
+ const uint32_t kSmallerMaxAllocatedBytes = kMaxAllocatedBytes / 2;
+ data->RecordAllocations(kAllocOps, kFreeOps, kAllocatedBytes, kFreedBytes,
+ kAllocOverheadBytes, kSmallerMaxAllocatedBytes);
+ EXPECT_EQ(data->alloc_ops(), 2 * kAllocOps);
+ EXPECT_EQ(data->free_ops(), 2 * kFreeOps);
+ EXPECT_EQ(data->allocated_bytes(), 2 * kAllocatedBytes);
+ EXPECT_EQ(data->freed_bytes(), 2 * kFreedBytes);
+ EXPECT_EQ(data->alloc_overhead_bytes(), 2 * kAllocOverheadBytes);
+ EXPECT_EQ(data->max_allocated_bytes(), kMaxAllocatedBytes);
+
+ // Now with a larger max.
+ const uint32_t kLargerMaxAllocatedBytes = kMaxAllocatedBytes * 2;
+ data->RecordAllocations(kAllocOps, kFreeOps, kAllocatedBytes, kFreedBytes,
+ kAllocOverheadBytes, kLargerMaxAllocatedBytes);
+ EXPECT_EQ(data->alloc_ops(), 3 * kAllocOps);
+ EXPECT_EQ(data->free_ops(), 3 * kFreeOps);
+ EXPECT_EQ(data->allocated_bytes(), 3 * kAllocatedBytes);
+ EXPECT_EQ(data->freed_bytes(), 3 * kFreedBytes);
+ EXPECT_EQ(data->alloc_overhead_bytes(), 3 * kAllocOverheadBytes);
+ EXPECT_EQ(data->max_allocated_bytes(), kLargerMaxAllocatedBytes);
+
+ // Saturate everything.
+ data->RecordAllocations(INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX);
+ EXPECT_EQ(data->alloc_ops(), INT_MAX);
+ EXPECT_EQ(data->free_ops(), INT_MAX);
+ EXPECT_EQ(data->allocated_bytes(), INT_MAX);
+ EXPECT_EQ(data->freed_bytes(), INT_MAX);
+ EXPECT_EQ(data->alloc_overhead_bytes(), INT_MAX);
+ EXPECT_EQ(data->max_allocated_bytes(), INT_MAX);
+}
+
TEST_F(TrackedObjectsTest, DeathDataTest2Phases) {
ThreadData::InitializeAndSetTrackingStatus(ThreadData::PROFILING_ACTIVE);
std::unique_ptr<DeathData> data(new DeathData());
ASSERT_NE(data, nullptr);
- int32_t run_ms = 42;
- int32_t queue_ms = 8;
+ const int32_t run_ms = 42;
+ const int32_t queue_ms = 8;
const int kUnrandomInt = 0; // Fake random int that ensure we sample data.
- data->RecordDeath(queue_ms, run_ms, kUnrandomInt);
- data->RecordDeath(queue_ms, run_ms, kUnrandomInt);
+ data->RecordDurations(queue_ms, run_ms, kUnrandomInt);
+ data->RecordDurations(queue_ms, run_ms, kUnrandomInt);
+
+ data->RecordAllocations(kAllocOps, kFreeOps, kAllocatedBytes, kFreedBytes,
+ kAllocOverheadBytes, kMaxAllocatedBytes);
data->OnProfilingPhaseCompleted(123);
EXPECT_EQ(data->run_duration_sum(), run_ms + run_ms);
@@ -297,6 +364,14 @@ TEST_F(TrackedObjectsTest, DeathDataTest2Phases) {
EXPECT_EQ(data->queue_duration_max(), 0);
EXPECT_EQ(data->queue_duration_sample(), queue_ms);
EXPECT_EQ(data->count(), 2);
+
+ EXPECT_EQ(data->alloc_ops(), kAllocOps);
+ EXPECT_EQ(data->free_ops(), kFreeOps);
+ EXPECT_EQ(data->allocated_bytes(), kAllocatedBytes);
+ EXPECT_EQ(data->freed_bytes(), kFreedBytes);
+ EXPECT_EQ(data->alloc_overhead_bytes(), kAllocOverheadBytes);
+ EXPECT_EQ(data->max_allocated_bytes(), kMaxAllocatedBytes);
+
ASSERT_NE(nullptr, data->last_phase_snapshot());
EXPECT_EQ(123, data->last_phase_snapshot()->profiling_phase);
EXPECT_EQ(2, data->last_phase_snapshot()->death_data.count);
@@ -311,12 +386,26 @@ TEST_F(TrackedObjectsTest, DeathDataTest2Phases) {
data->last_phase_snapshot()->death_data.queue_duration_max);
EXPECT_EQ(queue_ms,
data->last_phase_snapshot()->death_data.queue_duration_sample);
+
+ EXPECT_EQ(kAllocOps, data->last_phase_snapshot()->death_data.alloc_ops);
+ EXPECT_EQ(kFreeOps, data->last_phase_snapshot()->death_data.free_ops);
+ EXPECT_EQ(kAllocatedBytes,
+ data->last_phase_snapshot()->death_data.allocated_bytes);
+ EXPECT_EQ(kFreedBytes, data->last_phase_snapshot()->death_data.freed_bytes);
+ EXPECT_EQ(kAllocOverheadBytes,
+ data->last_phase_snapshot()->death_data.alloc_overhead_bytes);
+ EXPECT_EQ(kMaxAllocatedBytes,
+ data->last_phase_snapshot()->death_data.max_allocated_bytes);
+
EXPECT_EQ(nullptr, data->last_phase_snapshot()->prev);
- int32_t run_ms1 = 21;
- int32_t queue_ms1 = 4;
+ const int32_t run_ms1 = 21;
+ const int32_t queue_ms1 = 4;
+
+ data->RecordDurations(queue_ms1, run_ms1, kUnrandomInt);
+ data->RecordAllocations(kAllocOps, kFreeOps, kAllocatedBytes, kFreedBytes,
+ kAllocOverheadBytes, kMaxAllocatedBytes);
- data->RecordDeath(queue_ms1, run_ms1, kUnrandomInt);
EXPECT_EQ(data->run_duration_sum(), run_ms + run_ms + run_ms1);
EXPECT_EQ(data->run_duration_max(), run_ms1);
EXPECT_EQ(data->run_duration_sample(), run_ms1);
@@ -324,6 +413,14 @@ TEST_F(TrackedObjectsTest, DeathDataTest2Phases) {
EXPECT_EQ(data->queue_duration_max(), queue_ms1);
EXPECT_EQ(data->queue_duration_sample(), queue_ms1);
EXPECT_EQ(data->count(), 3);
+
+ EXPECT_EQ(data->alloc_ops(), 2 * kAllocOps);
+ EXPECT_EQ(data->free_ops(), 2 * kFreeOps);
+ EXPECT_EQ(data->allocated_bytes(), 2 * kAllocatedBytes);
+ EXPECT_EQ(data->freed_bytes(), 2 * kFreedBytes);
+ EXPECT_EQ(data->alloc_overhead_bytes(), 2 * kAllocOverheadBytes);
+ EXPECT_EQ(data->max_allocated_bytes(), kMaxAllocatedBytes);
+
ASSERT_NE(nullptr, data->last_phase_snapshot());
EXPECT_EQ(123, data->last_phase_snapshot()->profiling_phase);
EXPECT_EQ(2, data->last_phase_snapshot()->death_data.count);
@@ -338,6 +435,17 @@ TEST_F(TrackedObjectsTest, DeathDataTest2Phases) {
data->last_phase_snapshot()->death_data.queue_duration_max);
EXPECT_EQ(queue_ms,
data->last_phase_snapshot()->death_data.queue_duration_sample);
+
+ EXPECT_EQ(kAllocOps, data->last_phase_snapshot()->death_data.alloc_ops);
+ EXPECT_EQ(kFreeOps, data->last_phase_snapshot()->death_data.free_ops);
+ EXPECT_EQ(kAllocatedBytes,
+ data->last_phase_snapshot()->death_data.allocated_bytes);
+ EXPECT_EQ(kFreedBytes, data->last_phase_snapshot()->death_data.freed_bytes);
+ EXPECT_EQ(kAllocOverheadBytes,
+ data->last_phase_snapshot()->death_data.alloc_overhead_bytes);
+ EXPECT_EQ(kMaxAllocatedBytes,
+ data->last_phase_snapshot()->death_data.max_allocated_bytes);
+
EXPECT_EQ(nullptr, data->last_phase_snapshot()->prev);
}
@@ -353,6 +461,13 @@ TEST_F(TrackedObjectsTest, Delta) {
snapshot.queue_duration_max = 101;
snapshot.queue_duration_sample = 26;
+ snapshot.alloc_ops = 95;
+ snapshot.free_ops = 90;
+ snapshot.allocated_bytes = 10240;
+ snapshot.freed_bytes = 4096;
+ snapshot.alloc_overhead_bytes = 950;
+ snapshot.max_allocated_bytes = 10240;
+
DeathDataSnapshot older_snapshot;
older_snapshot.count = 2;
older_snapshot.run_duration_sum = 95;
@@ -362,6 +477,13 @@ TEST_F(TrackedObjectsTest, Delta) {
older_snapshot.queue_duration_max = 99;
older_snapshot.queue_duration_sample = 21;
+ older_snapshot.alloc_ops = 45;
+ older_snapshot.free_ops = 40;
+ older_snapshot.allocated_bytes = 4096;
+ older_snapshot.freed_bytes = 2048;
+ older_snapshot.alloc_overhead_bytes = 450;
+ older_snapshot.max_allocated_bytes = 10200;
+
const DeathDataSnapshot& delta = snapshot.Delta(older_snapshot);
EXPECT_EQ(8, delta.count);
EXPECT_EQ(5, delta.run_duration_sum);
@@ -370,6 +492,13 @@ TEST_F(TrackedObjectsTest, Delta) {
EXPECT_EQ(10, delta.queue_duration_sum);
EXPECT_EQ(101, delta.queue_duration_max);
EXPECT_EQ(26, delta.queue_duration_sample);
+
+ EXPECT_EQ(50, delta.alloc_ops);
+ EXPECT_EQ(50, delta.free_ops);
+ EXPECT_EQ(6144, delta.allocated_bytes);
+ EXPECT_EQ(2048, delta.freed_bytes);
+ EXPECT_EQ(500, delta.alloc_overhead_bytes);
+ EXPECT_EQ(10240, delta.max_allocated_bytes);
}
TEST_F(TrackedObjectsTest, DeactivatedBirthOnlyToSnapshotWorkerThread) {
@@ -732,6 +861,7 @@ TEST_F(TrackedObjectsTest, TwoPhasesSecondEmpty) {
SetTestTime(kEndOfRun);
stopwatch.Stop();
+ // DO NOT SUBMIT
ThreadData::TallyRunOnNamedThreadIfTracking(pending_task, stopwatch);
ThreadData::OnProfilingPhaseCompleted(0);
« base/tracked_objects.cc ('K') | « base/tracked_objects.cc ('k') | chrome/browser/chrome_browser_main.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698