29using namespace blender::gpu::shader;
42 std::atomic<gpu::Shader *>
shader =
nullptr;
63 bool deferred_compilation,
77 GPUShaderCreateInfo *base_info =
reinterpret_cast<GPUShaderCreateInfo *
>(
create_info);
79 if (deferred_compilation) {
116 fprintf(stderr,
"gpu::Shader: error: too many samplers in shader.\n");
142 GPUShaderCreateInfo *base_info =
reinterpret_cast<GPUShaderCreateInfo *
>(
create_info);
183 int previous_refcount = pass->
refcount++;
190 int previous_refcount = pass->
refcount--;
218 static constexpr float gc_collect_rate_ = 60.0f;
219 static constexpr float optimization_gc_collect_rate_ = 1.0f;
230 passes_[i][0].clear();
231 passes_[i][1].clear();
238 bool deferred_compilation,
239 bool is_optimization_pass)
241 std::lock_guard
lock(mutex_);
243 passes_[engine][is_optimization_pass].add(
246 deferred_compilation,
247 is_optimization_pass,
254 bool is_optimization_pass)
256 std::lock_guard
lock(mutex_);
257 std::unique_ptr<GPUPass> *pass = passes_[engine][is_optimization_pass].lookup_ptr(
hash);
258 if (!allow_deferred && pass && pass->get()->status ==
GPU_PASS_QUEUED) {
259 pass->get()->finalize_compilation();
261 return pass ? pass->get() :
nullptr;
266 std::lock_guard
lock(mutex_);
271 for (
auto &engine_passes : passes_) {
272 for (std::unique_ptr<GPUPass> &pass : engine_passes[
false].values()) {
273 pass->update(timestamp);
276 engine_passes[
false].remove_if(
277 [&](
auto item) {
return item.value->should_gc(gc_collect_rate_, timestamp); });
281 for (
auto &engine_passes : passes_) {
282 for (std::unique_ptr<GPUPass> &pass : engine_passes[
true].values()) {
283 pass->update(timestamp);
286 engine_passes[
true].remove_if([&](
auto item) {
287 return item.value->should_gc(optimization_gc_collect_rate_, timestamp);
312 g_cache = MEM_new<GPUPassCache>(__func__);
339 int samplers_len = 0;
352 const char *debug_name,
354 bool deferred_compilation,
361 GPUCodegen codegen(material, graph, debug_name);
365 if (optimize_graph) {
377 if (optimize_graph) {
390 pass =
g_cache->
get(engine, codegen.
hash_get(), deferred_compilation, optimize_graph);
402 finalize_source_cb(thunk, material, &codegen.
output);
405 g_cache->
add(engine, codegen, deferred_compilation, optimize_graph);
408 return g_cache->
get(engine, codegen.
hash_get(), deferred_compilation, optimize_graph);
Platform independent time functions.
#define GPU_SHADER_FREE_SAFE(shader)
Read Blender memory allocation and freeing.
#define UNUSED_VARS_NDEBUG(...)
#define BLI_assert_msg(a, msg)
void add(eGPUMaterialEngine engine, GPUCodegen &codegen, bool deferred_compilation, bool is_optimization_pass)
GPUPass * get(eGPUMaterialEngine engine, size_t hash, bool allow_deferred, bool is_optimization_pass)
constexpr IndexRange()=default
GPUCodegenCreateInfo * create_info
void generate_uniform_buffer()
bool should_optimize_heuristic() const
void generate_material_props()
void extract_uniform_list()
uint32_t hash_get() const
void generate_resources()
void sort_uniform_inputs()
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
static GPUPassCache * g_cache
unsigned __int64 uint64_t
void GPU_shader_compiler_wait_for_all()
void GPU_shader_compiler_pause()
bool GPU_pass_should_optimize(GPUPass *pass)
GPUBackendType GPU_backend_get_type()
void GPU_pass_acquire(GPUPass *pass)
void GPU_shader_async_compilation_cancel(AsyncCompilationHandle &handle)
gpu::Shader * GPU_shader_create_from_info(const GPUShaderCreateInfo *_info)
gpu::Shader * GPU_pass_shader_get(GPUPass *pass)
uint64_t GPU_pass_compilation_timestamp(GPUPass *pass)
void GPU_pass_cache_update()
GPUPassStatus GPU_pass_status(GPUPass *pass)
static bool gpu_pass_validate(GPUCodegenCreateInfo *create_info)
int64_t AsyncCompilationHandle
void GPU_pass_cache_init()
void GPU_pass_release(GPUPass *pass)
void GPU_pass_cache_free()
bool GPU_shader_async_compilation_is_ready(AsyncCompilationHandle handle)
void GPU_pass_cache_wait_for_all()
gpu::Shader * GPU_shader_async_compilation_finalize(AsyncCompilationHandle &handle)
uint64_t GPU_pass_global_compilation_count()
void gpu_node_graph_finalize_uniform_attrs(GPUNodeGraph *graph)
double BLI_time_now_seconds()
GPUPass * GPU_generate_pass(GPUMaterial *material, GPUNodeGraph *graph, const char *debug_name, eGPUMaterialEngine engine, bool deferred_compilation, GPUCodegenCallbackFn finalize_source_cb, void *thunk, bool optimize_graph)
void gpu_node_graph_prune_unused(GPUNodeGraph *graph)
AsyncCompilationHandle GPU_shader_async_compilation(const GPUShaderCreateInfo *info, CompilationPriority priority=CompilationPriority::High)
void GPU_pass_ensure_its_ready(GPUPass *pass)
void(*)(void *thunk, GPUMaterial *mat, struct GPUCodegenOutput *codegen) GPUCodegenCallbackFn
void gpu_node_graph_optimize(GPUNodeGraph *graph)
void GPU_shader_compiler_resume()
bool is_optimization_pass
void update(double timestamp)
std::atomic< int > refcount
GPUPass(GPUCodegenCreateInfo *info, bool deferred_compilation, bool is_optimization_pass, bool should_optimize)
AsyncCompilationHandle compilation_handle
static std::atomic< uint64_t > compilation_counts
std::atomic< gpu::Shader * > shader
std::atomic< GPUPassStatus > status
static constexpr float optimization_delay
void update_compilation(double timestamp)
double creation_timestamp
CompilationPriority compilation_priority()
GPUCodegenCreateInfo * create_info
void update_gc_timestamp(double timestamp)
uint64_t compilation_timestamp
void finalize_compilation()
bool should_gc(int gc_collect_rate, double timestamp)
void finalize(const bool recursive=false)
Vector< Resource > resources_get_all_() const