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
|
//
// Copyright 2017 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// MemoryProgramCache: Stores compiled and linked programs in memory so they don't
// always have to be re-compiled. Can be used in conjunction with the platform
// layer to warm up the cache from disk.
#ifndef LIBANGLE_MEMORY_PROGRAM_CACHE_H_
#define LIBANGLE_MEMORY_PROGRAM_CACHE_H_
#include <array>
#include "common/MemoryBuffer.h"
#include "libANGLE/Error.h"
#include "libANGLE/SizedMRUCache.h"
namespace gl
{
// 160-bit SHA-1 hash key.
constexpr size_t kProgramHashLength = 20;
using ProgramHash = std::array<uint8_t, kProgramHashLength>;
} // namespace gl
namespace std
{
template <>
struct hash<gl::ProgramHash>
{
// Simple routine to hash four ints.
size_t operator()(const gl::ProgramHash &programHash) const
{
unsigned int hash = 0;
for (uint32_t num : programHash)
{
hash *= 37;
hash += num;
}
return hash;
}
};
} // namespace std
namespace gl
{
class Context;
class InfoLog;
class Program;
class ProgramState;
class MemoryProgramCache final : angle::NonCopyable
{
public:
MemoryProgramCache(size_t maxCacheSizeBytes);
~MemoryProgramCache();
// Writes a program's binary to the output memory buffer.
static void Serialize(const Context *context,
const Program *program,
angle::MemoryBuffer *binaryOut);
// Loads program state according to the specified binary blob.
static LinkResult Deserialize(const Context *context,
const Program *program,
ProgramState *state,
const uint8_t *binary,
size_t length,
InfoLog &infoLog);
static void ComputeHash(const Context *context, const Program *program, ProgramHash *hashOut);
// Check if the cache contains a binary matching the specified program.
bool get(const ProgramHash &programHash, const angle::MemoryBuffer **programOut);
// For querying the contents of the cache.
bool getAt(size_t index, ProgramHash *hashOut, const angle::MemoryBuffer **programOut);
// Evict a program from the binary cache.
void remove(const ProgramHash &programHash);
// Helper method that serializes a program.
void putProgram(const ProgramHash &programHash, const Context *context, const Program *program);
// Same as putProgram but computes the hash.
void updateProgram(const Context *context, const Program *program);
// Store a binary directly.
void putBinary(const ProgramHash &programHash, const uint8_t *binary, size_t length);
// Check the cache, and deserialize and load the program if found. Evict existing hash if load
// fails.
LinkResult getProgram(const Context *context,
const Program *program,
ProgramState *state,
ProgramHash *hashOut);
// Empty the cache.
void clear();
// Resize the cache. Discards current contents.
void resize(size_t maxCacheSizeBytes);
// Returns the number of entries in the cache.
size_t entryCount() const;
// Reduces the current cache size and returns the number of bytes freed.
size_t trim(size_t limit);
// Returns the current cache size in bytes.
size_t size() const;
// Returns the maximum cache size in bytes.
size_t maxSize() const;
private:
enum class CacheSource
{
PutProgram,
PutBinary,
};
using CacheEntry = std::pair<angle::MemoryBuffer, CacheSource>;
angle::SizedMRUCache<ProgramHash, CacheEntry> mProgramBinaryCache;
unsigned int mIssuedWarnings;
};
} // namespace gl
#endif // LIBANGLE_MEMORY_PROGRAM_CACHE_H_
|
