50 compiler.
compile(shader, *svm_nodes, 0, &summary);
53 <<
"Shader name: " << shader->
name <<
"\n"
68 scene->
update_stats->svm.times.add_entry({
"device_update", time});
74 LOG_INFO <<
"Total " << num_shaders <<
" shaders.";
76 const double start_time =
time_dt();
84 for (
int i = 0; i < num_shaders; i++) {
85 task_pool.
push([
this, scene, &progress, &shader_svm_nodes, i] {
98 int svm_nodes_size = num_shaders * jump_node_size;
99 for (
int i = 0; i < num_shaders; i++) {
101 svm_nodes_size += shader_svm_nodes[i].size() - jump_node_size;
106 int node_offset = num_shaders * jump_node_size;
107 for (
int i = 0; i < num_shaders; i++) {
118 const int base = shader->
id * jump_node_size;
119 svm_nodes[base + 0] = NODE_SHADER_JUMP;
121 .offset_surface = shader_svm_nodes[i][1] - jump_node_size + node_offset,
122 .offset_volume = shader_svm_nodes[i][2] - jump_node_size + node_offset,
123 .offset_displacement = shader_svm_nodes[i][3] - jump_node_size + node_offset};
124 node_offset += shader_svm_nodes[i].size() - jump_node_size;
128 int *dst = svm_nodes + num_shaders * jump_node_size;
129 for (
int i = 0; i < num_shaders; i++) {
130 const int shader_size = shader_svm_nodes[i].size() - jump_node_size;
132 std::copy_n(&shader_svm_nodes[i][jump_node_size], shader_size, dst);
144 LOG_INFO <<
"Shader manager updated " << num_shaders <<
" shaders in " <<
time_dt() - start_time
219 if (num_unused == size) {
220 offset = i + 1 - size;
223 while (i >= offset) {
249 for (
int i = 0; i < size; i++) {
297 return output->stack_offset;
319 default_value = 0.0f;
363 return output(shader_output);
380 for (
int i = 0; i < size; i++) {
395 if (
in->parent !=
node && !done.contains(
in->parent)) {
443#define SHADER_NODE_TYPE_DERIVATIVE(name) \
445 return name##_DERIVATIVE;
457 const bool use_derivatives)
459 if ((use_derivatives || (shader_node && shader_node->
need_derivatives())) &&
482 const int stack_offset)
494 const int stack_offset)
511 const bool incomplete_derivatives =
node->need_derivatives() &&
513 node->shader_node_type();
514 if (!incomplete_derivatives) {
525 if (base_size == 3) {
529 else if (base_size == 1) {
558 if (
node !=
nullptr && !done.contains(
node) &&
node != skip_node && !dependencies.contains(
node))
563 dependencies.insert(
node);
570 node->compile(*
this);
577 if (
node->has_spatial_varying()) {
585 if (
node->has_spatial_varying()) {
588 if (
node->has_attribute_dependency()) {
636 if (!done_flag[producer->
id] &&
637 std::find(producers.begin(), producers.end(), producer) == producers.end())
639 producers.push_back(producer);
646 unordered_map<const ShaderNode *, int> num_consumers;
649 if (done_flag[
node->id]) {
656 if (!done_flag[consumer->
id] && nodes.contains(consumer) &&
657 std::find(consumers.begin(), consumers.end(), consumer) == consumers.end())
659 consumers.push_back(consumer);
663 num_consumers[
node] = consumers.size();
667 unordered_map<const ShaderNode *, int> sethi_ullman_number;
680 return node_order_key(a) > node_order_key(
b) ||
681 (node_order_key(a) == node_order_key(
b) && a->
id <
b->id);
686 const auto it = sethi_ullman_number.find(
node);
687 if (it != sethi_ullman_number.end()) {
692 get_producers(
node, producers);
694 compute_sethi_ullman_number(producer);
696 std::sort(producers.begin(), producers.end(), node_order_compare);
702 peak_size =
max(peak_size, output_size + current_sethi_ullman_number(producer));
706 sethi_ullman_number[
node] = peak_size;
715 if (done_flag[
node->id]) {
718 compute_sethi_ullman_number(
node);
722 if (!done_flag[
in->parent->id] && nodes.contains(
in->parent)) {
732 sinks.push_back(
node);
735 std::sort(sinks.begin(), sinks.end(), node_order_compare);
739 if (done_flag[
node->id]) {
743 get_producers(
node, producers);
744 std::sort(producers.begin(), producers.end(), node_order_compare);
750 done_flag[
node->id] =
true;
763 if ((
state->node_feature_mask & node_feature) != node_feature) {
769 if (
in->link !=
nullptr) {
794 if (
node->has_surface_transparent()) {
797 if (
node->has_surface_bssrdf()) {
799 if (
node->has_bssrdf_bump()) {
803 if (
node->has_bump()) {
806 if (
node->has_dispersion()) {
836 if (aov_node->
offset >= 0) {
837 aov_nodes.insert(aov_node);
839 if (
in->link !=
nullptr) {
853 if (
state->closure_done.contains(
node)) {
870 if (facin && facin->
link) {
887 set_intersection(cl1deps.begin(),
891 std::inserter(shareddeps, shareddeps.begin()),
898 if (root_node !=
node) {
902 set_intersection(rootdeps.begin(),
906 std::inserter(shareddeps, shareddeps.begin()),
908 set_intersection(rootdeps.begin(),
912 std::inserter(shareddeps, shareddeps.begin()),
921 if (!
state->aov_nodes.empty()) {
922 set_intersection(
state->aov_nodes.begin(),
923 state->aov_nodes.end(),
926 std::inserter(shareddeps, shareddeps.begin()),
928 set_intersection(
state->aov_nodes.begin(),
929 state->aov_nodes.end(),
932 std::inserter(shareddeps, shareddeps.begin()),
936 if (!shareddeps.empty()) {
960 (node_start + jump_node_size);
976 (node_start + jump_node_size);
1010 queue<ShaderNode *> traverse_queue;
1014 if (
node->is_texture_node_and_needs_derivatives(compiler)) {
1015 traverse_queue.push(
node);
1016 scheduled.insert(
node);
1021 while (!traverse_queue.empty()) {
1023 traverse_queue.pop();
1024 node->set_need_derivatives();
1025 LOG_DEBUG <<
"Marking " <<
node->name <<
" as requiring derivatives";
1027 if (input->
link ==
nullptr) {
1030 if (scheduled.contains(input->
link->
parent)) {
1066 clin =
output->input(
"Surface");
1069 clin =
output->input(
"Volume");
1072 clin =
output->input(
"Displacement");
1075 clin =
output->input(
"Normal");
1087 node->added_to_svm =
false;
1101 if (need_bump_state) {
1145 if (!
state.aov_nodes.empty()) {
1158 if (need_bump_state) {
1185 const int start_num_svm_nodes = svm_nodes.
size();
1187 const double time_start =
time_dt();
1194 if (has_bump_from_displacement) {
1197 svm_nodes[
index + 1] = svm_nodes.
size();
1207 if (!has_bump_from_displacement) {
1208 svm_nodes[
index + 1] = svm_nodes.
size();
1217 svm_nodes[
index + 2] = svm_nodes.
size();
1226 svm_nodes[
index + 3] = svm_nodes.
size();
1231 if (summary !=
nullptr) {
1278 max_id =
max(
node->id, max_id);
unsigned long long int uint64_t
static AttributeStandard name_standard(ustring name)
Shader * get_shader(const Scene *scene)
device_vector< int > svm_nodes
ShaderGraph * current_graph
void compile_type(Shader *shader, ShaderGraph *graph, ShaderType type)
SVMStackOffset input_link(const char *name)
ShaderNodeType node_type(const ShaderNode *shader_node, const ShaderNodeType type, const bool use_derivatives)
void find_aov_nodes_and_dependencies(ShaderNodeSet &aov_nodes, ShaderGraph *graph, CompilerState *state)
SVMCompiler(Scene *scene, Progress &progress)
SVMStackOffset output(const char *name)
void compile(Shader *shader, array< int > &svm_nodes, const int index, Summary *summary=nullptr)
SVMInputFloat input_float(const char *name)
void generate_closure_node(ShaderNode *node, CompilerState *state)
void add_value_node(ShaderNode *shader_node, const float value, const int stack_offset)
SVMStackOffset bump_state_offset
void generate_node(ShaderNode *node, ShaderNodeSet &done)
void stack_zero_incomplete_derivatives(const ShaderNode *node)
SVMStackOffset stack_find_offset(const ShaderIO *io)
void stack_clear_users(ShaderNode *node, ShaderNodeSet &done)
int stack_size(SocketType::Type type)
int stack_node_output_size(const ShaderNode *node)
void add_node(ShaderNodeType type)
void find_dependencies(ShaderNodeSet &dependencies, const ShaderNodeSet &done, ShaderInput *input, ShaderNode *skip_node=nullptr)
void stack_clear_temporary(ShaderNode *node)
uint attribute_standard(ustring name)
bool is_sole_user(const ShaderNode *node, const ShaderOutput *output, const ShaderNodeSet &done)
void stack_link(ShaderInput *input, ShaderOutput *output)
ShaderNode * current_node
void add_node_data_float(const float f)
SVMStackOffset mix_weight_offset
void generate_svm_nodes(const ShaderNodeSet &nodes, CompilerState *state)
array< int > current_svm_nodes
void generate_multi_closure(ShaderNode *root_node, ShaderNode *node, CompilerState *state)
void add_node_data_float4(const float4 &f)
SVMInputInt input_int(const char *name)
uint attribute(ustring name)
SVMStackOffset stack_assign(ShaderInput *input)
std::atomic_int * svm_node_types_used
SVMInputFloat3 input_float3(const char *name)
void stack_clear_offset(const ShaderIO *io, const SVMStackOffset offset)
void generated_shared_closure_nodes(ShaderNode *root_node, ShaderNode *node, CompilerState *state, const ShaderNodeSet &shared)
SVMInputFloat3 input_float3_from_offset(SVMStackOffset offset)
void device_free(Device *device, DeviceScene *dscene, Scene *scene) override
void device_update_specific(Device *device, DeviceScene *dscene, Scene *scene, Progress &progress) override
~SVMShaderManager() override
void device_update_shader(Scene *scene, Shader *shader, Progress &progress, array< int > *svm_nodes)
unique_ptr< LightManager > light_manager
unique_ptr< SceneUpdateStats > update_stats
unique_ptr_vector< Shader > shaders
unique_ptr< ShaderManager > shader_manager
unique_ptr_vector< ShaderNode > nodes
const SocketType & socket_type
SocketType::Type type() const
void device_update_common(Device *device, DeviceScene *dscene, Scene *scene, Progress &progress)
void device_free_common(Device *device, DeviceScene *dscene, Scene *scene)
ShaderInput * input(const char *name)
bool need_derivatives() const
unique_ptr_vector< ShaderInput > inputs
ShaderOutput * output(const char *name)
vector< ShaderInput * > links
bool has_surface_spatial_varying
bool has_bump_from_surface
bool has_volume_attribute_dependency
bool has_bump_from_displacement
EmissionSampling emission_sampling
bool has_surface_raytrace
bool has_surface_transparent
NODE_DECLARE unique_ptr< ShaderGraph > graph
bool has_volume_spatial_varying
void push(TaskRunFunction &&task)
void wait_work(Summary *stats=nullptr)
void append(const array< T > &from)
void push_back_slow(const T &t)
T * alloc(const size_t width, const size_t height=0)
#define KERNEL_FEATURE_NODE_MASK_DISPLACEMENT
#define KERNEL_FEATURE_NODE_MASK_BUMP
#define KERNEL_FEATURE_NODE_MASK_VOLUME
#define SVM_BUMP_EVAL_STATE_SIZE
#define KERNEL_FEATURE_NODE_MASK_SURFACE
#define SVM_STACK_INVALID
#define SVM_INPUT_STACK_OFFSET_MASK
#define KERNEL_FEATURE_NODE_RAYTRACE
#define CCL_NAMESPACE_END
#define assert(assertion)
@ SHADER_TYPE_DISPLACEMENT
ccl_device_inline bool isfinite_safe(const float f)
CCL_NAMESPACE_BEGIN ccl_device_inline float3 zero_float3()
@ SHADER_SPECIAL_TYPE_OUTPUT_AOV
@ SHADER_SPECIAL_TYPE_COMBINE_CLOSURE
set< ShaderNode *, ShaderNodeIDComparator > ShaderNodeSet
CCL_NAMESPACE_BEGIN string string_printf(const char *format,...)
float get_float(const SocketType &input) const
float3 get_float3(const SocketType &input) const
int reference_count() const
int get_int(const SocketType &input) const
vector< bool > nodes_done_flag
CompilerState(ShaderGraph *graph)
uint64_t node_feature_mask
int users[SVM_STACK_SIZE]
double time_generate_volume
double time_generate_surface
double time_generate_bump
string full_report() const
double time_generate_displacement
static void mark_nodes_requiring_derivatives(const SVMCompiler &compiler, ShaderGraph *graph, const ShaderType type)
static ShaderNodeType svm_node_type_with_derivatives(ShaderNodeType type)
CCL_NAMESPACE_BEGIN double time_dt()