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.

8 files changed, 104 insertions, 2 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;
 }