[Courgette Experiment] Track and print TempMapping total and peak allocation to measure Courgette d…

courgette/memory_allocator.h

 // 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.
 
 #ifndef COURGETTE_MEMORY_ALLOCATOR_H_
 #define COURGETTE_MEMORY_ALLOCATOR_H_
 
 #include <stddef.h>
 #include <stdint.h>
 #include <stdlib.h>
@@ skipping 99 matching lines @@
   HANDLE mapping_;
   void* view_;
 };
 
 // Manages a temporary file and a memory mapping of the temporary file.
 // The memory that this class manages holds a pointer back to the TempMapping
 // object itself, so that given a memory pointer allocated by this class,
 // you can get a pointer to the TempMapping instance that owns that memory.
 class TempMapping {
  public:
+  static long long alloc_cur;
+  static long long alloc_sum;
+  static long long alloc_max;
+
   TempMapping();
   ~TempMapping();
 
   // Creates a temporary file of size |size| and maps it into the current
   // process's address space.
   bool Initialize(size_t size);
 
   // Returns a writable pointer to the reserved memory.
   void* memory() const;
 
   // Returns true if the mapping is valid and memory is available.
   bool valid() const;
 
   // Returns a pointer to the TempMapping instance that allocated the |mem|
   // block of memory.  It's the callers responsibility to make sure that
   // the memory block was allocated by the TempMapping class.
   static TempMapping* GetMappingFromPtr(void* mem);
 
  protected:
   base::File file_;
   FileMapping mapping_;
+
+  size_t size_ = 0;
 };
 
 // A memory allocator class that allocates memory either from the heap or via a
 // temporary file.  The interface is STL inspired but the class does not throw
 // STL exceptions on allocation failure.  Instead it returns NULL.
 // A file allocation will be made if either the requested memory size exceeds
 // |kMaxHeapAllocationSize| or if a heap allocation fails.
 // Allocating the memory as a mapping of a temporary file solves the problem
 // that there might not be enough physical memory and pagefile to support the
 // allocation.  This can happen because these resources are too small, or
@@ skipping 350 matching lines @@
  protected:
   T* buffer_;
   size_t size_;  // how much of the buffer we're using.
   size_t alloc_size_;  // how much space we have allocated.
   Allocator alloc_;
 };
 
 }  // namespace courgette
 
 #endif  // COURGETTE_MEMORY_ALLOCATOR_H_