Code refactor: move more memory allocation logic into device API.

* Remove tex_* and pixels_* functions, replace by mem_*.
* Add MEM_TEXTURE and MEM_PIXELS as memory types recognized by devices.
* No longer create device_memory and call mem_* directly, always go
  through device_only_memory, device_vector and device_pixels.

15 files changed, 264 insertions, 340 deletions

diff --git a/intern/cycles/render/bake.cpp b/intern/cycles/render/bake.cpp
index 66615bf336c..99f68b6aa00 100644
--- a/intern/cycles/render/bake.cpp
+++ b/intern/cycles/render/bake.cpp
@@ -151,7 +151,7 @@ bool BakeManager::bake(Device *device, DeviceScene *dscene, Scene *scene, Progre
 
 		/* setup input for device task */
 		device_vector<uint4> d_input(device, "bake_input", MEM_READ_ONLY);
-		uint4 *d_input_data = d_input.resize(shader_size * 2);
+		uint4 *d_input_data = d_input.alloc(shader_size * 2);
 		size_t d_input_size = 0;
 
 		for(size_t i = shader_offset; i < (shader_offset + shader_size); i++) {
@@ -166,16 +166,13 @@ bool BakeManager::bake(Device *device, DeviceScene *dscene, Scene *scene, Progre
 
 		/* run device task */
 		device_vector<float4> d_output(device, "bake_output", MEM_READ_WRITE);
-		d_output.resize(shader_size);
+		d_output.alloc(shader_size);
+		d_output.zero_to_device();
+		d_input.copy_to_device();
 
 		/* needs to be up to data for attribute access */
 		device->const_copy_to("__data", &dscene->data, sizeof(dscene->data));
 
-		device->mem_alloc(d_input);
-		device->mem_copy_to(d_input);
-		device->mem_alloc(d_output);
-		device->mem_zero(d_output);
-
 		DeviceTask task(DeviceTask::SHADER);
 		task.shader_input = d_input.device_pointer;
 		task.shader_output = d_output.device_pointer;
@@ -192,15 +189,14 @@ bool BakeManager::bake(Device *device, DeviceScene *dscene, Scene *scene, Progre
 		device->task_wait();
 
 		if(progress.get_cancel()) {
-			device->mem_free(d_input);
-			device->mem_free(d_output);
+			d_input.free();
+			d_output.free();
 			m_is_baking = false;
 			return false;
 		}
 
-		device->mem_copy_from(d_output, 0, 1, d_output.size(), sizeof(float4));
-		device->mem_free(d_input);
-		device->mem_free(d_output);
+		d_output.copy_from_device(0, 1, d_output.size());
+		d_input.free();
 
 		/* read result */
 		int k = 0;
@@ -218,6 +214,8 @@ bool BakeManager::bake(Device *device, DeviceScene *dscene, Scene *scene, Progre
 				}
 			}
 		}
+
+		d_output.free();
 	}
 
 	m_is_baking = false;
diff --git a/intern/cycles/render/buffers.cpp b/intern/cycles/render/buffers.cpp
index 2342dd52d86..01f853dda71 100644
--- a/intern/cycles/render/buffers.cpp
+++ b/intern/cycles/render/buffers.cpp
@@ -115,54 +115,35 @@ RenderTile::RenderTile()
 /* Render Buffers */
 
 RenderBuffers::RenderBuffers(Device *device)
-: buffer(device, "RenderBuffers", MEM_READ_WRITE),
-  device(device)
+: buffer(device, "RenderBuffers", MEM_READ_WRITE)
 {
 }
 
 RenderBuffers::~RenderBuffers()
 {
-	device_free();
+	buffer.free();
 }
 
-void RenderBuffers::device_free()
-{
-	if(buffer.device_pointer) {
-		device->mem_free(buffer);
-		buffer.clear();
-	}
-}
-
-void RenderBuffers::reset(Device *device, BufferParams& params_)
+void RenderBuffers::reset(BufferParams& params_)
 {
 	params = params_;
 
-	/* free existing buffers */
-	device_free();
-
-	/* allocate buffer */
-	buffer.resize(params.width*params.height*params.get_passes_size());
-	device->mem_alloc(buffer);
-	device->mem_zero(buffer);
+	/* re-allocate buffer */
+	buffer.alloc(params.width*params.height*params.get_passes_size());
+	buffer.zero_to_device();
 }
 
-void RenderBuffers::zero(Device *device)
+void RenderBuffers::zero()
 {
-	if(buffer.device_pointer) {
-		device->mem_zero(buffer);
-	}
+	buffer.zero_to_device();
 }
 
-bool RenderBuffers::copy_from_device(Device *from_device)
+bool RenderBuffers::copy_from_device()
 {
 	if(!buffer.device_pointer)
 		return false;
 
-	if(!from_device) {
-		from_device = device;
-	}
-
-	from_device->mem_copy_from(buffer, 0, params.width, params.height, params.get_passes_size()*sizeof(float));
+	buffer.copy_from_device(0, params.width * params.get_passes_size(), params.height);
 
 	return true;
 }
@@ -402,47 +383,30 @@ DisplayBuffer::DisplayBuffer(Device *device, bool linear)
   draw_height(0),
   transparent(true), /* todo: determine from background */
   half_float(linear),
-  rgba_byte(device, "display buffer byte", MEM_WRITE_ONLY),
-  rgba_half(device, "display buffer half", MEM_WRITE_ONLY),
-  device(device)
+  rgba_byte(device, "display buffer byte"),
+  rgba_half(device, "display buffer half")
 {
 }
 
 DisplayBuffer::~DisplayBuffer()
 {
-	device_free();
-}
-
-void DisplayBuffer::device_free()
-{
-	if(rgba_byte.device_pointer) {
-		device->pixels_free(rgba_byte);
-		rgba_byte.clear();
-	}
-	if(rgba_half.device_pointer) {
-		device->pixels_free(rgba_half);
-		rgba_half.clear();
-	}
+	rgba_byte.free();
+	rgba_half.free();
 }
 
-void DisplayBuffer::reset(Device *device, BufferParams& params_)
+void DisplayBuffer::reset(BufferParams& params_)
 {
 	draw_width = 0;
 	draw_height = 0;
 
 	params = params_;
 
-	/* free existing buffers */
-	device_free();
-
 	/* allocate display pixels */
 	if(half_float) {
-		rgba_half.resize(params.width, params.height);
-		device->pixels_alloc(rgba_half);
+		rgba_half.alloc_to_device(params.width, params.height);
 	}
 	else {
-		rgba_byte.resize(params.width, params.height);
-		device->pixels_alloc(rgba_byte);
+		rgba_byte.alloc_to_device(params.width, params.height);
 	}
 }
 
@@ -457,7 +421,8 @@ void DisplayBuffer::draw_set(int width, int height)
 void DisplayBuffer::draw(Device *device, const DeviceDrawParams& draw_params)
 {
 	if(draw_width != 0 && draw_height != 0) {
-		device_memory& rgba = rgba_data();
+		device_memory& rgba = (half_float)? (device_memory&)rgba_half:
+		                                    (device_memory&)rgba_byte;
 
 		device->draw_pixels(rgba, 0, draw_width, draw_height, params.full_x, params.full_y, params.width, params.height, transparent, draw_params);
 	}
@@ -468,7 +433,7 @@ bool DisplayBuffer::draw_ready()
 	return (draw_width != 0 && draw_height != 0);
 }
 
-void DisplayBuffer::write(Device *device, const string& filename)
+void DisplayBuffer::write(const string& filename)
 {
 	int w = draw_width;
 	int h = draw_height;
@@ -480,21 +445,19 @@ void DisplayBuffer::write(Device *device, const string& filename)
 		return;
 
 	/* read buffer from device */
-	device_memory& rgba = rgba_data();
-	device->pixels_copy_from(rgba, 0, w, h);
+	uchar4 *pixels = rgba_byte.copy_from_device(0, w, h);
 
 	/* write image */
 	ImageOutput *out = ImageOutput::create(filename);
 	ImageSpec spec(w, h, 4, TypeDesc::UINT8);
-	int scanlinesize = w*4*sizeof(uchar);
 
 	out->open(filename, spec);
 
 	/* conversion for different top/bottom convention */
 	out->write_image(TypeDesc::UINT8,
-		(uchar*)rgba.data_pointer + (h-1)*scanlinesize,
+		(uchar*)(pixels + (h-1)*w),
 		AutoStride,
-		-scanlinesize,
+		-w*sizeof(uchar4),
 		AutoStride);
 
 	out->close();
@@ -502,13 +465,5 @@ void DisplayBuffer::write(Device *device, const string& filename)
 	delete out;
 }
 
-device_memory& DisplayBuffer::rgba_data()
-{
-	if(half_float)
-		return rgba_half;
-	else
-		return rgba_byte;
-}
-
 CCL_NAMESPACE_END
 
diff --git a/intern/cycles/render/buffers.h b/intern/cycles/render/buffers.h
index 2780fc8a68d..8563d6674ec 100644
--- a/intern/cycles/render/buffers.h
+++ b/intern/cycles/render/buffers.h
@@ -75,20 +75,15 @@ public:
 	/* float buffer */
 	device_vector<float> buffer;
 
-	Device *device;
-
 	explicit RenderBuffers(Device *device);
 	~RenderBuffers();
 
-	void reset(Device *device, BufferParams& params);
-	void zero(Device *device);
+	void reset(BufferParams& params);
+	void zero();
 
-	bool copy_from_device(Device *from_device = NULL);
+	bool copy_from_device();
 	bool get_pass_rect(PassType type, float exposure, int sample, int components, float *pixels);
 	bool get_denoising_pass_rect(int offset, float exposure, int sample, int components, float *pixels);
-
-protected:
-	void device_free();
 };
 
 /* Display Buffer
@@ -109,25 +104,18 @@ public:
 	/* use half float? */
 	bool half_float;
 	/* byte buffer for converted result */
-	device_vector<uchar4> rgba_byte;
-	device_vector<half4> rgba_half;
+	device_pixels<uchar4> rgba_byte;
+	device_pixels<half4> rgba_half;
 
 	DisplayBuffer(Device *device, bool linear = false);
 	~DisplayBuffer();
 
-	void reset(Device *device, BufferParams& params);
-	void write(Device *device, const string& filename);
+	void reset(BufferParams& params);
+	void write(const string& filename);
 
 	void draw_set(int width, int height);
 	void draw(Device *device, const DeviceDrawParams& draw_params);
 	bool draw_ready();
-
-	device_memory& rgba_data();
-
-protected:
-	void device_free();
-
-	Device *device;
 };
 
 /* Render Tile
diff --git a/intern/cycles/render/image.cpp b/intern/cycles/render/image.cpp
index e7f5ff002b7..625901ff258 100644
--- a/intern/cycles/render/image.cpp
+++ b/intern/cycles/render/image.cpp
@@ -532,7 +532,8 @@ bool ImageManager::file_load_image(Image *img,
 		pixels = &pixels_storage[0];
 	}
 	else {
-		pixels = (StorageType*)tex_img.resize(width, height, depth);
+		thread_scoped_lock device_lock(device_mutex);
+		pixels = (StorageType*)tex_img.alloc(width, height, depth);
 	}
 	if(pixels == NULL) {
 		/* Could be that we've run out of memory. */
@@ -686,9 +687,16 @@ bool ImageManager::file_load_image(Image *img,
 		                         scale_factor,
 		                         &scaled_pixels,
 		                         &scaled_width, &scaled_height, &scaled_depth);
-		StorageType *texture_pixels = (StorageType*)tex_img.resize(scaled_width,
-		                                                           scaled_height,
-		                                                           scaled_depth);
+
+		StorageType *texture_pixels;
+
+		{
+			thread_scoped_lock device_lock(device_mutex);
+			texture_pixels = (StorageType*)tex_img.alloc(scaled_width,
+			                                             scaled_height,
+			                                             scaled_depth);
+		}
+
 		memcpy(texture_pixels,
 		       &scaled_pixels[0],
 		       scaled_pixels.size() * sizeof(StorageType));
@@ -722,14 +730,14 @@ void ImageManager::device_load_image(Device *device,
 	/* Free previous texture in slot. */
 	if(img->mem) {
 		thread_scoped_lock device_lock(device_mutex);
-		device->tex_free(*img->mem);
 		delete img->mem;
 		img->mem = NULL;
 	}
 
 	/* Create new texture. */
 	if(type == IMAGE_DATA_TYPE_FLOAT4) {
-		device_vector<float4> *tex_img = new device_vector<float4>(device, name.c_str());
+		device_vector<float4> *tex_img
+			= new device_vector<float4>(device, name.c_str(), MEM_TEXTURE);
 
 		if(!file_load_image<TypeDesc::FLOAT, float>(img,
 		                                            type,
@@ -737,7 +745,7 @@ void ImageManager::device_load_image(Device *device,
 		                                            *tex_img))
 		{
 			/* on failure to load, we set a 1x1 pixels pink image */
-			float *pixels = (float*)tex_img->resize(1, 1);
+			float *pixels = (float*)tex_img->alloc(1, 1);
 
 			pixels[0] = TEX_IMAGE_MISSING_R;
 			pixels[1] = TEX_IMAGE_MISSING_G;
@@ -746,9 +754,15 @@ void ImageManager::device_load_image(Device *device,
 		}
 
 		img->mem = tex_img;
+		img->mem->interpolation = img->interpolation;
+		img->mem->extension = img->extension;
+
+		thread_scoped_lock device_lock(device_mutex);
+		tex_img->copy_to_device();
 	}
 	else if(type == IMAGE_DATA_TYPE_FLOAT) {
-		device_vector<float> *tex_img = new device_vector<float>(device, name.c_str());
+		device_vector<float> *tex_img
+			= new device_vector<float>(device, name.c_str(), MEM_TEXTURE);
 
 		if(!file_load_image<TypeDesc::FLOAT, float>(img,
 		                                            type,
@@ -756,15 +770,21 @@ void ImageManager::device_load_image(Device *device,
 		                                            *tex_img))
 		{
 			/* on failure to load, we set a 1x1 pixels pink image */
-			float *pixels = (float*)tex_img->resize(1, 1);
+			float *pixels = (float*)tex_img->alloc(1, 1);
 
 			pixels[0] = TEX_IMAGE_MISSING_R;
 		}
 
 		img->mem = tex_img;
+		img->mem->interpolation = img->interpolation;
+		img->mem->extension = img->extension;
+
+		thread_scoped_lock device_lock(device_mutex);
+		tex_img->copy_to_device();
 	}
 	else if(type == IMAGE_DATA_TYPE_BYTE4) {
-		device_vector<uchar4> *tex_img = new device_vector<uchar4>(device, name.c_str());
+		device_vector<uchar4> *tex_img
+			= new device_vector<uchar4>(device, name.c_str(), MEM_TEXTURE);
 
 		if(!file_load_image<TypeDesc::UINT8, uchar>(img,
 		                                            type,
@@ -772,7 +792,7 @@ void ImageManager::device_load_image(Device *device,
 		                                            *tex_img))
 		{
 			/* on failure to load, we set a 1x1 pixels pink image */
-			uchar *pixels = (uchar*)tex_img->resize(1, 1);
+			uchar *pixels = (uchar*)tex_img->alloc(1, 1);
 
 			pixels[0] = (TEX_IMAGE_MISSING_R * 255);
 			pixels[1] = (TEX_IMAGE_MISSING_G * 255);
@@ -781,31 +801,43 @@ void ImageManager::device_load_image(Device *device,
 		}
 
 		img->mem = tex_img;
+		img->mem->interpolation = img->interpolation;
+		img->mem->extension = img->extension;
+
+		thread_scoped_lock device_lock(device_mutex);
+		tex_img->copy_to_device();
 	}
 	else if(type == IMAGE_DATA_TYPE_BYTE) {
-		device_vector<uchar> *tex_img = new device_vector<uchar>(device, name.c_str());
+		device_vector<uchar> *tex_img
+			= new device_vector<uchar>(device, name.c_str(), MEM_TEXTURE);
 
 		if(!file_load_image<TypeDesc::UINT8, uchar>(img,
 		                                            type,
 		                                            texture_limit,
 		                                            *tex_img)) {
 			/* on failure to load, we set a 1x1 pixels pink image */
-			uchar *pixels = (uchar*)tex_img->resize(1, 1);
+			uchar *pixels = (uchar*)tex_img->alloc(1, 1);
 
 			pixels[0] = (TEX_IMAGE_MISSING_R * 255);
 		}
 
 		img->mem = tex_img;
+		img->mem->interpolation = img->interpolation;
+		img->mem->extension = img->extension;
+
+		thread_scoped_lock device_lock(device_mutex);
+		tex_img->copy_to_device();
 	}
 	else if(type == IMAGE_DATA_TYPE_HALF4) {
-		device_vector<half4> *tex_img = new device_vector<half4>(device, name.c_str());
+		device_vector<half4> *tex_img
+			= new device_vector<half4>(device, name.c_str(), MEM_TEXTURE);
 
 		if(!file_load_image<TypeDesc::HALF, half>(img,
 		                                          type,
 		                                          texture_limit,
 		                                          *tex_img)) {
 			/* on failure to load, we set a 1x1 pixels pink image */
-			half *pixels = (half*)tex_img->resize(1, 1);
+			half *pixels = (half*)tex_img->alloc(1, 1);
 
 			pixels[0] = TEX_IMAGE_MISSING_R;
 			pixels[1] = TEX_IMAGE_MISSING_G;
@@ -814,37 +846,38 @@ void ImageManager::device_load_image(Device *device,
 		}
 
 		img->mem = tex_img;
+		img->mem->interpolation = img->interpolation;
+		img->mem->extension = img->extension;
+
+		thread_scoped_lock device_lock(device_mutex);
+		tex_img->copy_to_device();
 	}
 	else if(type == IMAGE_DATA_TYPE_HALF) {
-		device_vector<half> *tex_img = new device_vector<half>(device, name.c_str());
+		device_vector<half> *tex_img
+			= new device_vector<half>(device, name.c_str(), MEM_TEXTURE);
 
 		if(!file_load_image<TypeDesc::HALF, half>(img,
 		                                          type,
 		                                          texture_limit,
 		                                          *tex_img)) {
 			/* on failure to load, we set a 1x1 pixels pink image */
-			half *pixels = (half*)tex_img->resize(1, 1);
+			half *pixels = (half*)tex_img->alloc(1, 1);
 
 			pixels[0] = TEX_IMAGE_MISSING_R;
 		}
 
 		img->mem = tex_img;
-	}
-
-	/* Copy to device. */
-	if(img->mem) {
 		img->mem->interpolation = img->interpolation;
 		img->mem->extension = img->extension;
 
 		thread_scoped_lock device_lock(device_mutex);
-		device->tex_alloc(*img->mem);
+		tex_img->copy_to_device();
 	}
 
-
 	img->need_load = false;
 }
 
-void ImageManager::device_free_image(Device *device, ImageDataType type, int slot)
+void ImageManager::device_free_image(Device *, ImageDataType type, int slot)
 {
 	Image *img = images[type][slot];
 
@@ -858,7 +891,6 @@ void ImageManager::device_free_image(Device *device, ImageDataType type, int slo
 
 		if(img->mem) {
 			thread_scoped_lock device_lock(device_mutex);
-			device->tex_free(*img->mem);
 			delete img->mem;
 		}
 
diff --git a/intern/cycles/render/integrator.cpp b/intern/cycles/render/integrator.cpp
index b128f18db08..33c3dac9e81 100644
--- a/intern/cycles/render/integrator.cpp
+++ b/intern/cycles/render/integrator.cpp
@@ -191,11 +191,11 @@ void Integrator::device_update(Device *device, DeviceScene *dscene, Scene *scene
 	int dimensions = PRNG_BASE_NUM + max_samples*PRNG_BOUNCE_NUM;
 	dimensions = min(dimensions, SOBOL_MAX_DIMENSIONS);
 
-	uint *directions = dscene->sobol_directions.resize(SOBOL_BITS*dimensions);
+	uint *directions = dscene->sobol_directions.alloc(SOBOL_BITS*dimensions);
 
 	sobol_generate_direction_vectors((uint(*)[SOBOL_BITS])directions, dimensions);
 
-	device->tex_alloc(dscene->sobol_directions);
+	dscene->sobol_directions.copy_to_device();
 
 	/* Clamping. */
 	bool use_sample_clamp = (sample_clamp_direct != 0.0f ||
@@ -208,10 +208,9 @@ void Integrator::device_update(Device *device, DeviceScene *dscene, Scene *scene
 	need_update = false;
 }
 
-void Integrator::device_free(Device *device, DeviceScene *dscene)
+void Integrator::device_free(Device *, DeviceScene *dscene)
 {
-	device->tex_free(dscene->sobol_directions);
-	dscene->sobol_directions.clear();
+	dscene->sobol_directions.free();
 }
 
 bool Integrator::modified(const Integrator& integrator)
diff --git a/intern/cycles/render/light.cpp b/intern/cycles/render/light.cpp
index 9664e1310d5..b3804f34963 100644
--- a/intern/cycles/render/light.cpp
+++ b/intern/cycles/render/light.cpp
@@ -39,7 +39,7 @@ static void shade_background_pixels(Device *device, DeviceScene *dscene, int res
 	device_vector<uint4> d_input(device, "background_input", MEM_READ_ONLY);
 	device_vector<float4> d_output(device, "background_output", MEM_WRITE_ONLY);
 
-	uint4 *d_input_data = d_input.resize(width*height);
+	uint4 *d_input_data = d_input.alloc(width*height);
 
 	for(int y = 0; y < height; y++) {
 		for(int x = 0; x < width; x++) {
@@ -52,16 +52,12 @@ static void shade_background_pixels(Device *device, DeviceScene *dscene, int res
 	}
 
 	/* compute on device */
-	d_output.resize(width*height);
-	memset((void*)d_output.data_pointer, 0, d_output.memory_size());
+	d_output.alloc(width*height);
+	d_output.zero_to_device();
+	d_input.copy_to_device();
 
 	device->const_copy_to("__data", &dscene->data, sizeof(dscene->data));
 
-	device->mem_alloc(d_input);
-	device->mem_copy_to(d_input);
-	device->mem_alloc(d_output);
-	device->mem_zero(d_output);
-
 	DeviceTask main_task(DeviceTask::SHADER);
 	main_task.shader_input = d_input.device_pointer;
 	main_task.shader_output = d_output.device_pointer;
@@ -78,13 +74,10 @@ static void shade_background_pixels(Device *device, DeviceScene *dscene, int res
 	foreach(DeviceTask& task, split_tasks) {
 		device->task_add(task);
 		device->task_wait();
-		device->mem_copy_from(d_output, task.shader_x, 1, task.shader_w, sizeof(float4));
+		d_output.copy_from_device(task.shader_x, 1, task.shader_w);
 	}
 
-	device->mem_free(d_input);
-	device->mem_free(d_output);
-
-	d_input.clear();
+	d_input.free();
 
 	float4 *d_output_data = reinterpret_cast<float4*>(d_output.data_pointer);
 
@@ -97,6 +90,8 @@ static void shade_background_pixels(Device *device, DeviceScene *dscene, int res
 			pixels[y*width + x].z = d_output_data[y*width + x].z;
 		}
 	}
+
+	d_output.free();
 }
 
 /* Light */
@@ -246,7 +241,7 @@ bool LightManager::object_usable_as_light(Object *object) {
 	return false;
 }
 
-void LightManager::device_update_distribution(Device *device, DeviceScene *dscene, Scene *scene, Progress& progress)
+void LightManager::device_update_distribution(Device *, DeviceScene *dscene, Scene *scene, Progress& progress)
 {
 	progress.set_status("Updating Lights", "Computing distribution");
 
@@ -292,7 +287,7 @@ void LightManager::device_update_distribution(Device *device, DeviceScene *dscen
 	VLOG(1) << "Total " << num_distribution << " of light distribution primitives.";
 
 	/* emission area */
-	float4 *distribution = dscene->light_distribution.resize(num_distribution + 1);
+	float4 *distribution = dscene->light_distribution.alloc(num_distribution + 1);
 	float totarea = 0.0f;
 
 	/* triangles */
@@ -451,7 +446,7 @@ void LightManager::device_update_distribution(Device *device, DeviceScene *dscen
 			kfilm->pass_shadow_scale *= (float)(num_lights - num_background_lights)/(float)num_lights;
 
 		/* CDF */
-		device->tex_alloc(dscene->light_distribution);
+		dscene->light_distribution.copy_to_device();
 
 		/* Portals */
 		if(num_portals > 0) {
@@ -466,7 +461,7 @@ void LightManager::device_update_distribution(Device *device, DeviceScene *dscen
 		}
 	}
 	else {
-		dscene->light_distribution.clear();
+		dscene->light_distribution.free();
 
 		kintegrator->num_distribution = 0;
 		kintegrator->num_all_lights = 0;
@@ -561,8 +556,8 @@ void LightManager::device_update_background(Device *device,
 
 	/* build row distributions and column distribution for the infinite area environment light */
 	int cdf_count = res + 1;
-	float2 *marg_cdf = dscene->light_background_marginal_cdf.resize(cdf_count);
-	float2 *cond_cdf = dscene->light_background_conditional_cdf.resize(cdf_count * cdf_count);
+	float2 *marg_cdf = dscene->light_background_marginal_cdf.alloc(cdf_count);
+	float2 *cond_cdf = dscene->light_background_conditional_cdf.alloc(cdf_count * cdf_count);
 
 	double time_start = time_dt();
 	if(res < 512) {
@@ -611,11 +606,11 @@ void LightManager::device_update_background(Device *device,
 	VLOG(2) << "Background MIS build time " << time_dt() - time_start << "\n";
 
 	/* update device */
-	device->tex_alloc(dscene->light_background_marginal_cdf);
-	device->tex_alloc(dscene->light_background_conditional_cdf);
+	dscene->light_background_marginal_cdf.copy_to_device();
+	dscene->light_background_conditional_cdf.copy_to_device();
 }
 
-void LightManager::device_update_points(Device *device,
+void LightManager::device_update_points(Device *,
                                         DeviceScene *dscene,
                                         Scene *scene)
 {
@@ -628,7 +623,7 @@ void LightManager::device_update_points(Device *device,
 		}
 	}
 
-	float4 *light_data = dscene->light_data.resize(num_lights*LIGHT_SIZE);
+	float4 *light_data = dscene->light_data.alloc(num_lights*LIGHT_SIZE);
 
 	if(num_lights == 0) {
 		VLOG(1) << "No effective light, ignoring points update.";
@@ -813,7 +808,7 @@ void LightManager::device_update_points(Device *device,
 	VLOG(1) << "Number of lights without contribution: "
 	        << num_scene_lights - light_index;
 
-	device->tex_alloc(dscene->light_data);
+	dscene->light_data.copy_to_device();
 }
 
 void LightManager::device_update(Device *device, DeviceScene *dscene, Scene *scene, Progress& progress)
@@ -846,17 +841,12 @@ void LightManager::device_update(Device *device, DeviceScene *dscene, Scene *sce
 	need_update = false;
 }
 
-void LightManager::device_free(Device *device, DeviceScene *dscene)
+void LightManager::device_free(Device *, DeviceScene *dscene)
 {
-	device->tex_free(dscene->light_distribution);
-	device->tex_free(dscene->light_data);
-	device->tex_free(dscene->light_background_marginal_cdf);
-	device->tex_free(dscene->light_background_conditional_cdf);
-
-	dscene->light_distribution.clear();
-	dscene->light_data.clear();
-	dscene->light_background_marginal_cdf.clear();
-	dscene->light_background_conditional_cdf.clear();
+	dscene->light_distribution.free();
+	dscene->light_data.free();
+	dscene->light_background_marginal_cdf.free();
+	dscene->light_background_conditional_cdf.free();
 }
 
 void LightManager::tag_update(Scene * /*scene*/)
diff --git a/intern/cycles/render/mesh.cpp b/intern/cycles/render/mesh.cpp
index 685272b80c1..75bdf71616f 100644
--- a/intern/cycles/render/mesh.cpp
+++ b/intern/cycles/render/mesh.cpp
@@ -1252,7 +1252,7 @@ void MeshManager::update_osl_attributes(Device *device, Scene *scene, vector<Att
 #endif
 }
 
-void MeshManager::update_svm_attributes(Device *device, DeviceScene *dscene, Scene *scene, vector<AttributeRequestSet>& mesh_attributes)
+void MeshManager::update_svm_attributes(Device *, DeviceScene *dscene, Scene *scene, vector<AttributeRequestSet>& mesh_attributes)
 {
 	/* for SVM, the attributes_map table is used to lookup the offset of an
 	 * attribute, based on a unique shader attribute id. */
@@ -1267,7 +1267,7 @@ void MeshManager::update_svm_attributes(Device *device, DeviceScene *dscene, Sce
 		return;
 
 	/* create attribute map */
-	uint4 *attr_map = dscene->attributes_map.resize(attr_map_stride*scene->objects.size());
+	uint4 *attr_map = dscene->attributes_map.alloc(attr_map_stride*scene->objects.size());
 	memset(attr_map, 0, dscene->attributes_map.size()*sizeof(uint));
 
 	for(size_t i = 0; i < scene->objects.size(); i++) {
@@ -1359,7 +1359,7 @@ void MeshManager::update_svm_attributes(Device *device, DeviceScene *dscene, Sce
 
 	/* copy to device */
 	dscene->data.bvh.attributes_map_stride = attr_map_stride;
-	device->tex_alloc(dscene->attributes_map);
+	dscene->attributes_map.copy_to_device();
 }
 
 static void update_attribute_element_size(Mesh *mesh,
@@ -1554,9 +1554,9 @@ void MeshManager::device_update_attributes(Device *device, DeviceScene *dscene,
 		}
 	}
 
-	dscene->attributes_float.resize(attr_float_size);
-	dscene->attributes_float3.resize(attr_float3_size);
-	dscene->attributes_uchar4.resize(attr_uchar4_size);
+	dscene->attributes_float.alloc(attr_float_size);
+	dscene->attributes_float3.alloc(attr_float3_size);
+	dscene->attributes_uchar4.alloc(attr_uchar4_size);
 
 	size_t attr_float_offset = 0;
 	size_t attr_float3_offset = 0;
@@ -1617,13 +1617,13 @@ void MeshManager::device_update_attributes(Device *device, DeviceScene *dscene,
 	progress.set_status("Updating Mesh", "Copying Attributes to device");
 
 	if(dscene->attributes_float.size()) {
-		device->tex_alloc(dscene->attributes_float);
+		dscene->attributes_float.copy_to_device();
 	}
 	if(dscene->attributes_float3.size()) {
-		device->tex_alloc(dscene->attributes_float3);
+		dscene->attributes_float3.copy_to_device();
 	}
 	if(dscene->attributes_uchar4.size()) {
-		device->tex_alloc(dscene->attributes_uchar4);
+		dscene->attributes_uchar4.copy_to_device();
 	}
 }
 
@@ -1671,7 +1671,7 @@ void MeshManager::mesh_calc_offset(Scene *scene)
 	}
 }
 
-void MeshManager::device_update_mesh(Device *device,
+void MeshManager::device_update_mesh(Device *,
                                      DeviceScene *dscene,
                                      Scene *scene,
                                      bool for_displacement,
@@ -1732,11 +1732,11 @@ void MeshManager::device_update_mesh(Device *device,
 		/* normals */
 		progress.set_status("Updating Mesh", "Computing normals");
 
-		uint *tri_shader = dscene->tri_shader.resize(tri_size);
-		float4 *vnormal = dscene->tri_vnormal.resize(vert_size);
-		uint4 *tri_vindex = dscene->tri_vindex.resize(tri_size);
-		uint *tri_patch = dscene->tri_patch.resize(tri_size);
-		float2 *tri_patch_uv = dscene->tri_patch_uv.resize(vert_size);
+		uint *tri_shader = dscene->tri_shader.alloc(tri_size);
+		float4 *vnormal = dscene->tri_vnormal.alloc(vert_size);
+		uint4 *tri_vindex = dscene->tri_vindex.alloc(tri_size);
+		uint *tri_patch = dscene->tri_patch.alloc(tri_size);
+		float2 *tri_patch_uv = dscene->tri_patch_uv.alloc(vert_size);
 
 		foreach(Mesh *mesh, scene->meshes) {
 			mesh->pack_normals(scene,
@@ -1754,32 +1754,32 @@ void MeshManager::device_update_mesh(Device *device,
 		/* vertex coordinates */
 		progress.set_status("Updating Mesh", "Copying Mesh to device");
 
-		device->tex_alloc(dscene->tri_shader);
-		device->tex_alloc(dscene->tri_vnormal);
-		device->tex_alloc(dscene->tri_vindex);
-		device->tex_alloc(dscene->tri_patch);
-		device->tex_alloc(dscene->tri_patch_uv);
+		dscene->tri_shader.copy_to_device();
+		dscene->tri_vnormal.copy_to_device();
+		dscene->tri_vindex.copy_to_device();
+		dscene->tri_patch.copy_to_device();
+		dscene->tri_patch_uv.copy_to_device();
 	}
 
 	if(curve_size != 0) {
 		progress.set_status("Updating Mesh", "Copying Strands to device");
 
-		float4 *curve_keys = dscene->curve_keys.resize(curve_key_size);
-		float4 *curves = dscene->curves.resize(curve_size);
+		float4 *curve_keys = dscene->curve_keys.alloc(curve_key_size);
+		float4 *curves = dscene->curves.alloc(curve_size);
 
 		foreach(Mesh *mesh, scene->meshes) {
 			mesh->pack_curves(scene, &curve_keys[mesh->curvekey_offset], &curves[mesh->curve_offset], mesh->curvekey_offset);
 			if(progress.get_cancel()) return;
 		}
 
-		device->tex_alloc(dscene->curve_keys);
-		device->tex_alloc(dscene->curves);
+		dscene->curve_keys.copy_to_device();
+		dscene->curves.copy_to_device();
 	}
 
 	if(patch_size != 0) {
 		progress.set_status("Updating Mesh", "Copying Patches to device");
 
-		uint *patch_data = dscene->patches.resize(patch_size);
+		uint *patch_data = dscene->patches.alloc(patch_size);
 
 		foreach(Mesh *mesh, scene->meshes) {
 			mesh->pack_patches(&patch_data[mesh->patch_offset], mesh->vert_offset, mesh->face_offset, mesh->corner_offset);
@@ -1791,11 +1791,11 @@ void MeshManager::device_update_mesh(Device *device,
 			if(progress.get_cancel()) return;
 		}
 
-		device->tex_alloc(dscene->patches);
+		dscene->patches.copy_to_device();
 	}
 
 	if(for_displacement) {
-		float4 *prim_tri_verts = dscene->prim_tri_verts.resize(tri_size * 3);
+		float4 *prim_tri_verts = dscene->prim_tri_verts.alloc(tri_size * 3);
 		foreach(Mesh *mesh, scene->meshes) {
 			for(size_t i = 0; i < mesh->num_triangles(); ++i) {
 				Mesh::Triangle t = mesh->get_triangle(i);
@@ -1805,7 +1805,7 @@ void MeshManager::device_update_mesh(Device *device,
 				prim_tri_verts[offset + 2] = float3_to_float4(mesh->verts[t.v[2]]);
 			}
 		}
-		device->tex_alloc(dscene->prim_tri_verts);
+		dscene->prim_tri_verts.copy_to_device();
 	}
 }
 
@@ -1841,43 +1841,43 @@ void MeshManager::device_update_bvh(Device *device, DeviceScene *dscene, Scene *
 
 	if(pack.nodes.size()) {
 		dscene->bvh_nodes.steal_data(pack.nodes);
-		device->tex_alloc(dscene->bvh_nodes);
+		dscene->bvh_nodes.copy_to_device();
 	}
 	if(pack.leaf_nodes.size()) {
 		dscene->bvh_leaf_nodes.steal_data(pack.leaf_nodes);
-		device->tex_alloc(dscene->bvh_leaf_nodes);
+		dscene->bvh_leaf_nodes.copy_to_device();
 	}
 	if(pack.object_node.size()) {
 		dscene->object_node.steal_data(pack.object_node);
-		device->tex_alloc(dscene->object_node);
+		dscene->object_node.copy_to_device();
 	}
 	if(pack.prim_tri_index.size()) {
 		dscene->prim_tri_index.steal_data(pack.prim_tri_index);
-		device->tex_alloc(dscene->prim_tri_index);
+		dscene->prim_tri_index.copy_to_device();
 	}
 	if(pack.prim_tri_verts.size()) {
 		dscene->prim_tri_verts.steal_data(pack.prim_tri_verts);
-		device->tex_alloc(dscene->prim_tri_verts);
+		dscene->prim_tri_verts.copy_to_device();
 	}
 	if(pack.prim_type.size()) {
 		dscene->prim_type.steal_data(pack.prim_type);
-		device->tex_alloc(dscene->prim_type);
+		dscene->prim_type.copy_to_device();
 	}
 	if(pack.prim_visibility.size()) {
 		dscene->prim_visibility.steal_data(pack.prim_visibility);
-		device->tex_alloc(dscene->prim_visibility);
+		dscene->prim_visibility.copy_to_device();
 	}
 	if(pack.prim_index.size()) {
 		dscene->prim_index.steal_data(pack.prim_index);
-		device->tex_alloc(dscene->prim_index);
+		dscene->prim_index.copy_to_device();
 	}
 	if(pack.prim_object.size()) {
 		dscene->prim_object.steal_data(pack.prim_object);
-		device->tex_alloc(dscene->prim_object);
+		dscene->prim_object.copy_to_device();
 	}
 	if(pack.prim_time.size()) {
 		dscene->prim_time.steal_data(pack.prim_time);
-		device->tex_alloc(dscene->prim_time);
+		dscene->prim_time.copy_to_device();
 	}
 
 	dscene->data.bvh.root = pack.root_index;
@@ -2142,51 +2142,28 @@ void MeshManager::device_update(Device *device, DeviceScene *dscene, Scene *scen
 
 void MeshManager::device_free(Device *device, DeviceScene *dscene)
 {
-	device->tex_free(dscene->bvh_nodes);
-	device->tex_free(dscene->bvh_leaf_nodes);
-	device->tex_free(dscene->object_node);
-	device->tex_free(dscene->prim_tri_verts);
-	device->tex_free(dscene->prim_tri_index);
-	device->tex_free(dscene->prim_type);
-	device->tex_free(dscene->prim_visibility);
-	device->tex_free(dscene->prim_index);
-	device->tex_free(dscene->prim_object);
-	device->tex_free(dscene->prim_time);
-	device->tex_free(dscene->tri_shader);
-	device->tex_free(dscene->tri_vnormal);
-	device->tex_free(dscene->tri_vindex);
-	device->tex_free(dscene->tri_patch);
-	device->tex_free(dscene->tri_patch_uv);
-	device->tex_free(dscene->curves);
-	device->tex_free(dscene->curve_keys);
-	device->tex_free(dscene->patches);
-	device->tex_free(dscene->attributes_map);
-	device->tex_free(dscene->attributes_float);
-	device->tex_free(dscene->attributes_float3);
-	device->tex_free(dscene->attributes_uchar4);
-
-	dscene->bvh_nodes.clear();
-	dscene->bvh_leaf_nodes.clear();
-	dscene->object_node.clear();
-	dscene->prim_tri_verts.clear();
-	dscene->prim_tri_index.clear();
-	dscene->prim_type.clear();
-	dscene->prim_visibility.clear();
-	dscene->prim_index.clear();
-	dscene->prim_object.clear();
-	dscene->prim_time.clear();
-	dscene->tri_shader.clear();
-	dscene->tri_vnormal.clear();
-	dscene->tri_vindex.clear();
-	dscene->tri_patch.clear();
-	dscene->tri_patch_uv.clear();
-	dscene->curves.clear();
-	dscene->curve_keys.clear();
-	dscene->patches.clear();
-	dscene->attributes_map.clear();
-	dscene->attributes_float.clear();
-	dscene->attributes_float3.clear();
-	dscene->attributes_uchar4.clear();
+	dscene->bvh_nodes.free();
+	dscene->bvh_leaf_nodes.free();
+	dscene->object_node.free();
+	dscene->prim_tri_verts.free();
+	dscene->prim_tri_index.free();
+	dscene->prim_type.free();
+	dscene->prim_visibility.free();
+	dscene->prim_index.free();
+	dscene->prim_object.free();
+	dscene->prim_time.free();
+	dscene->tri_shader.free();
+	dscene->tri_vnormal.free();
+	dscene->tri_vindex.free();
+	dscene->tri_patch.free();
+	dscene->tri_patch_uv.free();
+	dscene->curves.free();
+	dscene->curve_keys.free();
+	dscene->patches.free();
+	dscene->attributes_map.free();
+	dscene->attributes_float.free();
+	dscene->attributes_float3.free();
+	dscene->attributes_uchar4.free();
 
 #ifdef WITH_OSL
 	OSLGlobals *og = (OSLGlobals*)device->osl_memory();
diff --git a/intern/cycles/render/mesh_displace.cpp b/intern/cycles/render/mesh_displace.cpp
index c06cf86ea9c..ab3ae40d931 100644
--- a/intern/cycles/render/mesh_displace.cpp
+++ b/intern/cycles/render/mesh_displace.cpp
@@ -65,7 +65,7 @@ bool MeshManager::displace(Device *device, DeviceScene *dscene, Scene *scene, Me
 	const size_t num_verts = mesh->verts.size();
 	vector<bool> done(num_verts, false);
 	device_vector<uint4> d_input(device, "displace_input", MEM_READ_ONLY);
-	uint4 *d_input_data = d_input.resize(num_verts);
+	uint4 *d_input_data = d_input.alloc(num_verts);
 	size_t d_input_size = 0;
 
 	size_t num_triangles = mesh->num_triangles();
@@ -116,16 +116,13 @@ bool MeshManager::displace(Device *device, DeviceScene *dscene, Scene *scene, Me
 	
 	/* run device task */
 	device_vector<float4> d_output(device, "displace_output", MEM_WRITE_ONLY);
-	d_output.resize(d_input_size);
+	d_output.alloc(d_input_size);
+	d_output.zero_to_device();
+	d_input.copy_to_device();
 
 	/* needs to be up to data for attribute access */
 	device->const_copy_to("__data", &dscene->data, sizeof(dscene->data));
 
-	device->mem_alloc(d_input);
-	device->mem_copy_to(d_input);
-	device->mem_alloc(d_output);
-	device->mem_zero(d_output);
-
 	DeviceTask task(DeviceTask::SHADER);
 	task.shader_input = d_input.device_pointer;
 	task.shader_output = d_output.device_pointer;
@@ -139,14 +136,13 @@ bool MeshManager::displace(Device *device, DeviceScene *dscene, Scene *scene, Me
 	device->task_wait();
 
 	if(progress.get_cancel()) {
-		device->mem_free(d_input);
-		device->mem_free(d_output);
+		d_input.free();
+		d_output.free();
 		return false;
 	}
 
-	device->mem_copy_from(d_output, 0, 1, d_output.size(), sizeof(float4));
-	device->mem_free(d_input);
-	device->mem_free(d_output);
+	d_output.copy_from_device(0, 1, d_output.size());
+	d_input.free();
 
 	/* read result */
 	done.clear();
@@ -183,6 +179,8 @@ bool MeshManager::displace(Device *device, DeviceScene *dscene, Scene *scene, Me
 		}
 	}
 
+	d_output.free();
+
 	/* for displacement method both, we only need to recompute the face
 	 * normals, as bump mapping in the shader will already alter the
 	 * vertex normal, so we start from the non-displaced vertex normals
diff --git a/intern/cycles/render/object.cpp b/intern/cycles/render/object.cpp
index daa872239ce..57e44861e40 100644
--- a/intern/cycles/render/object.cpp
+++ b/intern/cycles/render/object.cpp
@@ -488,9 +488,9 @@ void ObjectManager::device_update_transforms(Device *device,
 	state.queue_start_object = 0;
 
 	state.object_flag = object_flag;
-	state.objects = dscene->objects.resize(OBJECT_SIZE*scene->objects.size());
+	state.objects = dscene->objects.alloc(OBJECT_SIZE*scene->objects.size());
 	if(state.need_motion == Scene::MOTION_PASS) {
-		state.objects_vector = dscene->objects_vector.resize(OBJECT_VECTOR_SIZE*scene->objects.size());
+		state.objects_vector = dscene->objects_vector.alloc(OBJECT_VECTOR_SIZE*scene->objects.size());
 	}
 	else {
 		state.objects_vector = NULL;
@@ -534,9 +534,9 @@ void ObjectManager::device_update_transforms(Device *device,
 		}
 	}
 
-	device->tex_alloc(dscene->objects);
+	dscene->objects.copy_to_device();
 	if(state.need_motion == Scene::MOTION_PASS) {
-		device->tex_alloc(dscene->objects_vector);
+		dscene->objects_vector.copy_to_device();
 	}
 
 	dscene->data.bvh.have_motion = state.have_motion;
@@ -557,7 +557,7 @@ void ObjectManager::device_update(Device *device, DeviceScene *dscene, Scene *sc
 		return;
 
 	/* object info flag */
-	uint *object_flag = dscene->object_flag.resize(scene->objects.size());
+	uint *object_flag = dscene->object_flag.alloc(scene->objects.size());
 
 	/* set object transform matrices, before applying static transforms */
 	progress.set_status("Updating Objects", "Copying Transformations to device");
@@ -573,7 +573,7 @@ void ObjectManager::device_update(Device *device, DeviceScene *dscene, Scene *sc
 	}
 }
 
-void ObjectManager::device_update_flags(Device *device,
+void ObjectManager::device_update_flags(Device *,
                                         DeviceScene *dscene,
                                         Scene *scene,
                                         Progress& /*progress*/,
@@ -638,10 +638,10 @@ void ObjectManager::device_update_flags(Device *device,
 	}
 
 	/* allocate object flag */
-	device->tex_alloc(dscene->object_flag);
+	dscene->object_flag.copy_to_device();
 }
 
-void ObjectManager::device_update_patch_map_offsets(Device *device, DeviceScene *dscene, Scene *scene)
+void ObjectManager::device_update_patch_map_offsets(Device *, DeviceScene *dscene, Scene *scene)
 {
 	if(scene->objects.size() == 0) {
 		return;
@@ -671,21 +671,15 @@ void ObjectManager::device_update_patch_map_offsets(Device *device, DeviceScene
 	}
 
 	if(update) {
-		device->tex_free(dscene->objects);
-		device->tex_alloc(dscene->objects);
+		dscene->objects.copy_to_device();
 	}
 }
 
-void ObjectManager::device_free(Device *device, DeviceScene *dscene)
+void ObjectManager::device_free(Device *, DeviceScene *dscene)
 {
-	device->tex_free(dscene->objects);
-	dscene->objects.clear();
-
-	device->tex_free(dscene->objects_vector);
-	dscene->objects_vector.clear();
-
-	device->tex_free(dscene->object_flag);
-	dscene->object_flag.clear();
+	dscene->objects.free();
+	dscene->objects_vector.free();
+	dscene->object_flag.free();
 }
 
 void ObjectManager::apply_static_transforms(DeviceScene *dscene, Scene *scene, uint *object_flag, Progress& progress)
diff --git a/intern/cycles/render/particles.cpp b/intern/cycles/render/particles.cpp
index a84ca51f274..06ff45b09bd 100644
--- a/intern/cycles/render/particles.cpp
+++ b/intern/cycles/render/particles.cpp
@@ -52,7 +52,7 @@ ParticleSystemManager::~ParticleSystemManager()
 {
 }
 
-void ParticleSystemManager::device_update_particles(Device *device, DeviceScene *dscene, Scene *scene, Progress& progress)
+void ParticleSystemManager::device_update_particles(Device *, DeviceScene *dscene, Scene *scene, Progress& progress)
 {
 	/* count particles.
 	 * adds one dummy particle at the beginning to avoid invalid lookups,
@@ -61,7 +61,7 @@ void ParticleSystemManager::device_update_particles(Device *device, DeviceScene
 	for(size_t j = 0; j < scene->particle_systems.size(); j++)
 		num_particles += scene->particle_systems[j]->particles.size();
 	
-	float4 *particles = dscene->particles.resize(PARTICLE_SIZE*num_particles);
+	float4 *particles = dscene->particles.alloc(PARTICLE_SIZE*num_particles);
 	
 	/* dummy particle */
 	particles[0] = make_float4(0.0f, 0.0f, 0.0f, 0.0f);
@@ -91,7 +91,7 @@ void ParticleSystemManager::device_update_particles(Device *device, DeviceScene
 		}
 	}
 	
-	device->tex_alloc(dscene->particles);
+	dscene->particles.copy_to_device();
 }
 
 void ParticleSystemManager::device_update(Device *device, DeviceScene *dscene, Scene *scene, Progress& progress)
@@ -112,10 +112,9 @@ void ParticleSystemManager::device_update(Device *device, DeviceScene *dscene, S
 	need_update = false;
 }
 
-void ParticleSystemManager::device_free(Device *device, DeviceScene *dscene)
+void ParticleSystemManager::device_free(Device *, DeviceScene *dscene)
 {
-	device->tex_free(dscene->particles);
-	dscene->particles.clear();
+	dscene->particles.free();
 }
 
 void ParticleSystemManager::tag_update(Scene * /*scene*/)
diff --git a/intern/cycles/render/scene.cpp b/intern/cycles/render/scene.cpp
index e362a35471d..260a325206c 100644
--- a/intern/cycles/render/scene.cpp
+++ b/intern/cycles/render/scene.cpp
@@ -41,40 +41,40 @@
 CCL_NAMESPACE_BEGIN
 
 DeviceScene::DeviceScene(Device *device)
-: bvh_nodes(device, "__bvh_nodes"),
-  bvh_leaf_nodes(device, "__bvh_leaf_nodes"),
-  object_node(device, "__object_node"),
-  prim_tri_index(device, "__prim_tri_index"),
-  prim_tri_verts(device, "__prim_tri_verts"),
-  prim_type(device, "__prim_type"),
-  prim_visibility(device, "__prim_visibility"),
-  prim_index(device, "__prim_index"),
-  prim_object(device, "__prim_object"),
-  prim_time(device, "__prim_time"),
-  tri_shader(device, "__tri_shader"),
-  tri_vnormal(device, "__tri_vnormal"),
-  tri_vindex(device, "__tri_vindex"),
-  tri_patch(device, "__tri_patch"),
-  tri_patch_uv(device, "__tri_patch_uv"),
-  curves(device, "__curves"),
-  curve_keys(device, "__curve_keys"),
-  patches(device, "__patches"),
-  objects(device, "__objects"),
-  objects_vector(device, "__objects_vector"),
-  attributes_map(device, "__attributes_map"),
-  attributes_float(device, "__attributes_float"),
-  attributes_float3(device, "__attributes_float3"),
-  attributes_uchar4(device, "__attributes_uchar4"),
-  light_distribution(device, "__light_distribution"),
-  light_data(device, "__light_data"),
-  light_background_marginal_cdf(device, "__light_background_marginal_cdf"),
-  light_background_conditional_cdf(device, "__light_background_conditional_cdf"),
-  particles(device, "__particles"),
-  svm_nodes(device, "__svm_nodes"),
-  shader_flag(device, "__shader_flag"),
-  object_flag(device, "__object_flag"),
-  lookup_table(device, "__lookup_table"),
-  sobol_directions(device, "__sobol_directions")
+: bvh_nodes(device, "__bvh_nodes", MEM_TEXTURE),
+  bvh_leaf_nodes(device, "__bvh_leaf_nodes", MEM_TEXTURE),
+  object_node(device, "__object_node", MEM_TEXTURE),
+  prim_tri_index(device, "__prim_tri_index", MEM_TEXTURE),
+  prim_tri_verts(device, "__prim_tri_verts", MEM_TEXTURE),
+  prim_type(device, "__prim_type", MEM_TEXTURE),
+  prim_visibility(device, "__prim_visibility", MEM_TEXTURE),
+  prim_index(device, "__prim_index", MEM_TEXTURE),
+  prim_object(device, "__prim_object", MEM_TEXTURE),
+  prim_time(device, "__prim_time", MEM_TEXTURE),
+  tri_shader(device, "__tri_shader", MEM_TEXTURE),
+  tri_vnormal(device, "__tri_vnormal", MEM_TEXTURE),
+  tri_vindex(device, "__tri_vindex", MEM_TEXTURE),
+  tri_patch(device, "__tri_patch", MEM_TEXTURE),
+  tri_patch_uv(device, "__tri_patch_uv", MEM_TEXTURE),
+  curves(device, "__curves", MEM_TEXTURE),
+  curve_keys(device, "__curve_keys", MEM_TEXTURE),
+  patches(device, "__patches", MEM_TEXTURE),
+  objects(device, "__objects", MEM_TEXTURE),
+  objects_vector(device, "__objects_vector", MEM_TEXTURE),
+  attributes_map(device, "__attributes_map", MEM_TEXTURE),
+  attributes_float(device, "__attributes_float", MEM_TEXTURE),
+  attributes_float3(device, "__attributes_float3", MEM_TEXTURE),
+  attributes_uchar4(device, "__attributes_uchar4", MEM_TEXTURE),
+  light_distribution(device, "__light_distribution", MEM_TEXTURE),
+  light_data(device, "__light_data", MEM_TEXTURE),
+  light_background_marginal_cdf(device, "__light_background_marginal_cdf", MEM_TEXTURE),
+  light_background_conditional_cdf(device, "__light_background_conditional_cdf", MEM_TEXTURE),
+  particles(device, "__particles", MEM_TEXTURE),
+  svm_nodes(device, "__svm_nodes", MEM_TEXTURE),
+  shader_flag(device, "__shader_flag", MEM_TEXTURE),
+  object_flag(device, "__object_flag", MEM_TEXTURE),
+  lookup_table(device, "__lookup_table", MEM_TEXTURE),
+  sobol_directions(device, "__sobol_directions", MEM_TEXTURE)
 {
 	memset(&data, 0, sizeof(data));
 }
diff --git a/intern/cycles/render/session.cpp b/intern/cycles/render/session.cpp
index 4642dcfa9a1..74cfd02e1a4 100644
--- a/intern/cycles/render/session.cpp
+++ b/intern/cycles/render/session.cpp
@@ -106,11 +106,11 @@ Session::~Session()
 		delete display;
 
 		display = new DisplayBuffer(device, false);
-		display->reset(device, buffers->params);
+		display->reset(buffers->params);
 		tonemap(params.samples);
 
 		progress.set_status("Writing Image", params.output_path);
-		display->write(device, params.output_path);
+		display->write(params.output_path);
 	}
 
 	/* clean up */
@@ -399,7 +399,7 @@ bool Session::acquire_tile(Device *tile_device, RenderTile& rtile)
 
 		/* allocate buffers */
 		tile->buffers = new RenderBuffers(tile_device);
-		tile->buffers->reset(tile_device, buffer_params);
+		tile->buffers->reset(buffer_params);
 	}
 
 	tile->buffers->params.get_offset_stride(rtile.offset, rtile.stride);
@@ -756,9 +756,9 @@ void Session::reset_(BufferParams& buffer_params, int samples)
 {
 	if(buffers && buffer_params.modified(tile_manager.params)) {
 		gpu_draw_ready = false;
-		buffers->reset(device, buffer_params);
+		buffers->reset(buffer_params);
 		if(display) {
-			display->reset(device, buffer_params);
+			display->reset(buffer_params);
 		}
 	}
 
@@ -923,7 +923,7 @@ void Session::render()
 {
 	/* Clear buffers. */
 	if(buffers && tile_manager.state.sample == tile_manager.range_start_sample) {
-		buffers->zero(device);
+		buffers->zero();
 	}
 
 	/* Add path trace task. */
diff --git a/intern/cycles/render/shader.cpp b/intern/cycles/render/shader.cpp
index a77df55e520..70f6d5bab47 100644
--- a/intern/cycles/render/shader.cpp
+++ b/intern/cycles/render/shader.cpp
@@ -416,14 +416,13 @@ void ShaderManager::device_update_common(Device *device,
                                          Scene *scene,
                                          Progress& /*progress*/)
 {
-	device->tex_free(dscene->shader_flag);
-	dscene->shader_flag.clear();
+	dscene->shader_flag.free();
 
 	if(scene->shaders.size() == 0)
 		return;
 
 	uint shader_flag_size = scene->shaders.size()*SHADER_SIZE;
-	uint *shader_flag = dscene->shader_flag.resize(shader_flag_size);
+	uint *shader_flag = dscene->shader_flag.alloc(shader_flag_size);
 	uint i = 0;
 	bool has_volumes = false;
 	bool has_transparent_shadow = false;
@@ -479,7 +478,7 @@ void ShaderManager::device_update_common(Device *device,
 		has_transparent_shadow |= (flag & SD_HAS_TRANSPARENT_SHADOW) != 0;
 	}
 
-	device->tex_alloc(dscene->shader_flag);
+	dscene->shader_flag.copy_to_device();
 
 	/* lookup tables */
 	KernelTables *ktables = &dscene->data.tables;
@@ -504,12 +503,11 @@ void ShaderManager::device_update_common(Device *device,
 	kintegrator->transparent_shadows = has_transparent_shadow;
 }
 
-void ShaderManager::device_free_common(Device *device, DeviceScene *dscene, Scene *scene)
+void ShaderManager::device_free_common(Device *, DeviceScene *dscene, Scene *scene)
 {
 	scene->lookup_tables->remove_table(&beckmann_table_offset);
 
-	device->tex_free(dscene->shader_flag);
-	dscene->shader_flag.clear();
+	dscene->shader_flag.free();
 }
 
 void ShaderManager::add_default(Scene *scene)
diff --git a/intern/cycles/render/svm.cpp b/intern/cycles/render/svm.cpp
index cf0dc97ef3f..db53e366d1e 100644
--- a/intern/cycles/render/svm.cpp
+++ b/intern/cycles/render/svm.cpp
@@ -130,7 +130,7 @@ void SVMShaderManager::device_update(Device *device, DeviceScene *dscene, Scene
 	}
 
 	dscene->svm_nodes.steal_data(svm_nodes);
-	device->tex_alloc(dscene->svm_nodes);
+	dscene->svm_nodes.copy_to_device();
 
 	for(i = 0; i < scene->shaders.size(); i++) {
 		Shader *shader = scene->shaders[i];
@@ -150,8 +150,7 @@ void SVMShaderManager::device_free(Device *device, DeviceScene *dscene, Scene *s
 {
 	device_free_common(device, dscene, scene);
 
-	device->tex_free(dscene->svm_nodes);
-	dscene->svm_nodes.clear();
+	dscene->svm_nodes.free();
 }
 
 /* Graph Compiler */
diff --git a/intern/cycles/render/tables.cpp b/intern/cycles/render/tables.cpp
index 9d04778abc6..5cda977b7f1 100644
--- a/intern/cycles/render/tables.cpp
+++ b/intern/cycles/render/tables.cpp
@@ -35,25 +35,22 @@ LookupTables::~LookupTables()
 	assert(lookup_tables.size() == 0);
 }
 
-void LookupTables::device_update(Device *device, DeviceScene *dscene)
+void LookupTables::device_update(Device *, DeviceScene *dscene)
 {
 	if(!need_update)
 		return;
 
 	VLOG(1) << "Total " << lookup_tables.size() << " lookup tables.";
 
-	device->tex_free(dscene->lookup_table);
-
 	if(lookup_tables.size() > 0)
-		device->tex_alloc(dscene->lookup_table);
+		dscene->lookup_table.copy_to_device();
 
 	need_update = false;
 }
 
-void LookupTables::device_free(Device *device, DeviceScene *dscene)
+void LookupTables::device_free(Device *, DeviceScene *dscene)
 {
-	device->tex_free(dscene->lookup_table);
-	dscene->lookup_table.clear();
+	dscene->lookup_table.free();
 }
 
 static size_t round_up_to_multiple(size_t size, size_t chunk)