Add a multiplier in tracking certificate memory allocation size

net/ssl/ssl_client_session_cache.cc

 // Copyright 2015 The Chromium 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 "net/ssl/ssl_client_session_cache.h"
 
 #include <utility>
 
+#include "base/containers/flat_set.h"
 #include "base/memory/memory_coordinator_client_registry.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/clock.h"
 #include "base/time/default_clock.h"
 #include "base/trace_event/process_memory_dump.h"
 #include "net/cert/x509_util_openssl.h"
 #include "third_party/boringssl/src/include/openssl/ssl.h"
 #include "third_party/boringssl/src/include/openssl/x509.h"
 
 namespace net {
@@ skipping 96 matching lines @@
   std::string absolute_name = "net/ssl_session_cache";
   base::trace_event::MemoryAllocatorDump* cache_dump =
       pmd->GetAllocatorDump(absolute_name);
   // This method can be reached from different URLRequestContexts. Since this is
   // a singleton, only log memory stats once.
   // TODO(xunjieli): Change this once crbug.com/458365 is fixed.
   if (cache_dump)
     return;
   cache_dump = pmd->CreateAllocatorDump(absolute_name);
   base::AutoLock lock(lock_);
-  size_t total_serialized_cert_size = 0;
+  size_t total_cert_size = 0;
+  size_t undeduped_cert_size = 0;
   size_t total_cert_count = 0;
+  // Use a flat_set here to avoid malloc upon insertion.
+  base::flat_set<const CRYPTO_BUFFER*> crypto_buffer_set;

[DmitrySkiba, 2017/02/21 22:08:25]

Two things:

1. We need to resize crypto_buffer_set before using it, to make sure it doesn't
allocate. The only way to do this (I think) is to count total_cert_count in a
separate loop.

2. Instead of find/insert you can just always call insert() and analyze its
return value. That'll avoid double lookups when we insert new cert.

   for (const auto& pair : cache_) {
     const SSL_SESSION* session = pair.second.session.get();
     size_t cert_count = sk_CRYPTO_BUFFER_num(session->certs);
     total_cert_count += cert_count;
     for (size_t i = 0; i < cert_count; ++i) {
       const CRYPTO_BUFFER* cert = sk_CRYPTO_BUFFER_value(session->certs, i);
-      total_serialized_cert_size += CRYPTO_BUFFER_len(cert);
+      // TODO(xunjieli): The multipler is added to account for the difference
+      // between the serialized form and real cert allocation. Remove after
+      // crbug.com/671420 is done.
+      size_t cert_size = 4 * CRYPTO_BUFFER_len(cert);
+      undeduped_cert_size += cert_size;
+      if (crypto_buffer_set.find(cert) != crypto_buffer_set.end())
+        continue;
+      total_cert_size += cert_size;
+      crypto_buffer_set.insert(cert);
     }
   }
   // This measures the lower bound of the serialized certificate. It doesn't
   // measure the actual memory used, which is 4x this amount (see
   // crbug.com/671420 for more details).
-  cache_dump->AddScalar("serialized_cert_size",
+  cache_dump->AddScalar("cert_size",
                         base::trace_event::MemoryAllocatorDump::kUnitsBytes,
-                        total_serialized_cert_size);
+                        total_cert_size);
+  cache_dump->AddScalar("undeduped_cert_size",
+                        base::trace_event::MemoryAllocatorDump::kUnitsBytes,
+                        undeduped_cert_size);
   cache_dump->AddScalar("cert_count",
                         base::trace_event::MemoryAllocatorDump::kUnitsObjects,
                         total_cert_count);
   cache_dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize,
                         base::trace_event::MemoryAllocatorDump::kUnitsBytes,
-                        total_serialized_cert_size);
+                        total_cert_size);
 }
 
 SSLClientSessionCache::Entry::Entry() : lookups(0) {}
 SSLClientSessionCache::Entry::Entry(Entry&&) = default;
 SSLClientSessionCache::Entry::~Entry() = default;
 
 void SSLClientSessionCache::FlushExpiredSessions() {
   time_t now = clock_->Now().ToTimeT();
   auto iter = cache_.begin();
   while (iter != cache_.end()) {
@@ skipping 17 matching lines @@
       Flush();
       break;
   }
 }
 
 void SSLClientSessionCache::OnPurgeMemory() {
   Flush();
 }
 
 }  // namespace net