Remove static effects from the effect memory pool.

include/gpu/GrEffect.h

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrEffect_DEFINED
 #define GrEffect_DEFINED
 
 #include "GrColor.h"
 #include "GrEffectUnitTest.h"
 #include "GrNoncopyable.h"
 #include "GrRefCnt.h"
 #include "GrTexture.h"
 #include "GrTextureAccess.h"
 #include "GrTypesPriv.h"
 
 class GrBackendEffectFactory;
 class GrContext;
 class GrEffect;
 class SkString;
 
 /**
  * A Wrapper class for GrEffect. Its ref-count will track owners that may use effects to enqueue
  * new draw operations separately from ownership within a deferred drawing queue. When the
  * GrEffectRef ref count reaches zero the scratch GrResources owned by the effect can be recycled
  * in service of later draws. However, the deferred draw queue may still own direct references to
  * the underlying GrEffect.
+ *

[robertphillips, 2013/04/22 22:05:13]

pools -> pool

+ * GrEffectRefs created by new are placed in a per-thread managed pool. The pools is destroyed when
+ * the thread ends. Therefore, all dynamically allocated GrEffectRefs must be unreffed before thread
+ * termination.
  */
 class GrEffectRef : public SkRefCnt {
 public:
     SK_DECLARE_INST_COUNT(GrEffectRef);
+    virtual ~GrEffectRef();
 
     GrEffect* get() { return fEffect; }
     const GrEffect* get() const { return fEffect; }
 
     const GrEffect* operator-> () { return fEffect; }
     const GrEffect* operator-> () const { return fEffect; }
 
     void* operator new(size_t size);
     void operator delete(void* target);
 
+    void* operator new(size_t size, void* placement) {
+        return ::operator new(size, placement);
+    }
+    void operator delete(void* target, void* placement) {
+        ::operator delete(target, placement);
+    }
+
 private:
     friend class GrEffect; // to construct these
 
     explicit GrEffectRef(GrEffect* effect);
 
-    virtual ~GrEffectRef();
-
     GrEffect* fEffect;
 
     typedef SkRefCnt INHERITED;
 };
 
 /** Provides custom vertex shader, fragment shader, uniform data for a particular stage of the
     Ganesh shading pipeline.
     Subclasses must have a function that produces a human-readable name:
         static const char* Name();
     GrEffect objects *must* be immutable: after being constructed, their fields may not change.
 
     GrEffect subclass objects should be created by factory functions that return GrEffectRef.
     There is no public way to wrap a GrEffect in a GrEffectRef. Thus, a factory should be a static
     member function of a GrEffect subclass.
 
-    Because almost no code should ever handle a GrEffect outside of a GrEffectRef, we privately
-    inherit from GrRefCnt to help prevent accidental direct ref'ing/unref'ing of effects.
+    Because almost no code should ever handle a GrEffect directly outside of a GrEffectRef, we
+    privately inherit from GrRefCnt to help prevent accidental direct ref'ing/unref'ing of effects.
+
+    Dynamically allocated GrEffects and their corresponding GrEffectRefs are managed by a per-thread
+    memory pool. The ref count of an effect must reach 0 before the thread terminates and the pool
+    is destroyed. To create a static effect use the macro GR_CREATE_STATIC_EFFECT declared below.
   */
 class GrEffect : private GrRefCnt {
 public:
     SK_DECLARE_INST_COUNT(GrEffect)
 
     /**
      * The types of vertex coordinates available to an effect in the vertex shader. Effects can
      * require their own vertex attribute but these coordinates are made available by the framework
      * in all programs. kCustom_CoordsType is provided to signify that an alternative set of coords
      * is used (usually an explicit vertex attribute) but its meaning is determined by the effect
@@ skipping 74 matching lines @@
     static inline SkMatrix MakeDivByTextureWHMatrix(const GrTexture* texture) {
         GrAssert(NULL != texture);
         SkMatrix mat;
         mat.setIDiv(texture->width(), texture->height());
         return mat;
     }
 
     void* operator new(size_t size);
     void operator delete(void* target);
 
+    void* operator new(size_t size, void* placement) {
+        return ::operator new(size, placement);
+    }
+    void operator delete(void* target, void* placement) {
+        ::operator delete(target, placement);
+    }
+
     /** These functions are used when recording effects into a deferred drawing queue. The inc call
         keeps the effect alive outside of GrEffectRef while allowing any resources owned by the
         effect to be returned to the cache for reuse. The dec call must balance the inc call. */
     void incDeferredRefCounts() const {
         this->ref();
         int count = fTextureAccesses.count();
         for (int t = 0; t < count; ++t) {
             fTextureAccesses[t]->getTexture()->incDeferredRefCount();
         }
     }
@@ skipping 30 matching lines @@
         } else {
             effect->fEffectRef->ref();
         }
         return effect->fEffectRef;
     }
 
     static const GrEffectRef* CreateEffectRef(const GrEffect* effect) {
         return CreateEffectRef(const_cast<GrEffect*>(effect));
     }
 
+    /** Used by GR_CREATE_STATIC_EFFECT below */
+    static GrEffectRef* CreateStaticEffectRef(void* refStorage, GrEffect* effect) {
+        GrAssert(NULL == effect->fEffectRef);
+        effect->fEffectRef = SkNEW_PLACEMENT_ARGS(refStorage, GrEffectRef, (effect));
+        return effect->fEffectRef;
+    }
+
+
     /** Helper used in subclass factory functions to unref the effect after it has been wrapped in a
         GrEffectRef. E.g.:
 
         class EffectSubclass : public GrEffect {
         public:
             GrEffectRef* Create(ParamType1 param1, ParamType2 param2, ...) {
                 AutoEffectUnref effect(SkNEW_ARGS(EffectSubclass, (param1, param2, ...)));
                 return CreateEffectRef(effect);
             }
      */
@@ skipping 56 matching lines @@
 
     typedef GrRefCnt INHERITED;
 };
 
 inline GrEffectRef::GrEffectRef(GrEffect* effect) {
     GrAssert(NULL != effect);
     effect->ref();
     fEffect = effect;
 }
 
+/**
+ * This creates an effect outside of the effect memory pool. The effect's destructor will be called
+ * at global destruction time. NAME will be the name of the created GrEffectRef.
+ */
+#define GR_CREATE_STATIC_EFFECT(NAME, EFFECT_CLASS, ARGS)                                         \
+enum {                                                                                            \
+    k_##NAME##_EffectRefOffset = GR_CT_ALIGN_UP(sizeof(EFFECT_CLASS), 8),                         \
+    k_##NAME##_StorageSize = k_##NAME##_EffectRefOffset + sizeof(GrEffectRef)                     \
+};                                                                                                \
+static SkAlignedSStorage<k_##NAME##_StorageSize> g_##NAME##_Storage;                              \
+static void* NAME##_RefLocation = (char*)g_##NAME##_Storage.get() + k_##NAME##_EffectRefOffset;   \
+static GrEffect* NAME##_Effect SkNEW_PLACEMENT_ARGS(g_##NAME##_Storage.get(), EFFECT_CLASS, ARGS);\
+static SkAutoTDestroy<GrEffect> NAME##_ad(NAME##_Effect);                                         \
+static GrEffectRef* NAME(GrEffect::CreateStaticEffectRef(NAME##_RefLocation, NAME##_Effect));     \
+static SkAutoTDestroy<GrEffectRef> NAME##_Ref_ad(NAME)
+
+
 #endif