81 const bool use_sample_subset,
82 const int sample_subset_offset,
83 const int sample_subset_length)
88 if (use_sample_subset) {
91 min(sample_subset_offset + sample_subset_length,
num_samples_) - sample_subset_offset, 0);
124 return state_.num_rendered_samples;
129 return state_.total_rendered_samples;
141 state_.resolution_divider = 1;
144 state_.user_is_navigating =
true;
148 state_.num_rendered_samples = 0;
149 state_.total_rendered_samples = 0;
150 state_.last_display_update_time = 0.0;
151 state_.last_display_update_sample = -1;
153 state_.last_rebalance_time = 0.0;
154 state_.num_rebalance_requested = 0;
155 state_.num_rebalance_changes = 0;
156 state_.last_rebalance_changed =
false;
157 state_.need_rebalance_at_next_work =
false;
161 state_.adaptive_sampling_threshold = 0.4f;
163 state_.last_work_tile_was_denoised =
false;
164 state_.tile_result_was_written =
false;
165 state_.postprocess_work_scheduled =
false;
166 state_.full_frame_work_scheduled =
false;
167 state_.full_frame_was_written =
false;
169 state_.path_trace_finished =
false;
171 state_.start_render_time = 0.0;
172 state_.end_render_time = 0.0;
173 state_.time_limit_reached =
false;
175 state_.occupancy_num_samples = 0;
207 state_.path_trace_finished =
true;
209 bool denoiser_delayed;
210 bool denoiser_ready_to_display;
214 render_work.
display.use_denoised_result = denoiser_ready_to_display;
233 state_.adaptive_sampling_threshold =
max(
state_.adaptive_sampling_threshold / 2,
248 LOG_DEBUG <<
"Schedule work for cancel.";
260 const bool tile_write = render_work.
tile.write;
261 const bool full_write = render_work.
full.write;
265 render_work.
tile.write = tile_write;
266 render_work.
full.write = full_write;
270 if (!
state_.tile_result_was_written && has_rendered_samples) {
271 render_work.
tile.write =
true;
274 if (!
state_.full_frame_was_written) {
275 render_work.
full.write =
true;
287 if (has_rendered_samples && !
state_.full_frame_was_written) {
288 render_work.
display.update =
true;
298 if (
state_.path_trace_finished ||
state_.time_limit_reached) {
309 const double time_now =
time_dt();
324 state_.end_render_time = time_now;
335 if (
state_.user_is_navigating) {
337 state_.user_is_navigating =
false;
350 state_.num_rendered_samples = 0;
351 state_.total_rendered_samples = 0;
352 state_.last_display_update_sample = -1;
361 state_.num_rendered_samples = 0;
385 bool denoiser_delayed;
386 bool denoiser_ready_to_display;
392 render_work.
display.use_denoised_result = denoiser_ready_to_display;
405 const double time_now =
time_dt();
408 state_.last_rebalance_time = time_now;
409 ++
state_.num_rebalance_requested;
414 if (render_work.
display.update) {
415 state_.last_display_update_time = time_now;
416 state_.last_display_update_sample =
state_.num_rendered_samples;
419 state_.last_work_tile_was_denoised = render_work.
tile.denoise;
420 state_.tile_result_was_written |= render_work.
tile.write;
421 state_.full_frame_was_written |= render_work.
full.write;
426 if (
state_.postprocess_work_scheduled) {
429 state_.postprocess_work_scheduled =
true;
431 bool any_scheduled =
false;
435 any_scheduled =
true;
440 any_scheduled =
true;
443 if (!
state_.tile_result_was_written) {
444 render_work->
tile.write =
true;
445 any_scheduled =
true;
449 render_work->
display.update =
true;
452 return any_scheduled;
457 if (
state_.full_frame_work_scheduled) {
471 if (
state_.full_frame_was_written) {
475 state_.full_frame_work_scheduled =
true;
477 render_work->
full.write =
true;
490 return time * resolution_divider_sq;
501 state_.start_render_time == 0.0)
595 LOG_DEBUG <<
"Average volume guiding denoising time: "
626 bool balance_changed)
636 if (balance_changed) {
637 ++
state_.num_rebalance_changes;
640 state_.last_rebalance_changed = balance_changed;
647 const double render_wall_time =
state_.end_render_time -
state_.start_render_time;
650 string result =
"\nRender Scheduler Summary\n\n";
661 mode =
"Interactive";
663 result +=
"Mode: " + mode +
"\n";
669 result +=
"\nAdaptive sampling:\n";
677 result +=
"\nDenoiser:\n";
683 string passes =
"Color";
685 passes +=
", Albedo";
688 passes +=
", Specular Albedo";
691 passes +=
", Normal";
694 passes +=
", Roughness";
700 passes +=
", Backward Motion";
703 passes +=
", Specular Motion";
706 result +=
" Passes: " + passes +
"\n";
709 if (
state_.num_rebalance_requested) {
710 result +=
"\nRebalancer:\n";
711 result +=
" Number of requested rebalances: " +
to_string(
state_.num_rebalance_requested) +
713 result +=
" Number of performed rebalances: " +
to_string(
state_.num_rebalance_changes) +
717 result +=
"\nTime (in seconds):\n";
718 result +=
string_printf(
" %20s %20s %20s\n",
"",
"Wall",
"Average");
741 if (
state_.num_rebalance_requested) {
750 result +=
"\n Total: " +
to_string(total_time) +
"\n";
753 "\nRendered %d samples in %f seconds\n", num_rendered_samples, render_wall_time);
758 result +=
string_printf(
"Average time per sample: %f seconds\n",
759 render_wall_time / num_rendered_samples);
771 int num_rendered_samples)
const
774 num_rendered_samples);
777 const double remaining_render_time =
max(0.0,
780 update_interval =
min(update_interval, remaining_render_time);
783 return update_interval;
789 int num_rendered_samples)
const
796 if (
state_.need_rebalance_at_next_work) {
799 if (
state_.last_rebalance_changed) {
810 if (num_rendered_samples < 32) {
821 if (render_time < 1) {
824 if (render_time < 2) {
827 if (render_time < 4) {
830 if (render_time < 8 || num_rendered_samples < 32) {
840 if (time_per_sample_average == 0.0) {
848 return max(
int(num_samples_in_second * update_interval_in_seconds), 1);
862 if (num_samples == 1) {
871 const uint num_samples_down = num_samples_up - (num_samples_up >> 1);
873 const uint delta_up = num_samples_up - num_samples;
874 const uint delta_down = num_samples - num_samples_down;
876 if (delta_up <= delta_down) {
877 return num_samples_up;
880 return num_samples_down;
892 if (
state_.num_rendered_samples == 0 &&
state_.last_display_update_sample == -1) {
909 int num_samples_to_render =
min(num_samples_pot, max_num_samples_to_render);
916 int num_samples_to_occupy =
state_.occupancy_num_samples;
917 float ratio_to_increase_occupancy = 1.0f;
919 ratio_to_increase_occupancy = 0.7f /
state_.occupancy;
920 num_samples_to_occupy = lround(
state_.occupancy_num_samples * ratio_to_increase_occupancy);
929 double path_tracing_time_limit = 0;
940 path_tracing_time_limit = 2.0;
943 path_tracing_time_limit = 15.0;
953 const double remaining_render_time =
max(
955 if (path_tracing_time_limit == 0) {
956 path_tracing_time_limit = remaining_render_time;
959 path_tracing_time_limit =
min(path_tracing_time_limit, remaining_render_time);
962 if (path_tracing_time_limit != 0) {
966 const double predicted_render_time = num_samples_to_occupy *
968 ratio_to_increase_occupancy;
969 if (predicted_render_time > path_tracing_time_limit) {
970 num_samples_to_occupy = lround(num_samples_to_occupy *
971 (path_tracing_time_limit / predicted_render_time));
975 num_samples_to_render =
max(num_samples_to_render,
976 min(num_samples_to_occupy, max_num_samples_to_render));
986 return num_samples_to_render;
994 num_samples_to_render);
1038 ready_to_display =
true;
1072 state_.num_rendered_samples :
1084 ready_to_display =
false;
1105 if (denoiser_delayed) {
1118 if (
done() ||
state_.last_display_update_sample == -1) {
1136 state_.last_display_update_sample);
1137 return (
time_dt() -
state_.last_display_update_time) > update_interval;
1144 static const double kRebalanceIntervalInSeconds = 1;
1157 if (
state_.num_rendered_samples == 0) {
1158 state_.need_rebalance_at_next_work =
true;
1162 if (
state_.need_rebalance_at_next_work) {
1163 state_.need_rebalance_at_next_work =
false;
1167 if (
state_.last_rebalance_changed) {
1171 return (
time_dt() -
state_.last_rebalance_time) > kRebalanceIntervalInSeconds;
1188 const int max_res_divider_for_desired_size = long_viewport_axis / 128;
1194 max_res_divider_for_desired_size);
1204 const double desired_update_interval_in_seconds =
1215 desired_update_interval_in_seconds * 1.4, actual_time_per_update);
1290 if (
state_.start_render_time == 0.0) {
1295 const double current_time =
time_dt();
1302 state_.time_limit_reached =
true;
1303 state_.end_render_time = current_time;
1311 const double actual_time)
1313 const double ratio_between_times = actual_time / desired_time;
1339 int resolution_divider = 1;
1340 while (width * height > resolution * resolution) {
1341 width =
max(1, width / 2);
1342 height =
max(1, height / 2);
1344 resolution_divider <<= 1;
1347 return resolution_divider;
1352 const int resolution_divider)
1354 const int pixel_area = width * height;
1355 const int resolution = lround(
sqrt(pixel_area));
1357 return resolution / resolution_divider;
int align_samples(const int start_sample, const int num_samples) const
bool need_filter(const int sample) const
static const int MAX_SAMPLES
double get_average() const
double get_last_sample_time() const
void add_average(const double time, const int num_measurements=1)
void add_wall(const double time)
int limit_samples_per_update_
AdaptiveSampling adaptive_sampling_
DenoiseParams denoiser_params_
void set_time_limit(const double time_limit)
void update_state_for_render_work(const RenderWork &render_work)
void report_path_trace_occupancy(const RenderWork &render_work, const float occupancy)
double guess_display_update_interval_in_seconds_for_num_samples(const int num_rendered_samples) const
float work_adaptive_threshold() const
int calculate_num_samples_per_update() const
int get_rendered_sample() const
void report_adaptive_filter_time(const RenderWork &render_work, const double time, bool is_cancelled)
bool work_need_update_display(const bool denoiser_delayed)
BufferParams buffer_params_
bool work_need_rebalance()
void set_need_schedule_rebalance(bool need_schedule_rebalance)
double guess_display_update_interval_in_seconds() const
void reset_for_next_tile()
bool work_need_denoise(bool &delayed, bool &ready_to_display)
bool work_need_adaptive_filter() const
int get_num_rendered_samples() const
string full_report() const
bool need_schedule_rebalance_works_
bool is_denoise_active_during_update() const
void report_denoise_time(const RenderWork &render_work, const double time)
bool set_postprocess_render_work(RenderWork *render_work)
double get_time_limit() const
double guess_display_update_interval_in_seconds_for_num_samples_no_limit(int num_rendered_samples) const
bool work_is_usable_for_first_render_estimation(const RenderWork &render_work)
int calculate_resolution_divider_for_time(const double desired_time, const double actual_time)
TimeWithAverage volume_guiding_denoise_time_
bool is_adaptive_sampling_used() const
void set_denoiser_params(const DenoiseParams ¶ms)
bool is_denoiser_interactive() const
bool use_progressive_noise_floor_
int get_total_rendered_samples() const
struct RenderScheduler::@152371007237337307247005247137000032232276335003 first_render_time_
bool render_work_reschedule_on_idle(RenderWork &render_work)
int get_num_samples() const
TimeWithAverage adaptive_filter_time_
void report_display_update_time(const RenderWork &render_work, const double time)
TimeWithAverage rebalance_time_
void set_sample_params(const int num_samples, const bool use_sample_subset, const int sample_subset_offset, const int sample_subset_length)
int get_sample_offset() const
int default_start_resolution_divider_
bool is_denoiser_gpu_used() const
TimeWithAverage display_update_time_
void reset(const BufferParams &buffer_params)
void set_full_frame_render_work(RenderWork *render_work)
double guess_viewport_navigation_update_interval_in_seconds() const
void update_start_resolution_divider()
void report_path_trace_time(const RenderWork &render_work, const double time, bool is_cancelled)
void set_adaptive_sampling(const AdaptiveSampling &adaptive_sampling)
int start_resolution_divider_
int get_num_samples_during_navigation(const int resolution_divider) const
bool render_work_reschedule_on_converge(RenderWork &render_work)
TileManager & tile_manager_
bool work_report_reset_average(const RenderWork &render_work)
TimeWithAverage path_trace_time_
bool need_schedule_cryptomatte_
void check_time_limit_reached()
int get_start_sample_to_path_trace() const
int get_num_samples_to_path_trace() const
void render_work_reschedule_on_cancel(RenderWork &render_work)
void report_work_begin(const RenderWork &render_work)
TimeWithAverage denoise_time_
void set_need_schedule_cryptomatte(bool need_schedule_cryptomatte)
void report_rebalance_time(const RenderWork &render_work, const double time, bool balance_changed)
void set_limit_samples_per_update(const int limit_samples)
RenderWork get_render_work()
RenderScheduler(TileManager &tile_manager, const SessionParams ¶ms)
struct RenderScheduler::@161253332237067242016063160144242156123242025211 state_
bool is_background() const
void report_volume_guiding_denoise_time(const RenderWork &render_work, const double time)
bool volume_guiding_denoise
struct RenderWork::@062144024112073257370032340252251130221344035014 tile
struct RenderWork::@045110325327334210271225251376000202010073303033 adaptive_sampling
struct RenderWork::@103345022157251202112140335355011252273171271005 path_trace
struct RenderWork::@310313166116170111017300246342343006316141322247 display
struct RenderWork::@026114172320136364120000247117121135046160342264 cryptomatte
struct RenderWork::@075102241252202025353112266176333317356231366323 full
float denoised_resolution_divider
bool has_multiple_tiles() const
CCL_NAMESPACE_BEGIN const char * denoiserTypeToHumanReadable(DenoiserType type)
@ DENOISER_PASS_ROUGHNESS
@ DENOISER_PASS_SPECULAR_ALBEDO
@ DENOISER_PASS_BACKWARD_MOTION
@ DENOISER_PASS_SPECULAR_MOTION
#define CCL_NAMESPACE_END
ccl_device_inline int ceil_to_int(const float f)
ccl_device_inline uint next_power_of_two(const uint x)
int calculate_resolution_divider_for_resolution(int width, int height, const int resolution)
int calculate_resolution_for_divider(const int width, const int height, const int resolution_divider)
static double approximate_final_time(const RenderWork &render_work, const double time)
static uint round_num_samples_to_power_of_2(const uint num_samples)
string string_from_bool(bool var)
string to_string(const char *str)
CCL_NAMESPACE_BEGIN string string_printf(const char *format,...)
CCL_NAMESPACE_BEGIN double time_dt()
ccl_device_inline bool is_power_of_two(const size_t x)