92ce594685
Eventually ops can use this to hold their ops and create GrPipelines at flush time. For now it is used by GrPipelineBuilder. Change-Id: I0db3892032f2d07238e4c847a790678b3aab456f Reviewed-on: https://skia-review.googlesource.com/7132 Reviewed-by: Robert Phillips <robertphillips@google.com> Commit-Queue: Brian Salomon <bsalomon@google.com>
126 lines
4.4 KiB
C++
126 lines
4.4 KiB
C++
/*
|
|
* 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 GrProgramElement_DEFINED
|
|
#define GrProgramElement_DEFINED
|
|
|
|
#include "../private/SkTArray.h"
|
|
#include "SkRefCnt.h"
|
|
|
|
class GrGpuResourceRef;
|
|
|
|
/**
|
|
* Note: We are converting GrProcessor from ref counting to a single owner model using move
|
|
* semantics. This class will be removed.
|
|
*
|
|
* Base class for GrProcessor. This exists to manage transitioning a GrProcessor from being owned by
|
|
* a client to being scheduled for execution. While a GrProcessor is ref'ed by drawing code its
|
|
* GrGpu resources must also be ref'ed to prevent incorrectly recycling them through the cache.
|
|
* However, once the GrProcessor is baked into a GrPipeline and the drawing code has stopped ref'ing
|
|
* it, it's internal resources can be recycled in some cases.
|
|
*
|
|
* We track this using two types of refs on GrProgramElement. A regular ref is owned by any client
|
|
* that may continue to issue draws that use the GrProgramElement. The GrPipeline owns "pending
|
|
* executions" instead of refs. A pending execution is cleared by ~GrPipeline().
|
|
*
|
|
* While a GrProgramElement is ref'ed any resources it owns are also ref'ed. However, once it gets
|
|
* into the state where it has pending executions AND no refs then it converts its ownership of
|
|
* its GrGpuResources from refs to pending IOs. The pending IOs allow the cache to track when it is
|
|
* safe to recycle a resource even though we still have buffered GrOps that read or write to the
|
|
* the resource.
|
|
*
|
|
* To make this work the subclass, GrProcessor, implements addPendingIOs and pendingIOComplete. The
|
|
* former adds pending reads/writes as appropriate when the processor is recorded in a GrOpList. The
|
|
* latter removes them after the op list executes the operation. These calls must propagate to any
|
|
* children processors. Similarly, the subclass implements a removeRefs function in order to remove
|
|
* refs from resources once the processor is only owned for pending execution.
|
|
*/
|
|
template<typename DERIVED> class GrProgramElement : public SkNoncopyable {
|
|
public:
|
|
virtual ~GrProgramElement() {
|
|
// fRefCnt can be one when an effect is created statically using GR_CREATE_STATIC_EFFECT
|
|
SkASSERT((0 == fRefCnt || 1 == fRefCnt) && 0 == fPendingExecutions);
|
|
// Set to invalid values.
|
|
SkDEBUGCODE(fRefCnt = fPendingExecutions = -10;)
|
|
}
|
|
|
|
void ref() const {
|
|
this->validate();
|
|
// Once the ref cnt reaches zero it should never be ref'ed again.
|
|
SkASSERT(fRefCnt > 0);
|
|
++fRefCnt;
|
|
this->validate();
|
|
}
|
|
|
|
void unref() const {
|
|
this->validate();
|
|
--fRefCnt;
|
|
if (0 == fRefCnt) {
|
|
this->notifyRefCntIsZero();
|
|
if (0 == fPendingExecutions) {
|
|
delete this;
|
|
return;
|
|
} else {
|
|
static_cast<const DERIVED*>(this)->removeRefs();
|
|
}
|
|
}
|
|
this->validate();
|
|
}
|
|
|
|
void validate() const {
|
|
#ifdef SK_DEBUG
|
|
SkASSERT(fRefCnt >= 0);
|
|
SkASSERT(fPendingExecutions >= 0);
|
|
SkASSERT(fRefCnt + fPendingExecutions > 0);
|
|
#endif
|
|
}
|
|
|
|
protected:
|
|
GrProgramElement() : fRefCnt(1), fPendingExecutions(0) {}
|
|
|
|
void addPendingExecution() const {
|
|
this->validate();
|
|
SkASSERT(fRefCnt > 0);
|
|
if (0 == fPendingExecutions) {
|
|
static_cast<const DERIVED*>(this)->addPendingIOs();
|
|
}
|
|
++fPendingExecutions;
|
|
this->validate();
|
|
}
|
|
|
|
void completedExecution() const {
|
|
this->validate();
|
|
--fPendingExecutions;
|
|
if (0 == fPendingExecutions) {
|
|
if (0 == fRefCnt) {
|
|
delete this;
|
|
return;
|
|
} else {
|
|
static_cast<const DERIVED*>(this)->pendingIOComplete();
|
|
}
|
|
}
|
|
this->validate();
|
|
}
|
|
|
|
private:
|
|
/** This will be called when the ref cnt is zero. The object may or may not have pending
|
|
executions. */
|
|
virtual void notifyRefCntIsZero() const = 0;
|
|
|
|
mutable int32_t fRefCnt;
|
|
// Count of deferred executions not yet issued to the 3D API.
|
|
mutable int32_t fPendingExecutions;
|
|
|
|
// Only this class can access addPendingExecution() and completedExecution().
|
|
template <typename T> friend class GrPendingProgramElement;
|
|
friend class GrProcessorSet;
|
|
|
|
typedef SkNoncopyable INHERITED;
|
|
};
|
|
|
|
#endif
|