Page MenuHome
Differential D2214 Diff 7396 intern/cycles/util/util_progress.h

Changeset View

Standalone View

View Options

intern/cycles/util/util_progress.h

Show All 28 Lines
#include "util_thread.h" #include "util_thread.h"
CCL_NAMESPACE_BEGIN CCL_NAMESPACE_BEGIN
class Progress { class Progress {
public: public:
Progress() Progress()
{ {
tile = 0; total_pixel_samples = 0;
sample = 0; current_tile_sample = 0;
finished_tiles = 0;
start_time = time_dt(); start_time = time_dt();
total_time = 0.0; render_start_time = time_dt();
render_time = 0.0;
tile_time = 0.0;
status = "Initializing"; status = "Initializing";
substatus = ""; substatus = "";
sync_status = ""; sync_status = "";
sync_substatus = ""; sync_substatus = "";
update_cb = function_null; update_cb = function_null;
cancel = false; cancel = false;
cancel_message = ""; cancel_message = "";
error = false; error = false;
error_message = ""; error_message = "";
cancel_cb = function_null; cancel_cb = function_null;
} }
Progress(Progress& progress) Progress(Progress& progress)
{ {
*this = progress; *this = progress;
} }
Progress& operator=(Progress& progress) Progress& operator=(Progress& progress)
{ {
thread_scoped_lock lock(progress.progress_mutex); thread_scoped_lock lock(progress.progress_mutex);
progress.get_status(status, substatus); progress.get_status(status, substatus);
progress.get_tile(tile, total_time, render_time, tile_time);
sample = progress.get_sample(); total_pixel_samples = progress.get_pixel_samples();
current_tile_sample = progress.get_current_sample();
return *this; return *this;
} }
void reset() void reset()
{ {
tile = 0; total_pixel_samples = 0;
sample = 0; current_tile_sample = 0;
finished_tiles = 0;
start_time = time_dt(); start_time = time_dt();
render_start_time = time_dt(); render_start_time = time_dt();
total_time = 0.0;
render_time = 0.0;
tile_time = 0.0;
status = "Initializing"; status = "Initializing";
substatus = ""; substatus = "";
sync_status = ""; sync_status = "";
sync_substatus = ""; sync_substatus = "";
cancel = false; cancel = false;
cancel_message = ""; cancel_message = "";
error = false; error = false;
error_message = ""; error_message = "";
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Linespublic:
string get_error_message() string get_error_message()
{ {
thread_scoped_lock lock(progress_mutex); thread_scoped_lock lock(progress_mutex);
return error_message; return error_message;
} }
/* tile and timing information */ /* tile and timing information */
void set_start_time(double start_time_) void set_start_time()
{ {
thread_scoped_lock lock(progress_mutex); thread_scoped_lock lock(progress_mutex);
start_time = start_time_; start_time = time_dt();
} }
void set_render_start_time(double render_start_time_) void set_render_start_time()
{ {
thread_scoped_lock lock(progress_mutex); thread_scoped_lock lock(progress_mutex);
render_start_time = render_start_time_; render_start_time = time_dt();
} }
void set_tile(int tile_, double tile_time_) void add_skip_time(const scoped_timer &start_timer, bool only_render)
{ {
thread_scoped_lock lock(progress_mutex); double skip_time = time_dt() - start_timer.get_start();
tile = tile_; render_start_time += skip_time;
total_time = time_dt() - start_time; if(!only_render) {
render_time = time_dt() - render_start_time; start_time += skip_time;
tile_time = tile_time_; }
} }
void get_tile(int& tile_, double& total_time_, double& render_time_, double& tile_time_) void get_time(double& total_time_, double& render_time_)
{ {
thread_scoped_lock lock(progress_mutex); thread_scoped_lock lock(progress_mutex);
tile_ = tile; total_time_ = time_dt() - start_time;
total_time_ = (total_time > 0.0)? total_time: 0.0; render_time_ = time_dt() - render_start_time;
render_time_ = (render_time > 0.0)? render_time: 0.0;
tile_time_ = tile_time;
} }
void get_time(double& total_time_, double& render_time_) void reset_sample()
{ {
total_time_ = (total_time > 0.0)? total_time: 0.0; total_pixel_samples = 0;
render_time_ = (render_time > 0.0)? render_time: 0.0; current_tile_sample = 0;
finished_tiles = 0;
} }
void reset_sample() void add_samples(long pixel_samples, int tile_sample)
{ {
thread_scoped_lock lock(progress_mutex); thread_scoped_lock lock(progress_mutex);
sample = 0; total_pixel_samples += pixel_samples;
current_tile_sample = tile_sample;
} }
void increment_sample() void add_samples_update(long pixel_samples, int tile_sample)
{
add_samples(pixel_samples, tile_sample);
set_update();
}
void add_finished_tile()
{ {
thread_scoped_lock lock(progress_mutex); thread_scoped_lock lock(progress_mutex);
sample++; finished_tiles++;
} }
void increment_sample_update() long get_pixel_samples()
{ {
increment_sample(); return total_pixel_samples;
set_update(); }
int get_current_sample()
{
/* Note that the value here always belongs to the last tile that updated,
* so it's only useful if there is only one active tile. */
return current_tile_sample;
} }
int get_sample() int get_finished_tiles()
{ {
return sample; return finished_tiles;
} }
/* status messages */ /* status messages */
void set_status(const string& status_, const string& substatus_ = "") void set_status(const string& status_, const string& substatus_ = "")
{ {
{ {
thread_scoped_lock lock(progress_mutex); thread_scoped_lock lock(progress_mutex);
status = status_; status = status_;
substatus = substatus_; substatus = substatus_;
total_time = time_dt() - start_time;
render_time = time_dt() - render_start_time;
} }
set_update(); set_update();
} }
void set_substatus(const string& substatus_) void set_substatus(const string& substatus_)
{ {
{ {
thread_scoped_lock lock(progress_mutex); thread_scoped_lock lock(progress_mutex);
substatus = substatus_; substatus = substatus_;
total_time = time_dt() - start_time;
render_time = time_dt() - render_start_time;
} }
set_update(); set_update();
} }
void set_sync_status(const string& status_, const string& substatus_ = "") void set_sync_status(const string& status_, const string& substatus_ = "")
{ {
{ {
thread_scoped_lock lock(progress_mutex); thread_scoped_lock lock(progress_mutex);
sync_status = status_; sync_status = status_;
sync_substatus = substatus_; sync_substatus = substatus_;
total_time = time_dt() - start_time;
render_time = time_dt() - render_start_time;
} }
set_update(); set_update();
} }
void set_sync_substatus(const string& substatus_) void set_sync_substatus(const string& substatus_)
{ {
{ {
thread_scoped_lock lock(progress_mutex); thread_scoped_lock lock(progress_mutex);
sync_substatus = substatus_; sync_substatus = substatus_;
total_time = time_dt() - start_time;
render_time = time_dt() - render_start_time;
} }
set_update(); set_update();
} }
void get_status(string& status_, string& substatus_) void get_status(string& status_, string& substatus_)
{ {
thread_scoped_lock lock(progress_mutex); thread_scoped_lock lock(progress_mutex);
Show All 24 Linespublic:
} }
protected: protected:
thread_mutex progress_mutex; thread_mutex progress_mutex;
thread_mutex update_mutex; thread_mutex update_mutex;
function<void(void)> update_cb; function<void(void)> update_cb;
function<void(void)> cancel_cb; function<void(void)> cancel_cb;
int tile; /* counter for rendered tiles */ /* Counts how many samples have been rendered in total, not just per pixel.
int sample; /* counter of rendered samples, global for all tiles */ * This makes the progress estimate more accurate when tiles with different sizes are used. */
long total_pixel_samples;
/* Stores the current sample count of the last tile that called the update function.
* It's used to display the sample count if only one tile is active. */
int current_tile_sample;
/* Stores the number of tiles that's already finished.
* Used to determine whether all but the last tile are finished rendering, in which case the current_tile_sample is displayed. */
int finished_tiles;
double start_time, render_start_time; double start_time, render_start_time;
double total_time, render_time;
double tile_time;
string status; string status;
string substatus; string substatus;
string sync_status; string sync_status;
string sync_substatus; string sync_substatus;
volatile bool cancel; volatile bool cancel;
Show All 10 Lines