blob: f8835cf3cedd2bb62667f6b0ed1c304718aed008 [file] [log] [blame]
* Copyright 2021 Google LLC
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
#ifndef skgpu_graphite_PipelineDataCache_DEFINED
#define skgpu_graphite_PipelineDataCache_DEFINED
#include "src/base/SkArenaAlloc.h"
#include "src/core/SkTHash.h"
#include "src/gpu/graphite/PipelineData.h"
namespace skgpu::graphite {
// Add a block of data to the cache and return a stable pointer to the contents (assuming that a
// resettable gatherer had accumulated the input data pointer).
// If an identical block of data is already in the cache, that existing pointer is returned, making
// pointer comparison suitable when comparing data blocks retrieved from the cache.
// T must define a hash() function, an operator==, and a static Make(const T&, SkArenaAlloc*)
// factory that's used to copy the data into an arena allocation owned by the PipelineDataCache.
template<typename T>
class PipelineDataCache {
PipelineDataCache() = default;
const T* insert(const T& dataBlock) {
DataRef data{&dataBlock}; // will not be persisted, since pointer isn't from the arena.
const DataRef* existing = fDataPointers.find(data);
if (existing) {
return existing->fPointer;
} else {
// Need to make a copy of dataBlock into the arena
T* copy = T::Make(dataBlock, &fArena);
return copy;
// The number of unique T objects in the cache
int count() const {
return fDataPointers.count();
// Call fn on every item in the set. You may not mutate anything.
template <typename Fn> // f(T), f(const T&)
void foreach(Fn&& fn) const {
fDataPointers.foreach([fn](const DataRef& ref){
struct DataRef {
const T* fPointer;
bool operator==(const DataRef& o) const {
if (!fPointer || !o.fPointer) {
return !fPointer && !o.fPointer;
} else {
return *fPointer == *o.fPointer;
struct Hash {
// This hash operator de-references and hashes the data contents
size_t operator()(const DataRef& dataBlock) const {
return dataBlock.fPointer ? dataBlock.fPointer->hash() : 0;
SkTHashSet<DataRef, Hash> fDataPointers;
// Holds the data that is pointed to by fDataPointers
SkArenaAlloc fArena{0};
// A UniformDataCache lives for the entire duration of a Recorder.
using UniformDataCache = PipelineDataCache<UniformDataBlock>;
// A TextureDataCache only lives for a single Recording. When a Recording is snapped it is pulled
// off of the Recorder and goes with the Recording as a record of the required Textures and
// Samplers.
using TextureDataCache = PipelineDataCache<TextureDataBlock>;
} // namespace skgpu::graphite
#endif // skgpu_graphite_PipelineDataCache_DEFINED