blob: 516c10ea348366b7ff004936896abb0df77e9c6e [file] [log] [blame]
cdalton397536c2016-03-25 12:15:03 -07001/*
2 * Copyright 2016 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
Mike Kleinc0bd9f92019-04-23 12:05:21 -05008#include "include/core/SkTraceMemoryDump.h"
9#include "src/gpu/GrGpuResourcePriv.h"
10#include "src/gpu/gl/GrGLBuffer.h"
11#include "src/gpu/gl/GrGLGpu.h"
cdalton397536c2016-03-25 12:15:03 -070012
13#define GL_CALL(X) GR_GL_CALL(this->glGpu()->glInterface(), X)
14#define GL_CALL_RET(RET, X) GR_GL_CALL_RET(this->glGpu()->glInterface(), RET, X)
15
16#if GR_GL_CHECK_ALLOC_WITH_GET_ERROR
17 #define CLEAR_ERROR_BEFORE_ALLOC(iface) GrGLClearErr(iface)
18 #define GL_ALLOC_CALL(iface, call) GR_GL_CALL_NOERRCHECK(iface, call)
19 #define CHECK_ALLOC_ERROR(iface) GR_GL_GET_ERROR(iface)
20#else
21 #define CLEAR_ERROR_BEFORE_ALLOC(iface)
22 #define GL_ALLOC_CALL(iface, call) GR_GL_CALL(iface, call)
23 #define CHECK_ALLOC_ERROR(iface) GR_GL_NO_ERROR
24#endif
25
26#ifdef SK_DEBUG
27#define VALIDATE() this->validate()
28#else
29#define VALIDATE() do {} while(false)
30#endif
31
Brian Salomonae64c192019-02-05 09:41:37 -050032sk_sp<GrGLBuffer> GrGLBuffer::Make(GrGLGpu* gpu, size_t size, GrGpuBufferType intendedType,
Brian Salomon12d22642019-01-29 14:38:50 -050033 GrAccessPattern accessPattern, const void* data) {
Jim Van Verth2e5eaf02017-06-21 15:55:46 -040034 if (gpu->glCaps().transferBufferType() == GrGLCaps::kNone_TransferBufferType &&
Brian Salomonae64c192019-02-05 09:41:37 -050035 (GrGpuBufferType::kXferCpuToGpu == intendedType ||
36 GrGpuBufferType::kXferGpuToCpu == intendedType)) {
Jim Van Verth2e5eaf02017-06-21 15:55:46 -040037 return nullptr;
38 }
39
Hal Canary144caf52016-11-07 17:57:18 -050040 sk_sp<GrGLBuffer> buffer(new GrGLBuffer(gpu, size, intendedType, accessPattern, data));
csmartdalton485a1202016-07-13 10:16:32 -070041 if (0 == buffer->bufferID()) {
cdalton397536c2016-03-25 12:15:03 -070042 return nullptr;
43 }
Brian Salomon12d22642019-01-29 14:38:50 -050044 return buffer;
cdalton397536c2016-03-25 12:15:03 -070045}
46
47// GL_STREAM_DRAW triggers an optimization in Chromium's GPU process where a client's vertex buffer
48// objects are implemented as client-side-arrays on tile-deferred architectures.
49#define DYNAMIC_DRAW_PARAM GR_GL_STREAM_DRAW
50
Brian Salomonae64c192019-02-05 09:41:37 -050051inline static GrGLenum gr_to_gl_access_pattern(GrGpuBufferType bufferType,
cdaltone2e71c22016-04-07 18:13:29 -070052 GrAccessPattern accessPattern) {
Brian Salomonae64c192019-02-05 09:41:37 -050053 auto drawUsage = [](GrAccessPattern pattern) {
54 switch (pattern) {
55 case kDynamic_GrAccessPattern:
56 // TODO: Do we really want to use STREAM_DRAW here on non-Chromium?
57 return DYNAMIC_DRAW_PARAM;
58 case kStatic_GrAccessPattern:
59 return GR_GL_STATIC_DRAW;
60 case kStream_GrAccessPattern:
61 return GR_GL_STREAM_DRAW;
62 }
63 SK_ABORT("Unexpected access pattern");
cdalton397536c2016-03-25 12:15:03 -070064 };
cdaltone2e71c22016-04-07 18:13:29 -070065
Brian Salomonae64c192019-02-05 09:41:37 -050066 auto readUsage = [](GrAccessPattern pattern) {
67 switch (pattern) {
68 case kDynamic_GrAccessPattern:
69 return GR_GL_DYNAMIC_READ;
70 case kStatic_GrAccessPattern:
71 return GR_GL_STATIC_READ;
72 case kStream_GrAccessPattern:
73 return GR_GL_STREAM_READ;
74 }
75 SK_ABORT("Unexpected access pattern");
cdalton397536c2016-03-25 12:15:03 -070076 };
cdaltone2e71c22016-04-07 18:13:29 -070077
Brian Salomonae64c192019-02-05 09:41:37 -050078 auto usageType = [&drawUsage, &readUsage](GrGpuBufferType type, GrAccessPattern pattern) {
79 switch (type) {
80 case GrGpuBufferType::kVertex:
81 case GrGpuBufferType::kIndex:
82 case GrGpuBufferType::kXferCpuToGpu:
83 return drawUsage(pattern);
84 case GrGpuBufferType::kXferGpuToCpu:
85 return readUsage(pattern);
86 }
87 SK_ABORT("Unexpected gpu buffer type.");
cdaltone2e71c22016-04-07 18:13:29 -070088 };
89
Brian Salomonae64c192019-02-05 09:41:37 -050090 return usageType(bufferType, accessPattern);
cdalton397536c2016-03-25 12:15:03 -070091}
92
Brian Salomonae64c192019-02-05 09:41:37 -050093GrGLBuffer::GrGLBuffer(GrGLGpu* gpu, size_t size, GrGpuBufferType intendedType,
csmartdalton485a1202016-07-13 10:16:32 -070094 GrAccessPattern accessPattern, const void* data)
Brian Salomonae64c192019-02-05 09:41:37 -050095 : INHERITED(gpu, size, intendedType, accessPattern)
96 , fIntendedType(intendedType)
97 , fBufferID(0)
98 , fUsage(gr_to_gl_access_pattern(intendedType, accessPattern))
99 , fGLSizeInBytes(0)
100 , fHasAttachedToTexture(false) {
csmartdalton485a1202016-07-13 10:16:32 -0700101 GL_CALL(GenBuffers(1, &fBufferID));
102 if (fBufferID) {
103 GrGLenum target = gpu->bindBuffer(fIntendedType, this);
104 CLEAR_ERROR_BEFORE_ALLOC(gpu->glInterface());
105 // make sure driver can allocate memory for this buffer
106 GL_ALLOC_CALL(gpu->glInterface(), BufferData(target,
107 (GrGLsizeiptr) size,
108 data,
109 fUsage));
110 if (CHECK_ALLOC_ERROR(gpu->glInterface()) != GR_GL_NO_ERROR) {
111 GL_CALL(DeleteBuffers(1, &fBufferID));
112 fBufferID = 0;
cdalton397536c2016-03-25 12:15:03 -0700113 } else {
csmartdalton485a1202016-07-13 10:16:32 -0700114 fGLSizeInBytes = size;
cdalton397536c2016-03-25 12:15:03 -0700115 }
116 }
117 VALIDATE();
kkinnunen2e6055b2016-04-22 01:48:29 -0700118 this->registerWithCache(SkBudgeted::kYes);
Robert Phillipsa5b39fa2017-06-08 15:34:16 -0400119 if (!fBufferID) {
120 this->resourcePriv().removeScratchKey();
121 }
cdalton397536c2016-03-25 12:15:03 -0700122}
123
124inline GrGLGpu* GrGLBuffer::glGpu() const {
125 SkASSERT(!this->wasDestroyed());
126 return static_cast<GrGLGpu*>(this->getGpu());
127}
128
129inline const GrGLCaps& GrGLBuffer::glCaps() const {
130 return this->glGpu()->glCaps();
131}
132
133void GrGLBuffer::onRelease() {
Yuqian Li40aa85f2019-07-02 13:45:00 -0700134 TRACE_EVENT0("skia.gpu", TRACE_FUNC);
135
cdalton397536c2016-03-25 12:15:03 -0700136 if (!this->wasDestroyed()) {
137 VALIDATE();
138 // make sure we've not been abandoned or already released
csmartdalton485a1202016-07-13 10:16:32 -0700139 if (fBufferID) {
cdaltone2e71c22016-04-07 18:13:29 -0700140 GL_CALL(DeleteBuffers(1, &fBufferID));
cdalton397536c2016-03-25 12:15:03 -0700141 fBufferID = 0;
142 fGLSizeInBytes = 0;
143 }
144 fMapPtr = nullptr;
145 VALIDATE();
146 }
147
148 INHERITED::onRelease();
149}
150
151void GrGLBuffer::onAbandon() {
152 fBufferID = 0;
153 fGLSizeInBytes = 0;
154 fMapPtr = nullptr;
cdalton397536c2016-03-25 12:15:03 -0700155 VALIDATE();
156 INHERITED::onAbandon();
157}
158
159void GrGLBuffer::onMap() {
Robert Phillipsa5b39fa2017-06-08 15:34:16 -0400160 SkASSERT(fBufferID);
Brian Salomon68aeec02019-04-16 11:01:13 -0400161 SkASSERT(!this->wasDestroyed());
cdalton397536c2016-03-25 12:15:03 -0700162 VALIDATE();
163 SkASSERT(!this->isMapped());
164
cdaltone2e71c22016-04-07 18:13:29 -0700165 // TODO: Make this a function parameter.
Brian Salomonae64c192019-02-05 09:41:37 -0500166 bool readOnly = (GrGpuBufferType::kXferGpuToCpu == fIntendedType);
cdalton397536c2016-03-25 12:15:03 -0700167
168 // Handling dirty context is done in the bindBuffer call
169 switch (this->glCaps().mapBufferType()) {
170 case GrGLCaps::kNone_MapBufferType:
Brian Salomon68aeec02019-04-16 11:01:13 -0400171 return;
cdaltone2e71c22016-04-07 18:13:29 -0700172 case GrGLCaps::kMapBuffer_MapBufferType: {
173 GrGLenum target = this->glGpu()->bindBuffer(fIntendedType, this);
Brian Salomon68aeec02019-04-16 11:01:13 -0400174 if (!readOnly) {
175 // Let driver know it can discard the old data
176 if (this->glCaps().useBufferDataNullHint() || fGLSizeInBytes != this->size()) {
177 GL_CALL(BufferData(target, this->size(), nullptr, fUsage));
178 }
cdalton397536c2016-03-25 12:15:03 -0700179 }
cdaltone2e71c22016-04-07 18:13:29 -0700180 GL_CALL_RET(fMapPtr, MapBuffer(target, readOnly ? GR_GL_READ_ONLY : GR_GL_WRITE_ONLY));
cdalton397536c2016-03-25 12:15:03 -0700181 break;
cdaltone2e71c22016-04-07 18:13:29 -0700182 }
cdalton397536c2016-03-25 12:15:03 -0700183 case GrGLCaps::kMapBufferRange_MapBufferType: {
cdaltone2e71c22016-04-07 18:13:29 -0700184 GrGLenum target = this->glGpu()->bindBuffer(fIntendedType, this);
cdalton397536c2016-03-25 12:15:03 -0700185 // Make sure the GL buffer size agrees with fDesc before mapping.
Brian Salomondbf70722019-02-07 11:31:24 -0500186 if (fGLSizeInBytes != this->size()) {
187 GL_CALL(BufferData(target, this->size(), nullptr, fUsage));
cdalton397536c2016-03-25 12:15:03 -0700188 }
Brian Salomon68aeec02019-04-16 11:01:13 -0400189 GrGLbitfield access;
190 if (readOnly) {
191 access = GR_GL_MAP_READ_BIT;
192 } else {
193 access = GR_GL_MAP_WRITE_BIT;
194 if (GrGpuBufferType::kXferCpuToGpu != fIntendedType) {
195 // TODO: Make this a function parameter.
196 access |= GR_GL_MAP_INVALIDATE_BUFFER_BIT;
197 }
cdalton397536c2016-03-25 12:15:03 -0700198 }
Brian Salomon68aeec02019-04-16 11:01:13 -0400199 GL_CALL_RET(fMapPtr, MapBufferRange(target, 0, this->size(), access));
cdalton397536c2016-03-25 12:15:03 -0700200 break;
201 }
cdaltone2e71c22016-04-07 18:13:29 -0700202 case GrGLCaps::kChromium_MapBufferType: {
203 GrGLenum target = this->glGpu()->bindBuffer(fIntendedType, this);
cdalton397536c2016-03-25 12:15:03 -0700204 // Make sure the GL buffer size agrees with fDesc before mapping.
Brian Salomondbf70722019-02-07 11:31:24 -0500205 if (fGLSizeInBytes != this->size()) {
206 GL_CALL(BufferData(target, this->size(), nullptr, fUsage));
cdalton397536c2016-03-25 12:15:03 -0700207 }
Brian Salomondbf70722019-02-07 11:31:24 -0500208 GL_CALL_RET(fMapPtr, MapBufferSubData(target, 0, this->size(),
209 readOnly ? GR_GL_READ_ONLY : GR_GL_WRITE_ONLY));
cdalton397536c2016-03-25 12:15:03 -0700210 break;
cdaltone2e71c22016-04-07 18:13:29 -0700211 }
cdalton397536c2016-03-25 12:15:03 -0700212 }
Brian Salomondbf70722019-02-07 11:31:24 -0500213 fGLSizeInBytes = this->size();
cdalton397536c2016-03-25 12:15:03 -0700214 VALIDATE();
215}
216
217void GrGLBuffer::onUnmap() {
Robert Phillipsa5b39fa2017-06-08 15:34:16 -0400218 SkASSERT(fBufferID);
cdalton397536c2016-03-25 12:15:03 -0700219 VALIDATE();
220 SkASSERT(this->isMapped());
221 if (0 == fBufferID) {
222 fMapPtr = nullptr;
223 return;
224 }
225 // bind buffer handles the dirty context
226 switch (this->glCaps().mapBufferType()) {
227 case GrGLCaps::kNone_MapBufferType:
228 SkDEBUGFAIL("Shouldn't get here.");
229 return;
230 case GrGLCaps::kMapBuffer_MapBufferType: // fall through
cdaltone2e71c22016-04-07 18:13:29 -0700231 case GrGLCaps::kMapBufferRange_MapBufferType: {
232 GrGLenum target = this->glGpu()->bindBuffer(fIntendedType, this);
233 GL_CALL(UnmapBuffer(target));
cdalton397536c2016-03-25 12:15:03 -0700234 break;
cdaltone2e71c22016-04-07 18:13:29 -0700235 }
cdalton397536c2016-03-25 12:15:03 -0700236 case GrGLCaps::kChromium_MapBufferType:
cdaltone2e71c22016-04-07 18:13:29 -0700237 this->glGpu()->bindBuffer(fIntendedType, this); // TODO: Is this needed?
cdalton397536c2016-03-25 12:15:03 -0700238 GL_CALL(UnmapBufferSubData(fMapPtr));
239 break;
240 }
241 fMapPtr = nullptr;
242}
243
244bool GrGLBuffer::onUpdateData(const void* src, size_t srcSizeInBytes) {
Robert Phillipsa5b39fa2017-06-08 15:34:16 -0400245 SkASSERT(fBufferID);
cdalton397536c2016-03-25 12:15:03 -0700246 if (this->wasDestroyed()) {
247 return false;
248 }
249
250 SkASSERT(!this->isMapped());
cdalton397536c2016-03-25 12:15:03 -0700251 VALIDATE();
Brian Salomondbf70722019-02-07 11:31:24 -0500252 if (srcSizeInBytes > this->size()) {
cdalton397536c2016-03-25 12:15:03 -0700253 return false;
254 }
Brian Salomondbf70722019-02-07 11:31:24 -0500255 SkASSERT(srcSizeInBytes <= this->size());
cdalton397536c2016-03-25 12:15:03 -0700256 // bindbuffer handles dirty context
cdaltone2e71c22016-04-07 18:13:29 -0700257 GrGLenum target = this->glGpu()->bindBuffer(fIntendedType, this);
cdalton397536c2016-03-25 12:15:03 -0700258
Robert Phillipsf2ec0242018-03-01 16:51:25 -0500259 if (this->glCaps().useBufferDataNullHint()) {
Brian Salomondbf70722019-02-07 11:31:24 -0500260 if (this->size() == srcSizeInBytes) {
Robert Phillipsf2ec0242018-03-01 16:51:25 -0500261 GL_CALL(BufferData(target, (GrGLsizeiptr) srcSizeInBytes, src, fUsage));
262 } else {
263 // Before we call glBufferSubData we give the driver a hint using
264 // glBufferData with nullptr. This makes the old buffer contents
265 // inaccessible to future draws. The GPU may still be processing
266 // draws that reference the old contents. With this hint it can
267 // assign a different allocation for the new contents to avoid
268 // flushing the gpu past draws consuming the old contents.
269 // TODO I think we actually want to try calling bufferData here
Brian Salomondbf70722019-02-07 11:31:24 -0500270 GL_CALL(BufferData(target, this->size(), nullptr, fUsage));
Robert Phillipsf2ec0242018-03-01 16:51:25 -0500271 GL_CALL(BufferSubData(target, 0, (GrGLsizeiptr) srcSizeInBytes, src));
272 }
Brian Salomondbf70722019-02-07 11:31:24 -0500273 fGLSizeInBytes = this->size();
cdalton397536c2016-03-25 12:15:03 -0700274 } else {
Robert Phillipsf2ec0242018-03-01 16:51:25 -0500275 // Note that we're cheating on the size here. Currently no methods
276 // allow a partial update that preserves contents of non-updated
277 // portions of the buffer (map() does a glBufferData(..size, nullptr..))
278 GL_CALL(BufferData(target, srcSizeInBytes, src, fUsage));
279 fGLSizeInBytes = srcSizeInBytes;
cdalton397536c2016-03-25 12:15:03 -0700280 }
cdalton397536c2016-03-25 12:15:03 -0700281 VALIDATE();
282 return true;
283}
284
285void GrGLBuffer::setMemoryBacking(SkTraceMemoryDump* traceMemoryDump,
286 const SkString& dumpName) const {
287 SkString buffer_id;
288 buffer_id.appendU32(this->bufferID());
289 traceMemoryDump->setMemoryBacking(dumpName.c_str(), "gl_buffer",
290 buffer_id.c_str());
291}
292
293#ifdef SK_DEBUG
294
295void GrGLBuffer::validate() const {
cdalton397536c2016-03-25 12:15:03 -0700296 SkASSERT(0 != fBufferID || 0 == fGLSizeInBytes);
Brian Salomondbf70722019-02-07 11:31:24 -0500297 SkASSERT(nullptr == fMapPtr || fGLSizeInBytes <= this->size());
cdalton397536c2016-03-25 12:15:03 -0700298}
299
300#endif