Implement SkPicture::bytesUsed() for SkRecord backend

src/core/SkRecord.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkRecord_DEFINED
 #define SkRecord_DEFINED
 
@@ skipping 12 matching lines @@
 // SkRecord often looks like it's compatible with any type T, but really it's compatible with any
 // type T which has a static const SkRecords::Type kType.  That is to say, SkRecord is compatible
 // only with SkRecords::* structs defined in SkRecords.h.  Your compiler will helpfully yell if you
 // get this wrong.
 
 class SkRecord : SkNoncopyable {
     enum {
         kFirstReserveCount = 64 / sizeof(void*),
     };
 public:
-    SkRecord() : fCount(0), fReserved(0) {}
+    SkRecord() : fCount(0), fReserved(0), fBytesAllocated(0) {}
 
     ~SkRecord() {
         Destroyer destroyer;
         for (unsigned i = 0; i < this->count(); i++) {
             this->mutate<void>(i, destroyer);
         }
     }
 
     // Returns the number of canvas commands in this SkRecord.
     unsigned count() const { return fCount; }
@@ skipping 17 matching lines @@
         SkASSERT(i < this->count());
         return fRecords[i].mutate<R>(fTypes[i], f);
     }
     // TODO: It'd be nice to infer R from F for visit and mutate if we ever get std::result_of.
 
     // Allocate contiguous space for count Ts, to be freed when the SkRecord is destroyed.
     // Here T can be any class, not just those from SkRecords.  Throws on failure.
     template <typename T>
     T* alloc(size_t count = 1) {
         // Bump up to the next pointer width if needed, so all allocations start pointer-aligned.
+        fBytesAllocated += sizeof(T) * count;
         return (T*)fAlloc.alloc(sizeof(T) * count, SK_MALLOC_THROW);
     }
 
     // Add a new command of type T to the end of this SkRecord.
     // You are expected to placement new an object of type T onto this pointer.
     template <typename T>
     T* append() {
         if (fCount == fReserved) {
             fReserved = SkTMax<unsigned>(kFirstReserveCount, fReserved*2);
             fRecords.realloc(fReserved);
@@ skipping 25 matching lines @@
     T* replace(unsigned i, const SkRecords::Adopted<Existing>& proofOfAdoption) {
         SkASSERT(i < this->count());
 
         SkASSERT(Existing::kType == fTypes[i]);
         SkASSERT(proofOfAdoption == fRecords[i].ptr<Existing>());
 
         fTypes[i] = T::kType;
         return fRecords[i].set(this->allocCommand<T>());
     }
 
+    size_t bytesUsed() const { return fBytesAllocated +
+                                      fReserved * (sizeof(Record) + sizeof(Type8)) +
+                                      sizeof(SkRecord); }
+
 private:
     // Implementation notes!
     //
     // Logically an SkRecord is structured as an array of pointers into a big chunk of memory where
     // records representing each canvas draw call are stored:
     //
     // fRecords:  [*][*][*]...
     //             |  |  |
     //             |  |  |
     //             |  |  +---------------------------------------+
@@ skipping 98 matching lines @@
     //
     // fRecords and fTypes need to be data structures that can append fixed length data, and need to
     // support efficient random access and forward iteration.  (They don't need to be contiguous.)
 
     SkVarAlloc fAlloc;
     SkAutoTMalloc<Record> fRecords;
     SkAutoTMalloc<Type8> fTypes;
     // fCount and fReserved measure both fRecords and fTypes, which always grow in lock step.
     unsigned fCount;
     unsigned fReserved;
+
+    // counts bytes we've requested in fAlloc; *not* bytes in fRecords or fTypes
+    unsigned fBytesAllocated;

[mtklein, 2014/11/17 23:15:33]

Now that I'm thinking about it, it seems counterproductive to add a member here
just to track how large it is.  More than that, this fBytesAllocated will count
how many bytes we asked for, not how many we've allocated to serve that request.
 Ideally those scale well with each other, but the whole point of this is to
assert that, right?

How often do you guys figure you'll be calling ApproximateBytesUsed, and do you
care if it doesn't work on all platforms?  What about Debug vs. Release, etc?

SkVarAlloc could implement a byte-precise bytesAllocated() without any extra
memory usage at the cost of non-constant run time.  Mapping malloc_size /
malloc_usable_size / _msize down the chain of fPrev pointers should work, though
to date I haven't really liked to depend on non-standard methods like those
outside of debugging code.

[chrishtr, 2014/11/17 23:22:13]

It will only be when we want to collect debug info. But it needs to work in
production as well as debug environments, so we can integrate with
about:tracing.
non-constant runtime is probably ok so long as it isn't too slow. How slow are
we talking about?
Regarding debugging code: it'll only run when the page is under explicit debug
inspection (via the user turning on about:tracing, or us running
rasterize_and_record. So potentially unsafe or slow behavior is more acceptable.

 };
 
 #endif//SkRecord_DEFINED