| // Copyright 2019 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "src/developer/memory/monitor/metrics.h" |
| |
| #include <lib/async/cpp/executor.h> |
| #include <lib/gtest/real_loop_fixture.h> |
| #include <lib/inspect/testing/cpp/inspect.h> |
| #include <lib/sys/cpp/testing/component_context_provider.h> |
| #include <zircon/time.h> |
| |
| #include <gtest/gtest.h> |
| #include <src/cobalt/bin/testing/fake_logger.h> |
| |
| #include "src/developer/memory/metrics/capture.h" |
| #include "src/developer/memory/metrics/tests/test_utils.h" |
| |
| using namespace memory; |
| |
| using cobalt_registry::MemoryMetricDimensionBucket; |
| using fuchsia::cobalt::EventPayload; |
| |
| namespace monitor { |
| namespace { |
| |
| class MetricsUnitTest : public gtest::RealLoopFixture { |
| public: |
| MetricsUnitTest() : executor_(dispatcher()) {} |
| |
| protected: |
| // Run a promise to completion on the default async executor. |
| void RunPromiseToCompletion(fit::promise<> promise) { |
| bool done = false; |
| executor_.schedule_task(std::move(promise).and_then([&]() { done = true; })); |
| RunLoopUntilIdle(); |
| ASSERT_TRUE(done); |
| } |
| std::vector<CaptureTemplate> Template() { |
| return std::vector<CaptureTemplate>{{ |
| .time = zx_nsec_from_duration(zx_duration_from_hour(7)), |
| .kmem = |
| { |
| .total_bytes = 2000, |
| .free_bytes = 800, |
| .wired_bytes = 60, |
| .total_heap_bytes = 200, |
| .free_heap_bytes = 80, |
| .vmo_bytes = 900, |
| .mmu_overhead_bytes = 60, |
| .ipc_bytes = 10, |
| .other_bytes = 20, |
| }, |
| .vmos = |
| { |
| {.koid = 1, .name = "uncompressed-bootfs", .committed_bytes = 1}, |
| {.koid = 2, .name = "magma_create_buffer", .committed_bytes = 2}, |
| {.koid = 3, .name = "SysmemAmlogicProtectedPool", .committed_bytes = 3}, |
| {.koid = 4, .name = "SysmemContiguousPool", .committed_bytes = 4}, |
| {.koid = 5, .name = "test", .committed_bytes = 5}, |
| {.koid = 6, .name = "test", .committed_bytes = 6}, |
| {.koid = 7, .name = "test", .committed_bytes = 7}, |
| {.koid = 8, .name = "dart", .committed_bytes = 8}, |
| {.koid = 9, .name = "test", .committed_bytes = 9}, |
| {.koid = 10, .name = "test", .committed_bytes = 10}, |
| {.koid = 11, .name = "test", .committed_bytes = 11}, |
| {.koid = 12, .name = "test", .committed_bytes = 12}, |
| {.koid = 13, .name = "test", .committed_bytes = 13}, |
| {.koid = 14, .name = "test", .committed_bytes = 14}, |
| {.koid = 15, .name = "test", .committed_bytes = 15}, |
| {.koid = 16, .name = "test", .committed_bytes = 16}, |
| {.koid = 17, .name = "test", .committed_bytes = 17}, |
| {.koid = 18, .name = "test", .committed_bytes = 18}, |
| {.koid = 19, .name = "test", .committed_bytes = 19}, |
| {.koid = 20, .name = "test", .committed_bytes = 20}, |
| {.koid = 21, .name = "test", .committed_bytes = 21}, |
| {.koid = 22, .name = "test", .committed_bytes = 22}, |
| }, |
| .processes = |
| { |
| {.koid = 1, .name = "bin/bootsvc", .vmos = {1}}, |
| {.koid = 2, .name = "test", .vmos = {2}}, |
| {.koid = 3, .name = "driver_host:sys", .vmos = {3, 4}}, |
| {.koid = 4, .name = "fshost.cm", .vmos = {5}}, |
| {.koid = 5, .name = "/boot/bin/minfs", .vmos = {6}}, |
| {.koid = 6, .name = "/boot/bin/blobfs", .vmos = {7}}, |
| {.koid = 7, .name = "io.flutter.product_runner.aot", .vmos = {8,9}}, |
| {.koid = 8, .name = "web_engine_exe:renderer", .vmos = {10}}, |
| {.koid = 9, .name = "web_engine_exe:gpu", .vmos = {11}}, |
| {.koid = 10, .name = "kronk.cmx", .vmos = {12}}, |
| {.koid = 11, .name = "scenic.cmx", .vmos = {13}}, |
| {.koid = 12, .name = "driver_host:pdev:05:00:f", .vmos = {14}}, |
| {.koid = 13, .name = "netstack.cmx", .vmos = {15}}, |
| {.koid = 14, .name = "pkgfs", .vmos = {16}}, |
| {.koid = 15, .name = "cast_agent.cmx", .vmos = {17}}, |
| {.koid = 16, .name = "archivist.cm", .vmos = {18}}, |
| {.koid = 17, .name = "cobalt.cmx", .vmos = {19}}, |
| {.koid = 18, .name = "audio_core.cmx", .vmos = {20}}, |
| {.koid = 19, .name = "context_provider.cmx", .vmos = {21}}, |
| {.koid = 20, .name = "new", .vmos = {22}}, |
| }, |
| }}; |
| } |
| async::Executor executor_; |
| sys::testing::ComponentContextProvider context_provider_; |
| }; |
| |
| TEST_F(MetricsUnitTest, Inspect) { |
| CaptureSupplier cs(Template()); |
| cobalt::FakeLogger_Sync logger; |
| sys::ComponentInspector inspector(context_provider_.context()); |
| Metrics m(zx::min(5), dispatcher(), &inspector, &logger, [&cs](Capture* c, CaptureLevel l) { |
| return cs.GetCapture(c, l, true /*use_capture_supplier_time*/); |
| }); |
| RunLoopUntil([&cs] { return cs.empty(); }); |
| |
| // [START get_hierarchy] |
| fit::result<inspect::Hierarchy> hierarchy; |
| RunPromiseToCompletion( |
| inspect::ReadFromInspector(*inspector.inspector()) |
| .then([&](fit::result<inspect::Hierarchy>& result) { hierarchy = std::move(result); })); |
| ASSERT_TRUE(hierarchy.is_ok()); |
| // [END get_hierarchy] |
| |
| // [START assertions] |
| auto* metric_node = hierarchy.value().GetByPath({Metrics::kInspectPlatformNodeName}); |
| ASSERT_TRUE(metric_node); |
| |
| auto* metric_memory = metric_node->GetByPath({Metrics::kMemoryNodeName}); |
| ASSERT_TRUE(metric_memory); |
| |
| auto* usage_readings = metric_memory->node().get_property<inspect::UintPropertyValue>("Graphics"); |
| ASSERT_TRUE(usage_readings); |
| EXPECT_EQ(2u, usage_readings->value()); |
| } |
| |
| TEST_F(MetricsUnitTest, All) { |
| CaptureSupplier cs(Template()); |
| cobalt::FakeLogger_Sync logger; |
| sys::ComponentInspector inspector(context_provider_.context()); |
| Metrics m(zx::msec(10), dispatcher(), &inspector, &logger, [&cs](Capture* c, CaptureLevel l) { |
| return cs.GetCapture(c, l, true /*use_capture_supplier_time*/); |
| }); |
| RunLoopUntil([&cs] { return cs.empty(); }); |
| // memory metric: 20 buckets + 4 (Orphaned, Kernel, Undigested and Free buckets) + |
| // memory_general_breakdown metric: 10 + |
| // memory_leak metric: 10 |
| // = 44 |
| EXPECT_EQ(44U, logger.logged_events().size()); |
| using Breakdown = cobalt_registry::MemoryGeneralBreakdownMetricDimensionGeneralBreakdown; |
| using Breakdown2 = cobalt_registry::MemoryLeakMetricDimensionGeneralBreakdown; |
| for (const auto& cobalt_event : logger.logged_events()) { |
| EXPECT_EQ(EventPayload::Tag::kMemoryBytesUsed, cobalt_event.payload.Which()); |
| switch (cobalt_event.metric_id) { |
| case cobalt_registry::kMemoryMetricId: |
| ASSERT_EQ(1u, cobalt_event.event_codes.size()); |
| switch (cobalt_event.event_codes[0]) { |
| case MemoryMetricDimensionBucket::ZbiBuffer: |
| EXPECT_EQ(1u, cobalt_event.payload.memory_bytes_used()); |
| break; |
| case MemoryMetricDimensionBucket::Graphics: |
| EXPECT_EQ(2u, cobalt_event.payload.memory_bytes_used()); |
| break; |
| case MemoryMetricDimensionBucket::ProtectedPool: |
| EXPECT_EQ(3u, cobalt_event.payload.memory_bytes_used()); |
| break; |
| case MemoryMetricDimensionBucket::ContiguousPool: |
| EXPECT_EQ(4u, cobalt_event.payload.memory_bytes_used()); |
| break; |
| case MemoryMetricDimensionBucket::Fshost: |
| EXPECT_EQ(5u, cobalt_event.payload.memory_bytes_used()); |
| break; |
| case MemoryMetricDimensionBucket::Minfs: |
| EXPECT_EQ(6u, cobalt_event.payload.memory_bytes_used()); |
| break; |
| case MemoryMetricDimensionBucket::Blobfs: |
| EXPECT_EQ(7u, cobalt_event.payload.memory_bytes_used()); |
| break; |
| case MemoryMetricDimensionBucket::FlutterApps: |
| EXPECT_EQ(8u, cobalt_event.payload.memory_bytes_used()); |
| break; |
| case MemoryMetricDimensionBucket::Flutter: |
| EXPECT_EQ(9u, cobalt_event.payload.memory_bytes_used()); |
| break; |
| case MemoryMetricDimensionBucket::Web: |
| EXPECT_EQ(21u, cobalt_event.payload.memory_bytes_used()); |
| break; |
| case MemoryMetricDimensionBucket::Kronk: |
| EXPECT_EQ(12u, cobalt_event.payload.memory_bytes_used()); |
| break; |
| case MemoryMetricDimensionBucket::Scenic: |
| EXPECT_EQ(13u, cobalt_event.payload.memory_bytes_used()); |
| break; |
| case MemoryMetricDimensionBucket::Amlogic: |
| EXPECT_EQ(14u, cobalt_event.payload.memory_bytes_used()); |
| break; |
| case MemoryMetricDimensionBucket::Netstack: |
| EXPECT_EQ(15u, cobalt_event.payload.memory_bytes_used()); |
| break; |
| case MemoryMetricDimensionBucket::Pkgfs: |
| EXPECT_EQ(16u, cobalt_event.payload.memory_bytes_used()); |
| break; |
| case MemoryMetricDimensionBucket::Cast: |
| EXPECT_EQ(17u, cobalt_event.payload.memory_bytes_used()); |
| break; |
| case MemoryMetricDimensionBucket::Archivist: |
| EXPECT_EQ(18u, cobalt_event.payload.memory_bytes_used()); |
| break; |
| case MemoryMetricDimensionBucket::Cobalt: |
| EXPECT_EQ(19u, cobalt_event.payload.memory_bytes_used()); |
| break; |
| case MemoryMetricDimensionBucket::Audio: |
| EXPECT_EQ(20u, cobalt_event.payload.memory_bytes_used()); |
| break; |
| case MemoryMetricDimensionBucket::Context: |
| EXPECT_EQ(21u, cobalt_event.payload.memory_bytes_used()); |
| break; |
| case MemoryMetricDimensionBucket::Undigested: |
| EXPECT_EQ(22, cobalt_event.payload.memory_bytes_used()); |
| break; |
| case MemoryMetricDimensionBucket::Orphaned: |
| // 900 kmem.vmo - (1 + 2 + 3 + ... + 22) vmo digested in buckets = 647 |
| EXPECT_EQ(647, cobalt_event.payload.memory_bytes_used()); |
| break; |
| case MemoryMetricDimensionBucket::Kernel: |
| // 60 wired + 200 total_heap + 60 mmu_overhead + 10 ipc + 20 other = 350 |
| EXPECT_EQ(350u, cobalt_event.payload.memory_bytes_used()); |
| break; |
| case MemoryMetricDimensionBucket::Free: |
| EXPECT_EQ(800u, cobalt_event.payload.memory_bytes_used()); |
| break; |
| default: |
| ADD_FAILURE(); |
| break; |
| } |
| break; |
| case cobalt_registry::kMemoryGeneralBreakdownMetricId: |
| ASSERT_EQ(1u, cobalt_event.event_codes.size()); |
| switch (cobalt_event.event_codes[0]) { |
| case Breakdown::TotalBytes: |
| EXPECT_EQ(2000u, cobalt_event.payload.memory_bytes_used()); |
| break; |
| case Breakdown::UsedBytes: |
| EXPECT_EQ(1200u, cobalt_event.payload.memory_bytes_used()); |
| break; |
| case Breakdown::VmoBytes: |
| EXPECT_EQ(900u, cobalt_event.payload.memory_bytes_used()); |
| break; |
| case Breakdown::FreeBytes: |
| EXPECT_EQ(800u, cobalt_event.payload.memory_bytes_used()); |
| break; |
| default: |
| EXPECT_TRUE(cobalt_event.payload.memory_bytes_used() <= 200); |
| break; |
| } |
| break; |
| case cobalt_registry::kMemoryLeakMetricId: |
| ASSERT_EQ(2u, cobalt_event.event_codes.size()); |
| ASSERT_EQ(cobalt_registry::MemoryLeakMetricDimensionTimeSinceBoot::UpSixHours, |
| cobalt_event.event_codes[1]); |
| switch (cobalt_event.event_codes[0]) { |
| case Breakdown2::TotalBytes: |
| EXPECT_EQ(2000u, cobalt_event.payload.memory_bytes_used()); |
| break; |
| case Breakdown2::UsedBytes: |
| EXPECT_EQ(1200u, cobalt_event.payload.memory_bytes_used()); |
| break; |
| case Breakdown2::VmoBytes: |
| EXPECT_EQ(900u, cobalt_event.payload.memory_bytes_used()); |
| break; |
| case Breakdown2::FreeBytes: |
| EXPECT_EQ(800u, cobalt_event.payload.memory_bytes_used()); |
| break; |
| default: |
| EXPECT_TRUE(cobalt_event.payload.memory_bytes_used() <= 200); |
| break; |
| } |
| break; |
| } |
| } |
| } |
| |
| TEST_F(MetricsUnitTest, One) { |
| CaptureSupplier cs({{ |
| .kmem = |
| { |
| .total_bytes = 0, |
| .free_bytes = 0, |
| .wired_bytes = 0, |
| .total_heap_bytes = 0, |
| .free_heap_bytes = 0, |
| .vmo_bytes = 0, |
| .mmu_overhead_bytes = 0, |
| .ipc_bytes = 0, |
| .other_bytes = 0, |
| }, |
| .vmos = |
| { |
| {.koid = 1, .name = "", .committed_bytes = 1}, |
| }, |
| .processes = |
| { |
| {.koid = 1, .name = "bin/bootsvc", .vmos = {1}}, |
| }, |
| }}); |
| cobalt::FakeLogger_Sync logger; |
| sys::ComponentInspector inspector(context_provider_.context()); |
| Metrics m(zx::msec(10), dispatcher(), &inspector, &logger, |
| [&cs](Capture* c, CaptureLevel l) { return cs.GetCapture(c, l); }); |
| RunLoopUntil([&cs] { return cs.empty(); }); |
| EXPECT_EQ(21U, logger.event_count()); // 1 + 10 + 10 |
| } |
| |
| TEST_F(MetricsUnitTest, Undigested) { |
| CaptureSupplier cs({{ |
| .kmem = |
| { |
| .total_bytes = 0, |
| .free_bytes = 0, |
| .wired_bytes = 0, |
| .total_heap_bytes = 0, |
| .free_heap_bytes = 0, |
| .vmo_bytes = 0, |
| .mmu_overhead_bytes = 0, |
| .ipc_bytes = 0, |
| .other_bytes = 0, |
| }, |
| .vmos = |
| { |
| {.koid = 1, .name = "uncompressed-bootfs", .committed_bytes = 1}, |
| {.koid = 2, .name = "test", .committed_bytes = 2}, |
| }, |
| .processes = |
| { |
| {.koid = 1, .name = "bin/bootsvc", .vmos = {1}}, |
| {.koid = 2, .name = "test", .vmos = {2}}, |
| }, |
| }}); |
| cobalt::FakeLogger_Sync logger; |
| sys::ComponentInspector inspector(context_provider_.context()); |
| Metrics m(zx::msec(10), dispatcher(), &inspector, &logger, |
| [&cs](Capture* c, CaptureLevel l) { return cs.GetCapture(c, l); }); |
| RunLoopUntil([&cs] { return cs.empty(); }); |
| EXPECT_EQ(22U, logger.event_count()); // 2 + 10 + 10 |
| } |
| |
| } // namespace |
| } // namespace monitor |
