sql/database_memory_dump_provider.cc

   1 // Copyright 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "sql/database_memory_dump_provider.h"
   6
   7 #include <inttypes.h>
   8
   9 #include "base/strings/stringprintf.h"
  10 #include "base/trace_event/process_memory_dump.h"
  11 #include "third_party/sqlite/sqlite3.h"
  12
  13 namespace sql {
  14
  15 DatabaseMemoryDumpProvider::DatabaseMemoryDumpProvider(sqlite3* db,
  16                                                        const std::string& name)
  17     : db_(db), connection_name_(name) {}
  18
  19 DatabaseMemoryDumpProvider::~DatabaseMemoryDumpProvider() = default;
  20
  21 void DatabaseMemoryDumpProvider::ResetDatabase() {
  22   base::AutoLock lock(lock_);
  23   db_ = nullptr;
  24 }
  25
  26 bool DatabaseMemoryDumpProvider::OnMemoryDump(
  27     const base::trace_event::MemoryDumpArgs& args,
  28     base::trace_event::ProcessMemoryDump* pmd) {
  29   if (args.level_of_detail == base::trace_event::MemoryDumpLevelOfDetail::LIGHT)
  30     return true;
  31
  32   int cache_size = 0;
  33   int schema_size = 0;
  34   int statement_size = 0;
  35   if (!GetDbMemoryUsage(&cache_size, &schema_size, &statement_size)) {
  36     return false;
  37   }
  38
  39   base::trace_event::MemoryAllocatorDump* dump =
  40       pmd->CreateAllocatorDump(FormatDumpName());
  41   dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize,
  42                   base::trace_event::MemoryAllocatorDump::kUnitsBytes,
  43                   cache_size + schema_size + statement_size);
  44   dump->AddScalar("cache_size",
  45                   base::trace_event::MemoryAllocatorDump::kUnitsBytes,
  46                   cache_size);
  47   dump->AddScalar("schema_size",
  48                   base::trace_event::MemoryAllocatorDump::kUnitsBytes,
  49                   schema_size);
  50   dump->AddScalar("statement_size",
  51                   base::trace_event::MemoryAllocatorDump::kUnitsBytes,
  52                   statement_size);
  53   return true;
  54 }
  55
  56 bool DatabaseMemoryDumpProvider::ReportMemoryUsage(
  57     base::trace_event::ProcessMemoryDump* pmd,
  58     const std::string& dump_name) {
  59   int cache_size = 0;
  60   int schema_size = 0;
  61   int statement_size = 0;
  62   if (!GetDbMemoryUsage(&cache_size, &schema_size, &statement_size))
  63     return false;
  64
  65   auto* mad = pmd->CreateAllocatorDump(dump_name);
  66   mad->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize,
  67                  base::trace_event::MemoryAllocatorDump::kUnitsBytes,
  68                  cache_size + schema_size + statement_size);
  69   pmd->AddSuballocation(mad->guid(), FormatDumpName());
  70
  71   return true;
  72 }
  73
  74 bool DatabaseMemoryDumpProvider::GetDbMemoryUsage(int* cache_size,
  75                                                   int* schema_size,
  76                                                   int* statement_size) {
  77   // Lock is acquired here so that db_ is not reset in ResetDatabase when
  78   // collecting stats.
  79   base::AutoLock lock(lock_);
  80   if (!db_) {
  81     return false;
  82   }
  83
  84   // The high water mark is not tracked for the following usages.
  85   int dummy_int;
  86   int status = sqlite3_db_status(db_, SQLITE_DBSTATUS_CACHE_USED, cache_size,
  87                                  &dummy_int, 0 /* resetFlag */);
  88   DCHECK_EQ(SQLITE_OK, status);
  89   status = sqlite3_db_status(db_, SQLITE_DBSTATUS_SCHEMA_USED, schema_size,
  90                              &dummy_int, 0 /* resetFlag */);
  91   DCHECK_EQ(SQLITE_OK, status);
  92   status = sqlite3_db_status(db_, SQLITE_DBSTATUS_STMT_USED, statement_size,
  93                              &dummy_int, 0 /* resetFlag */);
  94   DCHECK_EQ(SQLITE_OK, status);
  95
  96   return true;
  97 }
  98
  99 std::string DatabaseMemoryDumpProvider::FormatDumpName() const {
 100   return base::StringPrintf(
 101       "sqlite/%s_connection/0x%" PRIXPTR,
 102       connection_name_.empty() ? "Unknown" : connection_name_.c_str(),
 103       reinterpret_cast<uintptr_t>(this));
 104 }
 105
 106 }  // namespace sql