Added a Unique ID for a Field Trial containing it's hashed name and the selected group ID.

base/metrics/field_trial.cc

 // Copyright (c) 2011 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 "base/metrics/field_trial.h"
 
 #include "base/build_time.h"
 #include "base/logging.h"
 #include "base/rand_util.h"
 #include "base/sha1.h"
 #include "base/stringprintf.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 
 namespace base {
 
-// static
+static const char kHistogramFieldTrialSeparator('_');
+
+// statics
 const int FieldTrial::kNotFinalized = -1;
-
-// static
 const int FieldTrial::kDefaultGroupNumber = 0;
-
-// static
+const uint32 FieldTrial::kReservedHashValue = 0;
+const uint32 FieldTrial::kFallbackHashValue = 1;
 bool FieldTrial::enable_benchmarking_ = false;
 
-// static
 const char FieldTrialList::kPersistentStringSeparator('/');
-
-static const char kHistogramFieldTrialSeparator('_');
-
-// static
 int FieldTrialList::kExpirationYearInFuture = 0;
 
-
 //------------------------------------------------------------------------------
 // FieldTrial methods and members.
 
 FieldTrial::FieldTrial(const std::string& name,
                        const Probability total_probability,
                        const std::string& default_group_name,
                        const int year,
                        const int month,
                        const int day_of_month)
   : name_(name),
+    name_hash_(HashName(name)),
     divisor_(total_probability),
     default_group_name_(default_group_name),
     random_(static_cast<Probability>(divisor_ * RandDouble())),
     accumulated_group_probability_(0),
     next_group_number_(kDefaultGroupNumber + 1),
     group_(kNotFinalized),
+    group_name_hash_(kReservedHashValue),
     enable_field_trial_(true) {
   DCHECK_GT(total_probability, 0);
   DCHECK(!name_.empty());
   DCHECK(!default_group_name_.empty());
   FieldTrialList::Register(this);
 
   DCHECK_GT(year, 1970);
   DCHECK_GT(month, 0);
   DCHECK_LT(month, 13);
   DCHECK_GT(day_of_month, 0);
@@ skipping 28 matching lines @@
 }
 
 void FieldTrial::Disable() {
   enable_field_trial_ = false;
 
   // In case we are disabled after initialization, we need to switch
   // the trial to the default group.
   if (group_ != kNotFinalized) {
     group_ = kDefaultGroupNumber;
     group_name_ = default_group_name_;
+    group_name_hash_ = HashName(group_name_);
   }
 }
 
 int FieldTrial::AppendGroup(const std::string& name,
                             Probability group_probability) {
   DCHECK_LE(group_probability, divisor_);
   DCHECK_GE(group_probability, 0);
 
   if (enable_benchmarking_ || !enable_field_trial_)
     group_probability = 0;
 
   accumulated_group_probability_ += group_probability;
 
   DCHECK_LE(accumulated_group_probability_, divisor_);
   if (group_ == kNotFinalized && accumulated_group_probability_ > random_) {
     // This is the group that crossed the random line, so we do the assignment.
     group_ = next_group_number_;
     if (name.empty())
       StringAppendF(&group_name_, "%d", group_);
     else
       group_name_ = name;
+    group_name_hash_ = HashName(group_name_);
     FieldTrialList::NotifyFieldTrialGroupSelection(name_, group_name_);
   }
   return next_group_number_++;
 }
 
 int FieldTrial::group() {
   if (group_ == kNotFinalized) {
     accumulated_group_probability_ = divisor_;
     group_ = kDefaultGroupNumber;
     group_name_ = default_group_name_;
+    group_name_hash_ = HashName(group_name_);
     FieldTrialList::NotifyFieldTrialGroupSelection(name_, group_name_);
   }
   return group_;
 }
 
 std::string FieldTrial::group_name() {
   group();  // call group() to make sure group assignment was done.
   DCHECK(!group_name_.empty());
   return group_name_;
 }
 
+bool FieldTrial::GetNameGroupId(NameGroupId* name_group_id) {
+  if (group_name_hash_ == kReservedHashValue)
+    return false;
+  name_group_id->name = name_hash_;
+  name_group_id->group = group_name_hash_;
+  return true;
+}
+
 // static
 std::string FieldTrial::MakeName(const std::string& name_prefix,
                                  const std::string& trial_name) {
   std::string big_string(name_prefix);
   big_string.append(1, kHistogramFieldTrialSeparator);
   return big_string.append(FieldTrialList::FindFullName(trial_name));
 }
 
 // static
 void FieldTrial::EnableBenchmarking() {
@@ skipping 15 matching lines @@
   SHA1HashBytes(reinterpret_cast<const unsigned char*>(input.c_str()),
                 input.size(),
                 sha1_hash);
 
   COMPILE_ASSERT(sizeof(uint64) < sizeof(sha1_hash), need_more_data);
   uint64* bits = reinterpret_cast<uint64*>(&sha1_hash[0]);
 
   return BitsToOpenEndedUnitInterval(*bits);
 }
 
+// static
+uint32 FieldTrial::HashName(const std::string& name) {
+  // SHA-1 is designed to produce a uniformly random spread in its output space,
+  // even for nearly-identical inputs.
+  unsigned char sha1_hash[kSHA1Length];
+  SHA1HashBytes(reinterpret_cast<const unsigned char*>(name.c_str()),
+                name.size(),
+                sha1_hash);
+
+  COMPILE_ASSERT(sizeof(uint32) < sizeof(sha1_hash), need_more_data);
+  // We need to make sure we avoid kReservedHashValue.
+  // So we try different offsets within sha1_hash.
+  size_t offset = 0;
+  static const size_t kStep = sizeof(uint32) / sizeof(char);

[Alexei Svitkine (slow), 2012/01/25 18:59:39]

You can make this logic a little simpler - if you initialize |bits| to the first
uint32, then you can just increment it via |bits++| while checking bits <
&sha1_hash[kSHA1Length].

[jar (doing other things), 2012/01/25 19:52:14]

+1 for some variant of Alexei's suggestion.

nit: If you did stay with the approach on line 196, the style guide is clear
that much better would be:

kStep = sizeof(bits) / sizeof(sha1_hash[0]);

Always try to take the sizeof variables, rather than their types.

On 2012/01/25 18:59:39, Alexei Svitkine wrote:

[ian fette, 2012/01/25 20:03:42]

A related note is that you're currently stepping through 32-bits at a time to
avoid a reserved value - you could just as easily step through 8 bits at a time,
thus giving you many more possible values from the 160-bit hash before you
exhaust it. Alexei's proposal would also step 4 bytes at a time. Although it
would lead to an unaligned memory access, given that you're doing a SHA-1 hash I
really don't think that would be significant.

E.g. I don't understand why you need kStep to be 4 instead of 1. I personally
think this would be much more readable as:


uint32* bits = reinterpret_cast<uint32*>(sha1_hash);
size_t offset = 0;
while (*bits == kReservedHashValue && ++offset <= (kSha1Length - sizeof(uint32))
{
  bits = reinterpret_cast<uint32*>(sha1_hash + offset);
}
DCHECK(*bits == kReservedHashValue) << "PICK A BETTER NAME FOO!";

On 2012/01/25 18:59:39, Alexei Svitkine wrote:

[MAD, 2012/01/26 03:14:43]

Went back to previous version...

+  uint32* bits;
+  do {
+    bits = reinterpret_cast<uint32*>(&sha1_hash[offset]);

[jar (doing other things), 2012/01/25 19:52:14]

I suspect this code is not safe for big-endian vs little-endian machines.  The
problem is only significant because we'll send this hash to an external server,
that has expectations about the relationship between the strings and its hash. 
I asked around, and was told that we don't support big-endian.

To be sure this works, please include a test case that has the expected hash
values for some known string.  This way, if someone tried to port it, the test
would blow up, and identify the issue.

[MAD, 2012/01/26 03:14:43]

Added tests... Good idea...

+    offset += kStep;
+  } while (*bits == kReservedHashValue && offset <= kSHA1Length - kStep);
+
+  // Or fallback to a constant hard coded value.
+  if (*bits == kReservedHashValue)
+    *bits = kFallbackHashValue;

[Alexei Svitkine (slow), 2012/01/25 18:59:39]

While this case seems extremely unlikely, its also pretty scary. Would it be
possible to have a test that will check any FieldTrials in the code that none of
their names and possible groups hit this?

Then, this code could have a CHECK() for this.

[jar (doing other things), 2012/01/25 19:52:14]

At best, a DCHECK is called for IMO... but the point of using this secondary
hash was to avoid the need for the DCHECK/CHECK

You should have a unit test that asserted that we don't hit this fallback in our
tests (as that is probably a hint that the logic is broken).

On 2012/01/25 18:59:39, Alexei Svitkine wrote:

+  return *bits;
+}
+
 //------------------------------------------------------------------------------
 // FieldTrialList methods and members.
 
 // static
 FieldTrialList* FieldTrialList::global_ = NULL;
 
 // static
 bool FieldTrialList::used_without_global_ = false;
 
 FieldTrialList::FieldTrialList(const std::string& client_id)
@@ skipping 58 matching lines @@
   return "";
 }
 
 // static
 bool FieldTrialList::TrialExists(const std::string& name) {
   return Find(name) != NULL;
 }
 
 // static
 void FieldTrialList::StatesToString(std::string* output) {
+  DCHECK(output->empty());
   if (!global_)
     return;
-  DCHECK(output->empty());
   AutoLock auto_lock(global_->lock_);
 
   for (RegistrationList::iterator it = global_->registered_.begin();
        it != global_->registered_.end(); ++it) {
     const std::string name = it->first;
     std::string group_name = it->second->group_name_internal();
     if (group_name.empty())
       continue;  // Should not include uninitialized trials.
     DCHECK_EQ(name.find(kPersistentStringSeparator), std::string::npos);
     DCHECK_EQ(group_name.find(kPersistentStringSeparator), std::string::npos);
     output->append(name);
     output->append(1, kPersistentStringSeparator);
     output->append(group_name);
     output->append(1, kPersistentStringSeparator);
   }
 }
 
 // static
+void FieldTrialList::GetFieldTrialNameGroupIds(
+    std::vector<FieldTrial::NameGroupId>* name_group_ids) {
+  DCHECK(name_group_ids->empty());
+  if (!global_)
+    return;
+  AutoLock auto_lock(global_->lock_);
+
+  for (RegistrationList::iterator it = global_->registered_.begin();
+       it != global_->registered_.end(); ++it) {
+    FieldTrial::NameGroupId name_group_id;
+    if (it->second->GetNameGroupId(&name_group_id))
+      name_group_ids->push_back(name_group_id);
+  }
+}
+
+// static
 bool FieldTrialList::CreateTrialsInChildProcess(
     const std::string& parent_trials) {
   DCHECK(global_);
   if (parent_trials.empty() || !global_)
     return true;
 
   size_t next_item = 0;
   while (next_item < parent_trials.length()) {
     size_t name_end = parent_trials.find(kPersistentStringSeparator, next_item);
     if (name_end == parent_trials.npos || next_item == name_end)
@@ skipping 93 matching lines @@
 }
 
 FieldTrial* FieldTrialList::PreLockedFind(const std::string& name) {
   RegistrationList::iterator it = registered_.find(name);
   if (registered_.end() == it)
     return NULL;
   return it->second;
 }
 
 }  // namespace base