Fixed sequence of freeing memory.

AlexeyAB

2017-03-28 2662cd51a32cf8292ccce555f64880f460108d2d

 src/yolo_v2_class.cpp

@@ -1,6 +1,5 @@
#include "yolo_v2_class.hpp"


#include "network.h"

extern "C" {
@@ -12,40 +11,33 @@
#include "box.h"
#include "image.h"
#include "demo.h"

#include "option_list.h"

#include "stb_image.h"
}
//#include <sys/time.h>

#include <vector>
#include <iostream>

#include <algorithm>

#define FRAMES 3
#define ROI_PER_DETECTOR 100


struct detector_gpu_t{
   float **probs;
   box *boxes;
   network net;
   //image det;
   //image det_s;
   image images[FRAMES];
   float *avg;
   float *predictions[FRAMES];
};



YOLODLL_API Detector::Detector(std::string cfg_filename, std::string weight_filename, int gpu_id)
{
   int old_gpu_index;
   cudaGetDevice(&old_gpu_index);

   detector_gpu_ptr = std::make_shared<detector_gpu_t>();

   detector_gpu_t &detector_gpu = *reinterpret_cast<detector_gpu_t *>(detector_gpu_ptr.get());

   cudaSetDevice(gpu_id);
@@ -77,23 +69,63 @@
   cudaSetDevice(old_gpu_index);
}


YOLODLL_API Detector::~Detector() 
{
   detector_gpu_t &detector_gpu = *reinterpret_cast<detector_gpu_t *>(detector_gpu_ptr.get());
   layer l = detector_gpu.net.layers[detector_gpu.net.n - 1];

   free(detector_gpu.boxes);
   free(detector_gpu.avg);
   free(detector_gpu.predictions);
   for (int j = 0; j < FRAMES; ++j) free(detector_gpu.predictions[j]);
   for (int j = 0; j < FRAMES; ++j) if(detector_gpu.images[j].data) free(detector_gpu.images[j].data);

   for (int j = 0; j < l.w*l.h*l.n; ++j) free(detector_gpu.probs[j]);
   free(detector_gpu.boxes);
   free(detector_gpu.probs);

   int old_gpu_index;
   cudaGetDevice(&old_gpu_index);
   cudaSetDevice(detector_gpu.net.gpu_index);

   free_network(detector_gpu.net);

   cudaSetDevice(old_gpu_index);
}


YOLODLL_API std::vector<bbox_t> Detector::detect(std::string image_filename, float thresh)
{
   std::shared_ptr<image_t> image_ptr(new image_t, [](image_t *img) { if (img->data) free(img->data); delete img; });
   *image_ptr = load_image(image_filename);
   return detect(*image_ptr, thresh);
}

static image load_image_stb(char *filename, int channels)
{
   int w, h, c;
   unsigned char *data = stbi_load(filename, &w, &h, &c, channels);
   if (!data) 
      throw std::runtime_error("file not found");
   if (channels) c = channels;
   int i, j, k;
   image im = make_image(w, h, c);
   for (k = 0; k < c; ++k) {
      for (j = 0; j < h; ++j) {
         for (i = 0; i < w; ++i) {
            int dst_index = i + w*j + w*h*k;
            int src_index = k + c*i + c*w*j;
            im.data[dst_index] = (float)data[src_index] / 255.;
         }
      }
   }
   free(data);
   return im;
}

YOLODLL_API image_t Detector::load_image(std::string image_filename)
{
   char *input = const_cast<char *>(image_filename.data());
   image im = load_image_color(input, 0, 0);
   image im = load_image_stb(input, 3);

   image_t img;
   img.c = im.c;
@@ -101,10 +133,17 @@
   img.h = im.h;
   img.w = im.w;

   return detect(img, thresh);
   return img;
}


YOLODLL_API void Detector::free_image(image_t m)
{
   if (m.data) {
      free(m.data);
   }
}

YOLODLL_API std::vector<bbox_t> Detector::detect(image_t img, float thresh)
{

@@ -126,10 +165,6 @@
   image sized = resize_image(im, net.w, net.h);
   layer l = net.layers[net.n - 1];

   //box *boxes = (box *)calloc(l.w*l.h*l.n, sizeof(box));
   //float **probs = (float **)calloc(l.w*l.h*l.n, sizeof(float *));
   // (int j = 0; j < l.w*l.h*l.n; ++j) probs[j] = (float *)calloc(l.classes, sizeof(float *));

   float *X = sized.data;

   network_predict(net, X);
@@ -148,8 +183,8 @@
      if (prob > thresh) 
      {
         bbox_t bbox;
         bbox.x = (b.x - b.w / 2.)*im.w;
         bbox.y = (b.y - b.h / 2.)*im.h;
         bbox.x = std::max((double)0, (b.x - b.w / 2.)*im.w);
         bbox.y = std::max((double)0, (b.y - b.h / 2.)*im.h);
         bbox.w = b.w*im.w;
         bbox.h = b.h*im.h;
         bbox.obj_id = obj_id;
@@ -159,6 +194,9 @@
      }
   }

   if(sized.data)
      free(sized.data);

   cudaSetDevice(old_gpu_index);

   return bbox_vec;