Partially restore small-T optimization for very small (empty) T.

src/record/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 59 matching lines @@
     // You are expected to placement new an object of type T onto this pointer.
     template <typename T>
     T* append() {
         if (fCount == fReserved) {
             fReserved = SkTMax(kFirstReserveCount, fReserved*2);
             fRecords.realloc(fReserved);
             fTypes.realloc(fReserved);
         }
 
         fTypes[fCount] = T::kType;
-        return fRecords[fCount++].set(this->alloc<T>());
+        return fRecords[fCount++].set(this->allocCommand<T>());
     }
 
     // Replace the i-th command with a new command of type T.
     // You are expected to placement new an object of type T onto this pointer.
     // References to the original command are invalidated.
     template <typename T>
     T* replace(unsigned i) {
         SkASSERT(i < this->count());
 
         Destroyer destroyer;
         this->mutate(i, destroyer);
 
         fTypes[i] = T::kType;
-        return fRecords[i].set(this->alloc<T>());
+        return fRecords[i].set(this->allocCommand<T>());
     }
 
     // Replace the i-th command with a new command of type T.
     // You are expected to placement new an object of type T onto this pointer.
     // You must show proof that you've already adopted the existing command.
     template <typename T, typename Existing>
     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->alloc<T>());
+        return fRecords[i].set(this->allocCommand<T>());
     }
 
 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 36 matching lines @@
     struct Type8 {
     public:
         // This intentionally converts implicitly back and forth.
         Type8(SkRecords::Type type) : fType(type) { SkASSERT(*this == type); }
         operator SkRecords::Type () { return (SkRecords::Type)fType; }
 
     private:
         uint8_t fType;
     };
 
+    template <typename T>
+    T* allocCommand() {
+        struct AddChar : public T { char unused; };
+        if (sizeof(AddChar) == sizeof(char)) {
+            // T is an empty struct.
+            return NULL;
+        }
+        return this->alloc<T>();
+    }

[bungeman-skia, 2014/05/07 14:35:24]

I understand what you're doing here, but eck. Can we just make an IsEmpty trait?

SkTLogic.h:
class SkTIsEmpty<T> {
    struct test : public T { char unused; };
public:
    static const bool value = sizeof(test) == sizeof(char);
};

Here:
template <typename T> SK_WHEN<SkTIsEmpty<T>, T*> allocCommand() {
    return NULL;
}
template <typename T> SK_WHEN<!SkTIsEmpty<T>, T*> allocCommand() {
    return this->alloc<T>();
}

You're already writing/using a template DSL here, this seems more in keeping
with the rest of the implementation.

Come to think of it, we should probably put out traits in a namespace or
something. And move SkTIsConst there also.

[mtklein, 2014/05/07 15:27:43]

Done.  Leaving rearranging / renaming the traits for later.

+
     // An untyped pointer to some bytes in fAlloc.  This is the interface for polymorphic dispatch:
     // visit() and mutate() work with the parallel fTypes array to do the work of a vtable.
     struct Record {
     public:
         // Point this record to its data in fAlloc.  Returns ptr for convenience.
         template <typename T>
         T* set(T* ptr) {
             fPtr = ptr;
             return ptr;
         }
@@ skipping 33 matching lines @@
     SkChunkAlloc 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;
     const unsigned kFirstReserveCount;
 };
 
 #endif//SkRecord_DEFINED