Quelle  BenchmarkStorageParent.cpp   Sprache: C

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "BenchmarkStorageParent.h"
#include "KeyValueStorage.h"

namespace mozilla {

/* Moving average window size. */
const int32_t AVG_WINDOW = 20;
/* Calculate the moving average for the new value aValue for the current window
 * aWindow and the already existing average aAverage. When the method returns
 * aAverage will contain the new average and aWindow will contain the new
 * window.*/
void BenchmarkStorageParent::MovingAverage(int32_t& aAverage, int32_t& aWindow,
                                           const int32_t aValue) {
  if (aWindow < AVG_WINDOW) {
    aAverage = (aAverage * aWindow + aValue) / (aWindow + 1);
    aWindow++;
    return;
  }
  MOZ_ASSERT(aWindow == AVG_WINDOW);
  aAverage = (aAverage - aAverage / aWindow) + (aValue / aWindow);
}

/* In order to decrease the number of times the database is accessed when the
 * moving average is stored or retrieved we use the same value to store _both_
 * the window and the average. The range of the average is limited since it is
 * a percentage (0-100), and the range of the window is limited
 * (1-20). Thus the number that is stored in the database is in the form
 * (digits): WWAAA. For example, the value stored when an average(A) of 88
 * corresponds to a window(W) 7 is 7088. The average of 100 that corresponds to
 * a window of 20 is 20100. The following methods are helpers to extract or
 * construct the stored value according to the above. */

/* Stored value will be in the form WWAAA(19098). We need to extract the window
 * (19) and the average score (98). The aValue will
 * be parsed, the aWindow will contain the window (of the moving average) and
 * the return value will contain the average itself. */
int32_t BenchmarkStorageParent::ParseStoredValue(int32_t aValue,
                                                 int32_t& aWindow) {
  MOZ_ASSERT(aValue > 999);
  MOZ_ASSERT(aValue < 100000);

  int32_t score = aValue % 1000;
  aWindow = (aValue / 1000) % 100;
  return score;
}

int32_t BenchmarkStorageParent::PrepareStoredValue(int32_t aScore,
                                                   int32_t aWindow) {
  MOZ_ASSERT(aScore >= 0);
  MOZ_ASSERT(aScore <= 100);
  MOZ_ASSERT(aWindow > 0);
  MOZ_ASSERT(aWindow < 21);

  return aWindow * 1000 + aScore;
}

BenchmarkStorageParent::BenchmarkStorageParent()
    : mStorage(new KeyValueStorage) {}

IPCResult BenchmarkStorageParent::RecvPut(const nsCString& aDbName,
                                          const nsCString& aKey,
                                          const int32_t& aValue) {
  // In order to calculate and store the new moving average, we need to get the
  // stored value and window first, to calculate the new score and window, and
  // then to store the new aggregated value.
  mStorage->Get(aDbName, aKey)
      ->Then(
          GetCurrentSerialEventTarget(), __func__,
          [storage = mStorage, aDbName, aKey, aValue](int32_t aResult) {
            int32_t window = 0;
            int32_t average = 0;
            if (aResult >= 0) {
              // The key found.
              average = ParseStoredValue(aResult, window);
            }
            MovingAverage(average, window, aValue);
            int32_t newValue = PrepareStoredValue(average, window);
            // Avoid storing if the values are the same. This is an optimization
            // to minimize the disk usage.
            if (aResult != newValue) {
              storage->Put(aDbName, aKey, newValue);
            }
          },
          [](nsresult rv) { /*do nothing*/ });

  return IPC_OK();
}

IPCResult BenchmarkStorageParent::RecvGet(const nsCString& aDbName,
                                          const nsCString& aKey,
                                          GetResolver&& aResolve) {
  mStorage->Get(aDbName, aKey)
      ->Then(
          GetCurrentSerialEventTarget(), __func__,
          [aResolve](int32_t aResult) {
            int32_t window = 0;  // not used
            aResolve(aResult < 0 ? -1 : ParseStoredValue(aResult, window));
          },
          [aResolve](nsresult rv) { aResolve(-1); });

  return IPC_OK();
}

IPCResult BenchmarkStorageParent::RecvCheckVersion(const nsCString& aDbName,
                                                   int32_t aVersion) {
  mStorage->Get(aDbName, "Version"_ns)
      ->Then(
          GetCurrentSerialEventTarget(), __func__,
          [storage = mStorage, aDbName, aVersion](int32_t aResult) {
            if (aVersion != aResult) {
              storage->Clear(aDbName)->Then(
                  GetCurrentSerialEventTarget(), __func__,
                  [storage, aDbName, aVersion](bool) {
                    storage->Put(aDbName, "Version"_ns, aVersion);
                  },
                  [](nsresult rv) { /*do nothing*/ });
            }
          },
          [](nsresult rv) { /*do nothing*/ });

  return IPC_OK();
}

};  // namespace mozilla