1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
|
/*
* Copyright 2017 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef GrDeferredUpload_DEFINED
#define GrDeferredUpload_DEFINED
#include <functional>
#include "GrTypes.h"
#include "GrTypesPriv.h"
class GrTextureProxy;
/**
* A word about deferred uploads and tokens: Ops should usually schedule their uploads to occur at
* the beginning of a frame whenever possible. These are called ASAP uploads. Of course, this
* requires that there are no draws that have yet to be flushed that rely on the old texture
* contents. In that case the ASAP upload would happen prior to the draw and therefore the draw
* would read the new (wrong) texture data. When this read-before-write data hazard exists they
* should schedule an inline upload.
*
* Ops, in conjunction with helpers such as GrDrawOpAtlas, use upload tokens to know what the most
* recent draw was that referenced a resource (or portion of a resource). Each draw is assigned a
* token. A resource (or portion thereof) can be tagged with the most recent reading draw's token.
* The deferred uploads target provides a facility for testing whether the draw corresponding to the
* token has been flushed. If it has not been flushed then the op must perform an inline upload
* instead so that the upload occurs after the draw depending on the old contents and before the
* draw depending on the updated contents. When scheduling an inline upload the op provides the
* token of the draw that the upload must occur before.
*/
/**
* GrDeferredUploadToken is used to sequence the uploads relative to each other and to draws.
*/
class GrDeferredUploadToken {
public:
static GrDeferredUploadToken AlreadyFlushedToken() { return GrDeferredUploadToken(0); }
GrDeferredUploadToken(const GrDeferredUploadToken&) = default;
GrDeferredUploadToken& operator=(const GrDeferredUploadToken&) = default;
bool operator==(const GrDeferredUploadToken& that) const {
return fSequenceNumber == that.fSequenceNumber;
}
bool operator!=(const GrDeferredUploadToken& that) const { return !(*this == that); }
bool operator<(const GrDeferredUploadToken that) const {
return fSequenceNumber < that.fSequenceNumber;
}
bool operator<=(const GrDeferredUploadToken that) const {
return fSequenceNumber <= that.fSequenceNumber;
}
bool operator>(const GrDeferredUploadToken that) const {
return fSequenceNumber > that.fSequenceNumber;
}
bool operator>=(const GrDeferredUploadToken that) const {
return fSequenceNumber >= that.fSequenceNumber;
}
GrDeferredUploadToken& operator++() {
++fSequenceNumber;
return *this;
}
GrDeferredUploadToken operator++(int) {
auto old = fSequenceNumber;
++fSequenceNumber;
return GrDeferredUploadToken(old);
}
GrDeferredUploadToken next() const { return GrDeferredUploadToken(fSequenceNumber + 1); }
/** Is this token in the [start, end] inclusive interval? */
bool inInterval(const GrDeferredUploadToken& start, const GrDeferredUploadToken& end) {
return *this >= start && *this <= end;
}
private:
GrDeferredUploadToken() = delete;
explicit GrDeferredUploadToken(uint64_t sequenceNumber) : fSequenceNumber(sequenceNumber) {}
uint64_t fSequenceNumber;
};
/*
* The GrTokenTracker encapsulates the incrementing and distribution of tokens.
*/
class GrTokenTracker {
public:
/** Gets the token one beyond the last token that has been flushed. */
GrDeferredUploadToken nextTokenToFlush() const { return fLastFlushedToken.next(); }
/** Gets the next draw token that will be issued by this target. This can be used by an op
to record that the next draw it issues will use a resource (e.g. texture) while preparing
that draw. */
GrDeferredUploadToken nextDrawToken() const { return fLastIssuedToken.next(); }
private:
// Only these three classes get to increment the token counters
friend class SkInternalAtlasTextContext;
friend class GrOpFlushState;
friend class TestingUploadTarget;
/** Issues the next token for a draw. */
GrDeferredUploadToken issueDrawToken() { return ++fLastIssuedToken; }
/** Advances the last flushed token by one. */
GrDeferredUploadToken flushToken() { return ++fLastFlushedToken; }
GrDeferredUploadToken fLastIssuedToken = GrDeferredUploadToken::AlreadyFlushedToken();
GrDeferredUploadToken fLastFlushedToken = GrDeferredUploadToken::AlreadyFlushedToken();
};
/**
* Passed to a deferred upload when it is executed, this method allows the deferred upload to
* actually write its pixel data into a texture.
*/
using GrDeferredTextureUploadWritePixelsFn =
std::function<bool(GrTextureProxy*, int left, int top, int width, int height,
GrColorType colorType, const void* buffer, size_t rowBytes)>;
/**
* A deferred texture upload is simply a std::function that takes a
* GrDeferredTextureUploadWritePixelsFn as a parameter. It is called when it should perform its
* upload as the draw/upload sequence is executed.
*/
using GrDeferredTextureUploadFn = std::function<void(GrDeferredTextureUploadWritePixelsFn&)>;
/**
* An interface for scheduling deferred uploads. It accepts asap and deferred inline uploads.
*/
class GrDeferredUploadTarget {
public:
virtual ~GrDeferredUploadTarget() {}
virtual const GrTokenTracker* tokenTracker() = 0;
/** Returns the token of the draw that this upload will occur before. */
virtual GrDeferredUploadToken addInlineUpload(GrDeferredTextureUploadFn&&) = 0;
/** Returns the token of the draw that this upload will occur before. Since ASAP uploads
are done first during a flush, this will be the first token since the most recent
flush. */
virtual GrDeferredUploadToken addASAPUpload(GrDeferredTextureUploadFn&& upload) = 0;
};
#endif
|
