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
148
149
150
151
152
153
|
// Copyright 2022 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef GPU_COMMAND_BUFFER_SERVICE_DAWN_CACHING_INTERFACE_H_
#define GPU_COMMAND_BUFFER_SERVICE_DAWN_CACHING_INTERFACE_H_
#include <dawn/platform/DawnPlatform.h>
#include <memory>
#include <string>
#include "base/containers/flat_map.h"
#include "base/containers/flat_set.h"
#include "base/containers/linked_list.h"
#include "base/functional/callback.h"
#include "base/memory/memory_pressure_listener.h"
#include "base/memory/ref_counted.h"
#include "base/synchronization/lock.h"
#include "base/thread_annotations.h"
#include "base/trace_event/memory_dump_provider.h"
#include "components/persistent_cache/persistent_cache.h"
#include "gpu/command_buffer/common/shm_count.h"
#include "gpu/command_buffer/service/memory_cache.h"
#include "gpu/gpu_gles2_export.h"
#include "gpu/ipc/common/gpu_disk_cache_type.h"
namespace gpu {
class GpuPersistentCache;
namespace webgpu {
class DawnCachingInterfaceFactory;
// Provides a wrapper class around an in-memory DawnMemoryCache and a disk
// cache. The disk cache controller can be provided either via a
// CacheBlobCallback or a GpuPersistentCache pointer.
class GPU_GLES2_EXPORT DawnCachingInterface
: public dawn::platform::CachingInterface {
public:
using CacheBlobCallback =
base::RepeatingCallback<void(const std::string& key,
const std::string& blob)>;
~DawnCachingInterface() override;
void InitializePersistentCache(
persistent_cache::PendingBackend pending_backend,
scoped_refptr<RefCountedGpuProcessShmCount> use_shader_cache_shm_count);
size_t LoadData(const void* key,
size_t key_size,
void* value_out,
size_t value_size) override;
void StoreData(const void* key,
size_t key_size,
const void* value,
size_t value_size) override;
private:
friend class DawnCachingInterfaceFactory;
// Simplified accessor to the backend.
MemoryCache* memory_cache() { return memory_cache_backend_.get(); }
// Constructor is private because creation of interfaces should be deferred to
// the factory.
explicit DawnCachingInterface(scoped_refptr<MemoryCache> backend,
CacheBlobCallback callback = {});
explicit DawnCachingInterface(
scoped_refptr<MemoryCache> backend,
scoped_refptr<GpuPersistentCache> persistent_cache);
// Caching interface owns a reference to the backend.
scoped_refptr<MemoryCache> memory_cache_backend_ = nullptr;
// The callback provides ability to store cache entries to persistent disk.
CacheBlobCallback cache_blob_callback_;
// The interface that allows storing and loading cache entries directly
// to/from disk.
// TODO(crbug.com/399642827): Remove the above callback once we migrate
// everything to use GpuPersistentCache API.
scoped_refptr<GpuPersistentCache> persistent_cache_;
};
// Factory class for producing and managing DawnCachingInterfaces.
// Creating/using caching interfaces through the factory guarantees that we will
// not run into issues where backends are being initialized with the same
// parameters leading to blockage.
class GPU_GLES2_EXPORT DawnCachingInterfaceFactory
: public base::trace_event::MemoryDumpProvider {
public:
// Factory for backend creation, especially for testing.
using BackendFactory = base::RepeatingCallback<scoped_refptr<MemoryCache>()>;
explicit DawnCachingInterfaceFactory(BackendFactory factory);
DawnCachingInterfaceFactory();
~DawnCachingInterfaceFactory() override;
// Returns a pointer to a DawnCachingInterface, creating a backend for it if
// necessary. For handle based instances, the factory keeps a reference to the
// backend until ReleaseHandle below is called.
std::unique_ptr<DawnCachingInterface> CreateInstance(
const gpu::GpuDiskCacheHandle& handle,
DawnCachingInterface::CacheBlobCallback callback = {});
std::unique_ptr<DawnCachingInterface> CreateInstance(
const gpu::GpuDiskCacheHandle& handle,
scoped_refptr<GpuPersistentCache> persistent_cache);
// Returns a pointer to a DawnCachingInterface that owns the in memory
// backend. This is used for incognito cases where the cache should not be
// persisted to disk.
std::unique_ptr<DawnCachingInterface> CreateInstance();
// Releases the factory held reference of the handle's backend. Generally this
// is the last reference which means that the in-memory disk cache will be
// destroyed and the resources reclaimed. The factory needs to hold an extra
// reference in order to avoid potential races where the browser may be about
// to reuse the same handle, but the last reference on the GPU side has just
// been released causing us to clear the in-memory disk cache too early. When
// that happens, the disk cache entries are not re-sent over to the GPU
// process. To avoid this, when the browser's last reference goes away, it
// notifies the GPU process, and the last reference held by the factory is
// released.
void ReleaseHandle(const gpu::GpuDiskCacheHandle& handle);
void PurgeMemory(base::MemoryPressureLevel memory_pressure_level);
// base::trace_event::MemoryDumpProvider implementation.
bool OnMemoryDump(const base::trace_event::MemoryDumpArgs& args,
base::trace_event::ProcessMemoryDump* pmd) override;
private:
scoped_refptr<MemoryCache> GetOrCreateMemoryCache(
const gpu::GpuDiskCacheHandle& handle);
// Creates a default backend for assignment.
static scoped_refptr<MemoryCache> CreateDefaultInMemoryBackend();
// Factory to create backends.
BackendFactory backend_factory_;
// Map that holds existing backends.
base::flat_map<gpu::GpuDiskCacheHandle, scoped_refptr<MemoryCache>> backends_;
};
} // namespace webgpu
} // namespace gpu
#endif // GPU_COMMAND_BUFFER_SERVICE_DAWN_CACHING_INTERFACE_H_
|
