Cycles: persistent images option

This option enables keeping loaded images in the memory in-between
of rendering.

Implemented by keeping render engine alive for until Render structure
is being freed.

Cycles will free all data when render finishes, optionally keeping
image manager untouched. All shaders, meshes, objects will be
re-allocated next time rendering happens.

Cycles cession and scene will be re-created from scratch if render/
scene parameters were changed.

This will also allow to keep compiled OSL shaders in memory without
need to re-compile them again.

P.S. Performance panel could be cleaned up a bit, not so much happy
     with it's vertical alignment currently but not sure how to make
     it look better.

 P.P.S. Currently the only way to free images from the device is to
       disable Persistent Images option and start rendering.

13 files changed, 202 insertions, 34 deletions

diff --git a/intern/cycles/blender/addon/__init__.py b/intern/cycles/blender/addon/__init__.py
index 16697c08b2b..0fad2ac5618 100644
--- a/intern/cycles/blender/addon/__init__.py
+++ b/intern/cycles/blender/addon/__init__.py
@@ -48,7 +48,11 @@ class CyclesRender(bpy.types.RenderEngine):
 
     # final render
     def update(self, data, scene):
-        engine.create(self, data, scene)
+        if not self.session:
+            engine.create(self, data, scene)
+        else:
+            engine.reset(self, data, scene)
+
         engine.update(self, data, scene)
 
     def render(self, scene):
diff --git a/intern/cycles/blender/addon/engine.py b/intern/cycles/blender/addon/engine.py
index e4f80cb4d5d..ca5cbee9325 100644
--- a/intern/cycles/blender/addon/engine.py
+++ b/intern/cycles/blender/addon/engine.py
@@ -61,6 +61,13 @@ def render(engine):
         _cycles.render(engine.session)
 
 
+def reset(engine, data, scene):
+    import _cycles
+    data = data.as_pointer()
+    scene = scene.as_pointer()
+    _cycles.reset(engine.session, data, scene)
+
+
 def update(engine, data, scene):
     import _cycles
     _cycles.sync(engine.session)
diff --git a/intern/cycles/blender/addon/properties.py b/intern/cycles/blender/addon/properties.py
index 0b8ca6e0fbe..32b07f47ba8 100644
--- a/intern/cycles/blender/addon/properties.py
+++ b/intern/cycles/blender/addon/properties.py
@@ -297,6 +297,12 @@ class CyclesRenderSettings(bpy.types.PropertyGroup):
                 default=False,
                 )
 
+        cls.use_persistent_images = BoolProperty(
+                name="Persistent Images",
+                description="Keep images loaded on the device so they could be reused by next render",
+                default=False,
+                )
+
     @classmethod
     def unregister(cls):
         del bpy.types.Scene.cycles
diff --git a/intern/cycles/blender/addon/ui.py b/intern/cycles/blender/addon/ui.py
index 9cc58e65bef..d8d8c11baa6 100644
--- a/intern/cycles/blender/addon/ui.py
+++ b/intern/cycles/blender/addon/ui.py
@@ -216,6 +216,10 @@ class CyclesRender_PT_performance(CyclesButtonsPanel, Panel):
         sub.label(text="Viewport:")
         sub.prop(cscene, "preview_start_resolution")
 
+        sub = col.column(align=True)
+        sub.label(text="Final Render:")
+        sub.prop(cscene, "use_persistent_images")
+
 
 class CyclesRender_PT_layers(CyclesButtonsPanel, Panel):
     bl_label = "Layers"
diff --git a/intern/cycles/blender/blender_python.cpp b/intern/cycles/blender/blender_python.cpp
index 3b78651a6a1..fbc88f1056f 100644
--- a/intern/cycles/blender/blender_python.cpp
+++ b/intern/cycles/blender/blender_python.cpp
@@ -146,6 +146,32 @@ static PyObject *draw_func(PyObject *self, PyObject *args)
 	Py_RETURN_NONE;
 }
 
+static PyObject *reset_func(PyObject *self, PyObject *args)
+{
+	PyObject *pysession, *pydata, *pyscene;
+
+	if(!PyArg_ParseTuple(args, "OOO", &pysession, &pydata, &pyscene))
+		return NULL;
+
+	BlenderSession *session = (BlenderSession*)PyLong_AsVoidPtr(pysession);
+
+	PointerRNA dataptr;
+	RNA_id_pointer_create((ID*)PyLong_AsVoidPtr(pydata), &dataptr);
+	BL::BlendData b_data(dataptr);
+
+	PointerRNA sceneptr;
+	RNA_id_pointer_create((ID*)PyLong_AsVoidPtr(pyscene), &sceneptr);
+	BL::Scene b_scene(sceneptr);
+
+	Py_BEGIN_ALLOW_THREADS
+
+	session->reset_session(b_data, b_scene);
+
+	Py_END_ALLOW_THREADS
+
+	Py_RETURN_NONE;
+}
+
 static PyObject *sync_func(PyObject *self, PyObject *value)
 {
 	Py_BEGIN_ALLOW_THREADS
@@ -352,6 +378,7 @@ static PyMethodDef methods[] = {
 	{"render", render_func, METH_O, ""},
 	{"draw", draw_func, METH_VARARGS, ""},
 	{"sync", sync_func, METH_O, ""},
+	{"reset", reset_func, METH_VARARGS, ""},
 #ifdef WITH_OSL
 	{"osl_update_node", osl_update_node_func, METH_VARARGS, ""},
 	{"osl_compile", osl_compile_func, METH_VARARGS, ""},
diff --git a/intern/cycles/blender/blender_session.cpp b/intern/cycles/blender/blender_session.cpp
index 01bd5f013e3..fcc3d89f5d8 100644
--- a/intern/cycles/blender/blender_session.cpp
+++ b/intern/cycles/blender/blender_session.cpp
@@ -109,9 +109,50 @@ void BlenderSession::create_session()
 	session->reset(buffer_params, session_params.samples);
 }
 
+void BlenderSession::reset_session(BL::BlendData b_data_, BL::Scene b_scene_)
+{
+	b_data = b_data_;
+	b_scene = b_scene_;
+
+	SceneParams scene_params = BlenderSync::get_scene_params(b_scene, background);
+	SessionParams session_params = BlenderSync::get_session_params(b_engine, b_userpref, b_scene, background);
+
+	if(scene->params.modified(scene_params) ||
+	   session->params.modified(session_params))
+	{
+		/* if scene or session parameters changed, it's easier to simply re-create
+		 * them rather than trying to distinguish which settings need to be updated
+		 */
+
+		delete session;
+
+		create_session();
+
+		return;
+	}
+
+	session->progress.reset();
+	scene->reset();
+
+	/* peak memory usage should show current render peak, not peak for all renders
+	 * made by this render session
+	 */
+	session->stats.mem_peak = session->stats.mem_used;
+
+	/* sync object should be re-created */
+	sync = new BlenderSync(b_engine, b_data, b_scene, scene, !background, session->progress);
+	sync->sync_data(b_v3d, b_engine.camera_override());
+	sync->sync_camera(b_engine.camera_override(), width, height);
+
+	BufferParams buffer_params = BlenderSync::get_buffer_params(b_scene, PointerRNA_NULL, PointerRNA_NULL, scene->camera, width, height);
+	session->reset(buffer_params, session_params.samples);
+}
+
 void BlenderSession::free_session()
 {
-	delete sync;
+	if(sync)
+		delete sync;
+
 	delete session;
 }
 
@@ -304,6 +345,15 @@ void BlenderSession::render()
 	/* clear callback */
 	session->write_render_tile_cb = NULL;
 	session->update_render_tile_cb = NULL;
+
+	/* free all memory used (host and device), so we wouldn't leave render
+	 * engine with extra memory allocated
+	 */
+
+	session->device_free();
+
+	delete sync;
+	sync = NULL;
 }
 
 void BlenderSession::do_write_update_render_result(BL::RenderResult b_rr, BL::RenderLayer b_rlay, RenderTile& rtile, bool do_update_only)
diff --git a/intern/cycles/blender/blender_session.h b/intern/cycles/blender/blender_session.h
index d52e0103bbf..7f3973ae873 100644
--- a/intern/cycles/blender/blender_session.h
+++ b/intern/cycles/blender/blender_session.h
@@ -46,6 +46,8 @@ public:
 	void create_session();
 	void free_session();
 
+	void reset_session(BL::BlendData b_data, BL::Scene b_scene);
+
 	/* offline render */
 	void render();
 
diff --git a/intern/cycles/blender/blender_sync.cpp b/intern/cycles/blender/blender_sync.cpp
index 024cb1685d0..eacfbdadba0 100644
--- a/intern/cycles/blender/blender_sync.cpp
+++ b/intern/cycles/blender/blender_sync.cpp
@@ -294,6 +294,8 @@ SceneParams BlenderSync::get_scene_params(BL::Scene b_scene, bool background)
 	params.use_bvh_spatial_split = RNA_boolean_get(&cscene, "debug_use_spatial_splits");
 	params.use_bvh_cache = (background)? RNA_boolean_get(&cscene, "use_cache"): false;
 
+	params.persistent_images = (background)? RNA_boolean_get(&cscene, "use_persistent_images"): false;
+
 	return params;
 }
 
diff --git a/intern/cycles/render/scene.cpp b/intern/cycles/render/scene.cpp
index 15031b9500c..a2febc31f60 100644
--- a/intern/cycles/render/scene.cpp
+++ b/intern/cycles/render/scene.cpp
@@ -62,33 +62,11 @@ Scene::Scene(const SceneParams& params_, const DeviceInfo& device_info_)
 
 Scene::~Scene()
 {
-	if(device) camera->device_free(device, &dscene);
-	delete camera;
-
-	if(device) filter->device_free(device, &dscene);
-	delete filter;
-
-	if(device) film->device_free(device, &dscene);
-	delete film;
-
-	if(device) background->device_free(device, &dscene);
-	delete background;
-
-	if(device) mesh_manager->device_free(device, &dscene);
-	delete mesh_manager;
-
-	if(device) object_manager->device_free(device, &dscene);
-	delete object_manager;
-
-	if(device) integrator->device_free(device, &dscene);
-	delete integrator;
-
-	if(device) shader_manager->device_free(device, &dscene);
-	delete shader_manager;
-
-	if(device) light_manager->device_free(device, &dscene);
-	delete light_manager;
+	free_memory(true);
+}
 
+void Scene::free_memory(bool final)
+{
 	foreach(Shader *s, shaders)
 		delete s;
 	foreach(Mesh *m, meshes)
@@ -100,11 +78,44 @@ Scene::~Scene()
 	foreach(ParticleSystem *p, particle_systems)
 		delete p;
 
-	if(device) image_manager->device_free(device, &dscene);
-	delete image_manager;
-
-	if(device) particle_system_manager->device_free(device, &dscene);
-	delete particle_system_manager;
+	if(device) {
+		camera->device_free(device, &dscene);
+		filter->device_free(device, &dscene);
+		film->device_free(device, &dscene);
+		background->device_free(device, &dscene);
+		integrator->device_free(device, &dscene);
+
+		object_manager->device_free(device, &dscene);
+		mesh_manager->device_free(device, &dscene);
+		shader_manager->device_free(device, &dscene);
+		light_manager->device_free(device, &dscene);
+
+		particle_system_manager->device_free(device, &dscene);
+
+		if(!params.persistent_images || final)
+			image_manager->device_free(device, &dscene);
+	}
+
+	if(final) {
+		delete filter;
+		delete camera;
+		delete film;
+		delete background;
+		delete integrator;
+		delete object_manager;
+		delete mesh_manager;
+		delete shader_manager;
+		delete light_manager;
+		delete particle_system_manager;
+		delete image_manager;
+	}
+	else {
+		shaders.clear();
+		meshes.clear();
+		objects.clear();
+		lights.clear();
+		particle_systems.clear();
+	}
 }
 
 void Scene::device_update(Device *device_, Progress& progress)
@@ -229,5 +240,22 @@ bool Scene::need_reset()
 		|| particle_system_manager->need_update);
 }
 
+void Scene::reset()
+{
+	shader_manager->add_default(this);
+
+	/* ensure all objects are updated */
+	camera->tag_update();
+	filter->tag_update(this);
+	film->tag_update(this);
+	background->tag_update(this);
+	integrator->tag_update(this);
+}
+
+void Scene::device_free()
+{
+	free_memory(false);
+}
+
 CCL_NAMESPACE_END
 
diff --git a/intern/cycles/render/scene.h b/intern/cycles/render/scene.h
index bd45c1c04e6..92ef692b4b9 100644
--- a/intern/cycles/render/scene.h
+++ b/intern/cycles/render/scene.h
@@ -120,6 +120,7 @@ public:
 	bool use_bvh_cache;
 	bool use_bvh_spatial_split;
 	bool use_qbvh;
+	bool persistent_images;
 
 	SceneParams()
 	{
@@ -139,7 +140,8 @@ public:
 		&& bvh_type == params.bvh_type
 		&& use_bvh_cache == params.use_bvh_cache
 		&& use_bvh_spatial_split == params.use_bvh_spatial_split
-		&& use_qbvh == params.use_qbvh); }
+		&& use_qbvh == params.use_qbvh
+		&& persistent_images == params.persistent_images); }
 };
 
 /* Scene */
@@ -198,6 +200,12 @@ public:
 
 	bool need_update();
 	bool need_reset();
+
+	void reset();
+	void device_free();
+
+protected:
+	void free_memory(bool final);
 };
 
 CCL_NAMESPACE_END
diff --git a/intern/cycles/render/session.cpp b/intern/cycles/render/session.cpp
index 7f6b43c1e00..41212c2db84 100644
--- a/intern/cycles/render/session.cpp
+++ b/intern/cycles/render/session.cpp
@@ -842,4 +842,18 @@ bool Session::update_progressive_refine(bool cancel)
 	return write;
 }
 
+void Session::device_free()
+{
+	scene->device_free();
+
+	foreach(RenderBuffers *buffers, tile_buffers)
+		delete buffers;
+
+	tile_buffers.clear();
+
+	/* used from background render only, so no need to
+	 * re-create render/display buffers here
+	 */
+}
+
 CCL_NAMESPACE_END
diff --git a/intern/cycles/render/session.h b/intern/cycles/render/session.h
index 7bb0cd1ae01..cfc1502287d 100644
--- a/intern/cycles/render/session.h
+++ b/intern/cycles/render/session.h
@@ -130,6 +130,7 @@ public:
 	void set_samples(int samples);
 	void set_pause(bool pause);
 
+	void device_free();
 protected:
 	struct DelayedReset {
 		thread_mutex mutex;
diff --git a/intern/cycles/util/util_progress.h b/intern/cycles/util/util_progress.h
index c97379d8776..03e25d4d132 100644
--- a/intern/cycles/util/util_progress.h
+++ b/intern/cycles/util/util_progress.h
@@ -68,6 +68,21 @@ public:
 		return *this;
 	}
 
+	void reset()
+	{
+		tile = 0;
+		sample = 0;
+		start_time = time_dt();
+		total_time = 0.0f;
+		tile_time = 0.0f;
+		status = "Initializing";
+		substatus = "";
+		sync_status = "";
+		sync_substatus = "";
+		cancel = false;
+		cancel_message = "";
+	}
+
 	/* cancel */
 	void set_cancel(const string& cancel_message_)
 	{