Fix #32951: Progressive refine crashing Blender when used with multiple cuda
authorSergey Sharybin <sergey.vfx@gmail.com>
Tue, 23 Oct 2012 16:36:53 +0000 (16:36 +0000)
committerSergey Sharybin <sergey.vfx@gmail.com>
Tue, 23 Oct 2012 16:36:53 +0000 (16:36 +0000)
Issue was caused by offline rendering could have been allocated the same tile
to different devices and in this case buffers would become invalid.

Made it more clear in the code, so now it's  flag for tile manager to indicate
whether tiles should always be allocated for the same device or not.

Also cleaned a way how tile index for progressive refine is calculating,
which is now avoids tricky computation based on tile coordinate and it's
dimensions.

intern/cycles/render/session.cpp
intern/cycles/render/tile.cpp
intern/cycles/render/tile.h

index 65b20f1dd2cc45c4f56ef72f000863d224e5fae4..aeee119d8cd4be0fc45c8642990854da8c7c2410 100644 (file)
 
 CCL_NAMESPACE_BEGIN
 
+/* Note about  preserve_tile_device option for tile manager:
+ * progressive refine and viewport rendering does requires tiles to
+ * always be allocated for the same device
+ */
 Session::Session(const SessionParams& params_)
 : params(params_),
   tile_manager(params.progressive, params.samples, params.tile_size, params.start_resolution,
-       (params.background)? 1: max(params.device.multi_devices.size(), 1))
+       params.background == false || params.progressive_refine,
+       max(params.device.multi_devices.size(), 1))
 {
        device_use_gl = ((params.device.type != DEVICE_CPU) && !params.background);
 
@@ -334,7 +339,7 @@ bool Session::acquire_tile(Device *tile_device, RenderTile& rtile)
 
        /* get next tile from manager */
        Tile tile;
-       int device_num = (params.background)? 0: device->device_number(tile_device);
+       int device_num = device->device_number(tile_device);
 
        if(!tile_manager.next_tile(tile, device_num))
                return false;
@@ -378,20 +383,15 @@ bool Session::acquire_tile(Device *tile_device, RenderTile& rtile)
 
        /* allocate buffers */
        if(params.progressive_refine) {
-               int tile_x = rtile.x / params.tile_size.x;
-               int tile_y = rtile.y / params.tile_size.y;
-
-               int tile_index = tile_y * tile_manager.state.tile_w + tile_x;
-
                tile_lock.lock();
 
                if(tile_buffers.size() == 0)
                        tile_buffers.resize(tile_manager.state.num_tiles, NULL);
 
-               tilebuffers = tile_buffers[tile_index];
+               tilebuffers = tile_buffers[tile.index];
                if(tilebuffers == NULL) {
                        tilebuffers = new RenderBuffers(tile_device);
-                       tile_buffers[tile_index] = tilebuffers;
+                       tile_buffers[tile.index] = tilebuffers;
 
                        tilebuffers->reset(tile_device, buffer_params);
                }
index 02c0ee640a3657f3c41db98cb57c610f7e5fab43..a737f47457d71a97658bb186cf59b83d76dfff2a 100644 (file)
 
 CCL_NAMESPACE_BEGIN
 
-TileManager::TileManager(bool progressive_, int num_samples_, int2 tile_size_, int start_resolution_, int num_devices_)
+TileManager::TileManager(bool progressive_, int num_samples_, int2 tile_size_, int start_resolution_,
+                         int preserve_tile_device_, int num_devices_)
 {
        progressive = progressive_;
        tile_size = tile_size_;
        start_resolution = start_resolution_;
        num_devices = num_devices_;
+       preserve_tile_device = preserve_tile_device_;
 
        BufferParams buffer_params;
        reset(buffer_params, 0);
@@ -75,10 +77,13 @@ void TileManager::set_tiles()
        int resolution = state.resolution_divider;
        int image_w = max(1, params.width/resolution);
        int image_h = max(1, params.height/resolution);
+       int tile_index = 0;
 
        state.tiles.clear();
 
-       int num = min(image_h, num_devices);
+       int num_logical_devices = preserve_tile_device? num_devices: 1;
+
+       int num = min(image_h, num_logical_devices);
 
        for(int device = 0; device < num; device++) {
                int device_y = (image_h/num)*device;
@@ -90,20 +95,18 @@ void TileManager::set_tiles()
                int sub_h = (device_h + tile_h - 1)/tile_h;
 
                for(int tile_y = 0; tile_y < tile_h; tile_y++) {
-                       for(int tile_x = 0; tile_x < tile_w; tile_x++) {
+                       for(int tile_x = 0; tile_x < tile_w; tile_x++, tile_index++) {
                                int x = tile_x * sub_w;
                                int y = tile_y * sub_h;
                                int w = (tile_x == tile_w-1)? image_w - x: sub_w;
                                int h = (tile_y == tile_h-1)? device_h - y: sub_h;
 
-                               state.tiles.push_back(Tile(x, y + device_y, w, h, device));
+                               state.tiles.push_back(Tile(tile_index, x, y + device_y, w, h, device));
                        }
                }
        }
 
        state.num_tiles = state.tiles.size();
-       state.tile_w = (tile_size.x >= image_w) ? 1 : (image_w + tile_size.x - 1) / tile_size.x;
-       state.tile_h = (tile_size.y >= image_h) ? 1 : (image_h + tile_size.y - 1) / tile_size.y;
 
        state.buffer.width = image_w;
        state.buffer.height = image_h;
@@ -122,10 +125,13 @@ list<Tile>::iterator TileManager::next_center_tile(int device)
        int image_w = max(1, params.width/resolution);
        int image_h = max(1, params.height/resolution);
 
-       int num = min(image_h, num_devices);
+       int logical_device = preserve_tile_device? device: 0;
+       int num_logical_devices = preserve_tile_device? num_devices: 1;
+
+       int num = min(image_h, num_logical_devices);
 
-       int device_y = (image_h / num) * device;
-       int device_h = (device == num - 1) ? image_h - device * (image_h / num) : image_h / num;
+       int device_y = (image_h / num) * logical_device;
+       int device_h = (logical_device == num - 1) ? image_h - device * (image_h / num) : image_h / num;
 
        int64_t centx = image_w / 2, centy = device_y + device_h / 2, tot = 1;
        int64_t mindist = (int64_t) image_w * (int64_t) device_h;
@@ -145,7 +151,7 @@ list<Tile>::iterator TileManager::next_center_tile(int device)
 
        /* closest of the non-rendering tiles */
        for(iter = state.tiles.begin(); iter != state.tiles.end(); iter++) {
-               if(iter->device == device && iter->rendering == false) {
+               if(iter->device == logical_device && iter->rendering == false) {
                        Tile &cur_tile = *iter;
 
                        int64_t distx = centx - (cur_tile.x + cur_tile.w / 2);
index 587dfbe4f1a911c2568675453b6a8fecebf3fa3f..3ccc73deed10d798183527f2891a3a1fc0c96aa7 100644 (file)
@@ -30,6 +30,7 @@ CCL_NAMESPACE_BEGIN
 
 class Tile {
 public:
+       int index;
        int x, y, w, h;
        int device;
        bool rendering;
@@ -37,8 +38,8 @@ public:
        Tile()
        {}
 
-       Tile(int x_, int y_, int w_, int h_, int device_)
-       : x(x_), y(y_), w(w_), h(h_), device(device_), rendering(false) {}
+       Tile(int index_, int x_, int y_, int w_, int h_, int device_)
+       : index(index_), x(x_), y(y_), w(w_), h(h_), device(device_), rendering(false) {}
 };
 
 /* Tile Manager */
@@ -54,12 +55,11 @@ public:
                int resolution_divider;
                int num_tiles;
                int num_rendered_tiles;
-               int tile_w;
-               int tile_h;
                list<Tile> tiles;
        } state;
 
-       TileManager(bool progressive, int num_samples, int2 tile_size, int start_resolution, int num_devices = 1);
+       TileManager(bool progressive, int num_samples, int2 tile_size, int start_resolution,
+                   int preserve_tile_device, int num_devices = 1);
        ~TileManager();
 
        void reset(BufferParams& params, int num_samples);
@@ -77,6 +77,15 @@ protected:
        int start_resolution;
        int num_devices;
 
+       /* in some cases it is important that the same tile will be returned for the same
+        * device it was originally generated for (i.e. viewport rendering when buffer is
+        * allocating once for tile and then always used by it)
+        *
+        * in other cases any tile could be handled by any device (i.e. final rendering
+        * without progressive refine)
+        */
+       bool preserve_tile_device;
+
        list<Tile>::iterator next_center_tile(int device = 0);
 };