SDCH: add TimeWeightedMemoryUse

net/sdch/sdch_owner.cc

 // Copyright 2014 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/sdch/sdch_owner.h"
 
 #include "base/bind.h"
 #include "base/debug/alias.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/prefs/persistent_pref_store.h"
 #include "base/prefs/value_map_pref_store.h"
+#include "base/process/process_info.h"
 #include "base/strings/string_util.h"
 #include "base/time/default_clock.h"
 #include "base/values.h"
 #include "net/base/sdch_manager.h"
 #include "net/base/sdch_net_log_params.h"
 
 namespace net {
 
 namespace {
 
@@ skipping 280 matching lines @@
   CHECK(manager_.get());
 #endif
 
   for (DictionaryPreferenceIterator it(pref_store_); !it.IsAtEnd();
        it.Advance()) {
     int new_uses = it.use_count() - use_counts_at_load_[it.server_hash()];
     DictionaryFate fate = IsPersistingDictionaries() ?
                           DICTIONARY_FATE_UNLOAD_FOR_DESTRUCTION :
                           DICTIONARY_FATE_EVICT_FOR_DESTRUCTION;
     RecordDictionaryEvictionOrUnload(new_uses, fate);
+    RecordDictionaryLifetime(it.server_hash(), it.size());
   }
   manager_->RemoveObserver(this);
 
   // This object only observes the external store during loading,
   // i.e. before it's made the default preferences store.
   if (external_pref_store_)
     external_pref_store_->RemoveObserver(this);
 
 #if defined(OS_CHROMEOS)
   destroyed_ = 0xdeadbeef;
@@ skipping 21 matching lines @@
 void SdchOwner::OnDictionaryFetched(base::Time last_used,
                                     int use_count,
                                     const std::string& dictionary_text,
                                     const GURL& dictionary_url,
                                     const net::BoundNetLog& net_log) {
   struct DictionaryItem {
     base::Time last_used;
     std::string server_hash;
     int use_count;
     size_t dictionary_size;
+    base::Time load_time;

[Randy Smith (Not in Mondays), 2015/04/03 16:08:18]

??

[Elly Fong-Jones, 2015/04/03 20:24:23]

Done.

 
     DictionaryItem() : use_count(0), dictionary_size(0) {}
     DictionaryItem(const base::Time& last_used,
                    const std::string& server_hash,
                    int use_count,
                    size_t dictionary_size)
         : last_used(last_used),
           server_hash(server_hash),
           use_count(use_count),
           dictionary_size(dictionary_size) {}
@@ skipping 81 matching lines @@
     bool success = pref_dictionary_map->RemoveWithoutPathExpansion(
         stale_it->server_hash, nullptr);
     DCHECK(success);
 
     avail_bytes += stale_it->dictionary_size;
 
     int new_uses = stale_it->use_count -
         use_counts_at_load_[stale_it->server_hash];
     RecordDictionaryEvictionOrUnload(new_uses,
                                      DICTIONARY_FATE_EVICT_FOR_DICT);
+    RecordDictionaryLifetime(stale_it->server_hash, stale_it->dictionary_size);
 
     ++stale_it;
   }
   DCHECK_GE(avail_bytes, dictionary_text.size());
 
   RecordDictionaryFate(
       // Distinguish between loads triggered by network responses and
       // loads triggered by persistence.
       last_used.is_null() ? DICTIONARY_FATE_ADD_RESPONSE_TRIGGERED
                           : DICTIONARY_FATE_ADD_PERSISTENCE_TRIGGERED);
@@ skipping 15 matching lines @@
   // Record the addition in the pref store.
   scoped_ptr<base::DictionaryValue> dictionary_description(
       new base::DictionaryValue());
   dictionary_description->SetString(kDictionaryUrlKey, dictionary_url.spec());
   dictionary_description->SetDouble(kDictionaryLastUsedKey,
                                     last_used.ToDoubleT());
   dictionary_description->SetInteger(kDictionaryUseCountKey, use_count);
   dictionary_description->SetInteger(kDictionarySizeKey,
                                      dictionary_text.size());
   pref_dictionary_map->Set(server_hash, dictionary_description.Pass());
+  load_times_[server_hash] = clock_->Now();
 }
 
 void SdchOwner::OnDictionaryUsed(SdchManager* manager,
                                  const std::string& server_hash) {
   base::Time now(clock_->Now());
   base::DictionaryValue* pref_dictionary_map =
       GetPersistentStoreDictionaryMap(pref_store_);
   ScopedPrefNotifier scoped_pref_notifier(pref_store_);
 
   base::Value* value = nullptr;
@@ skipping 213 matching lines @@
 }
 
 void SdchOwner::OnMemoryPressure(
     base::MemoryPressureListener::MemoryPressureLevel level) {
   DCHECK_NE(base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE, level);
 
   for (DictionaryPreferenceIterator it(pref_store_); !it.IsAtEnd();
        it.Advance()) {
     int new_uses = it.use_count() - use_counts_at_load_[it.server_hash()];
     RecordDictionaryEvictionOrUnload(new_uses,
                                      DICTIONARY_FATE_EVICT_FOR_MEMORY);

[Randy Smith (Not in Mondays), 2015/04/03 16:08:18]

Why isn't there a RecordDictionaryLifetime here?  More generally, any reason not
to combine that call with this one?  I think they'd generally both be called at
the same time.  

[Elly Fong-Jones, 2015/04/03 20:24:23]

Done.

   }
 
   // TODO(rdsmith): Make a distinction between moderate and critical
   // memory pressure.
   manager_->ClearData();
 }
 
 bool SdchOwner::SchedulePersistedDictionaryLoads(
     const base::DictionaryValue& persisted_info) {
   // Any schema error will result in dropping the persisted info.
@@ skipping 39 matching lines @@
                              base::Time::FromDoubleT(last_used), use_count));
   }
 
   return true;
 }
 
 bool SdchOwner::IsPersistingDictionaries() const {
   return in_memory_pref_store_.get() != nullptr;
 }
 
+void SdchOwner::RecordDictionaryLifetime(const std::string& server_hash,
+                                         size_t size) {
+  DCHECK(load_times_.count(server_hash) == 1);
+  base::Time now = clock_->Now();
+  base::TimeDelta dict_lifetime = now - load_times_[server_hash];
+  base::TimeDelta process_lifetime = now -
+      base::CurrentProcessInfo::CreationTime();

[Randy Smith (Not in Mondays), 2015/04/03 16:08:18]

I'm not sure this is the right value.  Specifically, imagine that we start up
chrome, do a whole lot of dictionary loading and use, clear dictionaries, then
use chrome for a long while longer.  Our "average bytes used over chrome's
lifetime" value will be way off.  Another way to put it is that this biases
things a lot by when the dictionary gets kicked out of memory in relationship to
the process shutting down.

I'm inclined to think that this means we need to record the statistic at
SdchOwner destruction.  That's still not ideal (Incognito, other profiles) but I
think it'd be mostly right.

[Elly Fong-Jones, 2015/04/03 20:24:23]

Done.

+  int64 frac = (size * dict_lifetime.InMilliseconds()) /
+      process_lifetime.InMilliseconds();
+  UMA_HISTOGRAM_COUNTS("Sdch3.TimeWeightedMemoryUse", frac);
+}
+
 }  // namespace net