Differential D2214 Diff 7897 intern/cycles/util/util_progress.h

Changeset View

Standalone View

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;		pixel_samples = 0;
sample = 0;		total_pixel_samples = 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();		pixel_samples = progress.pixel_samples;
		total_pixel_samples = progress.total_pixel_samples;
		current_tile_sample = progress.get_current_sample();

return *this;		return *this;
}		}

void reset()		void reset()
{		{
tile = 0;		pixel_samples = 0;
sample = 0;		total_pixel_samples = 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 Lines	public:
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;		thread_scoped_lock lock(progress_mutex);
render_time_ = (render_time > 0.0)? render_time: 0.0;
		pixel_samples = 0;
		current_tile_sample = 0;
		finished_tiles = 0;
}		}

void reset_sample()		void set_total_pixel_samples(uint64_t total_pixel_samples_)
{		{
thread_scoped_lock lock(progress_mutex);		thread_scoped_lock lock(progress_mutex);

sample = 0;		total_pixel_samples = total_pixel_samples_;
		}

		float get_progress()
		{
		if(total_pixel_samples > 0) {
		return ((float) pixel_samples) / total_pixel_samples;
		}
		return 0.0f;
}		}

void increment_sample()		void add_samples(uint64_t pixel_samples_, int tile_sample)
{		{
thread_scoped_lock lock(progress_mutex);		thread_scoped_lock lock(progress_mutex);

sample++;		pixel_samples += pixel_samples_;
		current_tile_sample = tile_sample;
}		}

void increment_sample_update()		void add_samples_update(uint64_t pixel_samples_, int tile_sample)
{		{
increment_sample();		add_samples(pixel_samples_, tile_sample);
set_update();		set_update();
}		}

int get_sample()		void add_finished_tile()
		{
		thread_scoped_lock lock(progress_mutex);

		finished_tiles++;
		}

		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_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 Lines	public:
}		}

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 */		/* pixel_samples counts how many samples have been rendered over all pixel, 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.
		*
		* total_pixel_samples is the total amount of pixel samples that will be rendered. */
		uint64_t pixel_samples, 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