tor-browser

ProfileBufferControlledChunkManager.h (8271B)

---

/* -*- Mode: C++; tab-width: 2; 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/. */

#ifndef ProfileBufferControlledChunkManager_h
#define ProfileBufferControlledChunkManager_h

#include "mozilla/ProfileBufferChunk.h"

#include <functional>
#include <vector>

namespace mozilla {

// A "Controlled" chunk manager will provide updates about chunks that it
// creates, releases, and destroys; and it can destroy released chunks as
// requested.
class ProfileBufferControlledChunkManager {
public:
 using Length = ProfileBufferChunk::Length;

 virtual ~ProfileBufferControlledChunkManager() = default;

 // Minimum amount of chunk metadata to be transferred between processes.
 struct ChunkMetadata {
   // Timestamp when chunk was marked "done", which is used to:
   // - determine its age, so the oldest one will be destroyed first,
   // - uniquely identify this chunk in this process. (The parent process is
   //   responsible for associating this timestamp to its process id.)
   TimeStamp mDoneTimeStamp;
   // Size of this chunk's buffer.
   Length mBufferBytes;

   ChunkMetadata(TimeStamp aDoneTimeStamp, Length aBufferBytes)
       : mDoneTimeStamp(aDoneTimeStamp), mBufferBytes(aBufferBytes) {}
 };

 // Class collecting all information necessary to describe updates that
 // happened in a chunk manager.
 // An update can be folded into a previous update.
 class Update {
  public:
   // Construct a "not-an-Update" object, which should only be used after a
   // real update is folded into it.
   Update() = default;

   // Construct a "final" Update, which marks the end of all updates from a
   // chunk manager.
   explicit Update(decltype(nullptr)) : mUnreleasedBytes(FINAL) {}

   // Construct an Update from the given data and released chunks.
   // The chunk pointers may be null, and it doesn't matter if
   // `aNewlyReleasedChunks` is already linked to `aExistingReleasedChunks` or
   // not.
   Update(size_t aUnreleasedBytes, size_t aReleasedBytes,
          const ProfileBufferChunk* aExistingReleasedChunks,
          const ProfileBufferChunk* aNewlyReleasedChunks)
       : mUnreleasedBytes(aUnreleasedBytes),
         mReleasedBytes(aReleasedBytes),
         mOldestDoneTimeStamp(
             aExistingReleasedChunks
                 ? aExistingReleasedChunks->ChunkHeader().mDoneTimeStamp
                 : TimeStamp{}) {
     MOZ_RELEASE_ASSERT(
         !IsNotUpdate(),
         "Empty update should only be constructed with default constructor");
     MOZ_RELEASE_ASSERT(
         !IsFinal(),
         "Final update should only be constructed with nullptr constructor");
     for (const ProfileBufferChunk* chunk = aNewlyReleasedChunks; chunk;
          chunk = chunk->GetNext()) {
       mNewlyReleasedChunks.emplace_back(ChunkMetadata{
           chunk->ChunkHeader().mDoneTimeStamp, chunk->BufferBytes()});
     }
   }

   // Construct an Update from raw data.
   // This may be used to re-construct an Update that was previously
   // serialized.
   Update(size_t aUnreleasedBytes, size_t aReleasedBytes,
          TimeStamp aOldestDoneTimeStamp,
          std::vector<ChunkMetadata>&& aNewlyReleasedChunks)
       : mUnreleasedBytes(aUnreleasedBytes),
         mReleasedBytes(aReleasedBytes),
         mOldestDoneTimeStamp(aOldestDoneTimeStamp),
         mNewlyReleasedChunks(std::move(aNewlyReleasedChunks)) {}

   // Clear the Update completely and return it to a "not-an-Update" state.
   void Clear() {
     mUnreleasedBytes = NO_UPDATE;
     mReleasedBytes = 0;
     mOldestDoneTimeStamp = TimeStamp{};
     mNewlyReleasedChunks.clear();
   }

   bool IsNotUpdate() const { return mUnreleasedBytes == NO_UPDATE; }

   bool IsFinal() const { return mUnreleasedBytes == FINAL; }

   size_t UnreleasedBytes() const {
     MOZ_RELEASE_ASSERT(!IsNotUpdate(),
                        "Cannot access UnreleasedBytes from empty update");
     MOZ_RELEASE_ASSERT(!IsFinal(),
                        "Cannot access UnreleasedBytes from final update");
     return mUnreleasedBytes;
   }

   size_t ReleasedBytes() const {
     MOZ_RELEASE_ASSERT(!IsNotUpdate(),
                        "Cannot access ReleasedBytes from empty update");
     MOZ_RELEASE_ASSERT(!IsFinal(),
                        "Cannot access ReleasedBytes from final update");
     return mReleasedBytes;
   }

   TimeStamp OldestDoneTimeStamp() const {
     MOZ_RELEASE_ASSERT(!IsNotUpdate(),
                        "Cannot access OldestDoneTimeStamp from empty update");
     MOZ_RELEASE_ASSERT(!IsFinal(),
                        "Cannot access OldestDoneTimeStamp from final update");
     return mOldestDoneTimeStamp;
   }

   const std::vector<ChunkMetadata>& NewlyReleasedChunksRef() const {
     MOZ_RELEASE_ASSERT(
         !IsNotUpdate(),
         "Cannot access NewlyReleasedChunksRef from empty update");
     MOZ_RELEASE_ASSERT(
         !IsFinal(), "Cannot access NewlyReleasedChunksRef from final update");
     return mNewlyReleasedChunks;
   }

   // Fold a later update into this one.
   void Fold(Update&& aNewUpdate) {
     MOZ_ASSERT(
         !IsFinal() || aNewUpdate.IsFinal(),
         "There shouldn't be another non-final update after the final update");

     if (IsNotUpdate() || aNewUpdate.IsFinal()) {
       // We were empty, or the new update is the final update, we just switch
       // to that new update.
       *this = std::move(aNewUpdate);
       return;
     }

     mUnreleasedBytes = aNewUpdate.mUnreleasedBytes;
     mReleasedBytes = aNewUpdate.mReleasedBytes;
     if (!aNewUpdate.mOldestDoneTimeStamp.IsNull()) {
       MOZ_ASSERT(mOldestDoneTimeStamp.IsNull() ||
                  mOldestDoneTimeStamp <= aNewUpdate.mOldestDoneTimeStamp);
       mOldestDoneTimeStamp = aNewUpdate.mOldestDoneTimeStamp;
       auto it = mNewlyReleasedChunks.begin();
       while (it != mNewlyReleasedChunks.end() &&
              it->mDoneTimeStamp < mOldestDoneTimeStamp) {
         it = mNewlyReleasedChunks.erase(it);
       }
     }
     if (!aNewUpdate.mNewlyReleasedChunks.empty()) {
       mNewlyReleasedChunks.reserve(mNewlyReleasedChunks.size() +
                                    aNewUpdate.mNewlyReleasedChunks.size());
       mNewlyReleasedChunks.insert(mNewlyReleasedChunks.end(),
                                   aNewUpdate.mNewlyReleasedChunks.begin(),
                                   aNewUpdate.mNewlyReleasedChunks.end());
     }
   }

  private:
   static const size_t NO_UPDATE = size_t(-1);
   static const size_t FINAL = size_t(-2);

   size_t mUnreleasedBytes = NO_UPDATE;
   size_t mReleasedBytes = 0;
   TimeStamp mOldestDoneTimeStamp;
   std::vector<ChunkMetadata> mNewlyReleasedChunks;
 };

 using UpdateCallback = std::function<void(Update&&)>;

 // This *may* be set (or reset) by an object that needs to know about all
 // chunk updates that happen in this manager. The main use will be to
 // coordinate the global memory usage of Firefox.
 // If a non-empty callback is given, it will be immediately invoked with the
 // current state.
 // When the callback is about to be destroyed (by overwriting it here, or in
 // the class destructor), it will be invoked one last time with an empty
 // update.
 // Note that the callback (even the first current-state callback) will be
 // invoked from inside a locked scope, so it should *not* call other functions
 // of the chunk manager. A side benefit of this locking is that it guarantees
 // that no two invocations can overlap.
 virtual void SetUpdateCallback(UpdateCallback&& aUpdateCallback) = 0;

 // This is a request to destroy all chunks before the given timestamp.
 // This timestamp should be one that was given in a previous UpdateCallback
 // call. Obviously, only released chunks can be destroyed.
 virtual void DestroyChunksAtOrBefore(TimeStamp aDoneTimeStamp) = 0;
};

}  // namespace mozilla

#endif  // ProfileBufferControlledChunkManager_h