Peter M. Groen / openbr

Commit eac782df784f1f10a1e864139f22233247ea36e6

Authored by DepthDeluxe
1 parent 24536713

removed MatManager from master because it isn't ready

Inline Side-by-side
Showing 2 changed files with 0 additions and 155 deletions
openbr/core/cuda/MatManager.cu deleted
View file @2453671
1 -#include <pthread.h>  
2 -#include <semaphore.h>  
3 -  
4 -#include <opencv2/opencv.hpp>  
5 -  
6 -#include "MatManager.hpp"  
7 -  
8 -using namespace cv;  
9 -using namespace cv::gpu;  
10 -  
11 -namespace br { namespace cuda {  
12 - MatManager::MatManager(int num) {  
13 - _numMats = num;  
14 -  
15 - // initialize the an array of Mats  
16 - _mats = (uint8_t**)malloc(num * sizeof(uint8_t*));  
17 - _matTaken = (bool*)malloc(num * sizeof(bool));  
18 - _matsDimension = (int*)malloc(num * sizeof(int));  
19 -  
20 - for (int i=0; i < num; i++) {  
21 - cudaMalloc(&_mats[i], 1 * sizeof(uint8_t));  
22 -  
23 - // initialize matTaken  
24 - _matTaken[i] = false;  
25 -  
26 - // initialize all mat dimensions to be 1  
27 - _matsDimension[i] = 1;  
28 - }  
29 -  
30 - // initialize the locks  
31 - _matTakenLock = new pthread_mutex_t;  
32 - pthread_mutex_init(_matTakenLock, NULL);  
33 - _matsDimensionLock = new pthread_mutex_t;  
34 - pthread_mutex_init(_matsDimensionLock, NULL);  
35 -  
36 - // initialize the semaphore  
37 - _matSemaphore = new sem_t;  
38 - sem_init(_matSemaphore, 0, _numMats);  
39 - }  
40 -  
41 - MatManager::matindex MatManager::reserve(Mat &mat) {  
42 - int reservedMatIndex = 0;  
43 -  
44 - sem_wait(_matSemaphore);  
45 - pthread_mutex_lock(_matTakenLock);  
46 - int i;  
47 - for (i=0; i < _numMats; i++) {  
48 - if ( !_matTaken[i] ) {  
49 - _matTaken[i] = true;  
50 - reservedMatIndex = i;  
51 - break;  
52 - }  
53 - }  
54 - if (i == _numMats) {  
55 - std::cout << "Cannot reserve a mat. Not enough GpuMat resourses\n" << std::endl << std::flush;  
56 - }  
57 -  
58 - pthread_mutex_unlock(_matTakenLock);  
59 -  
60 - // reallocate if size does not match  
61 - pthread_mutex_lock(_matsDimensionLock);  
62 - if (_matsDimension[reservedMatIndex] != mat.rows * mat.cols) {  
63 - cudaFree(_mats[reservedMatIndex]); // free the previous memory first  
64 - cudaMalloc(&_mats[reservedMatIndex], mat.rows * mat.cols * sizeof(uint8_t));  
65 - // change the dimension of that matrix  
66 - _matsDimension[reservedMatIndex] = mat.rows * mat.cols;  
67 -  
68 - }  
69 - pthread_mutex_unlock(_matsDimensionLock);  
70 - return reservedMatIndex;  
71 - }  
72 -  
73 - void MatManager::upload(MatManager::matindex reservedMatIndex, Mat& mat) {  
74 - // copy the content of the Mat to GPU  
75 - uint8_t* reservedMat = _mats[reservedMatIndex];  
76 - cudaMemcpy(reservedMat, mat.ptr<uint8_t>(), mat.rows * mat.cols, cudaMemcpyHostToDevice);  
77 - }  
78 -  
79 - void MatManager::download(MatManager::matindex reservedMatIndex, Mat& dstMat) {  
80 - // copy the mat data back  
81 - int dimension = dstMat.rows * dstMat.cols;  
82 - uint8_t* reservedMat = _mats[reservedMatIndex];  
83 - cudaMemcpy(dstMat.ptr<uint8_t>(), reservedMat, dimension, cudaMemcpyDeviceToHost);  
84 - }  
85 -  
86 - void MatManager::release(MatManager::matindex reservedMatIndex) {  
87 - uint8_t* reservedMat = _mats[reservedMatIndex];  
88 - pthread_mutex_lock(_matTakenLock);  
89 - bool foundMatch = false;  
90 - for (int i=0; i < _numMats; i++) {  
91 - if (reservedMat == _mats[i]) {  
92 - _matTaken[i] = false;  
93 - foundMatch = true;  
94 - }  
95 - }  
96 - pthread_mutex_unlock(_matTakenLock);  
97 -  
98 - // return unconditionally if we didn't find a match  
99 - if (!foundMatch) {  
100 - std::cout << "Reservedmat is not in the _mats array" << std::endl << std::flush;  
101 - return;  
102 - }  
103 - sem_post(_matSemaphore);  
104 - }  
105 -  
106 - MatManager::~MatManager() {  
107 - // assume a single thread is destroying the manager  
108 - // TODO(colin): add the destroy code  
109 - //std::cout << "Start to destroy.." << std::endl << std::flush;  
110 - }  
111 -  
112 - uint8_t* MatManager::get_mat_pointer_from_index(MatManager::matindex matIndex) {  
113 - return _mats[matIndex];  
114 - }  
115 -  
116 -}}  
openbr/core/cuda/MatManager.hpp deleted
View file @2453671
1 -/*  
2 -NOTES  
3 -Mat reservations should return a handle instead of a pointer  
4 -*/  
5 -  
6 -#include <pthread.h>  
7 -#include <semaphore.h>  
8 -  
9 -#include <opencv2/opencv.hpp>  
10 -#include <opencv2/gpu/gpu.hpp>  
11 -  
12 -using namespace cv;  
13 -using namespace cv::gpu;  
14 -  
15 -namespace br { namespace cuda {  
16 - class MatManager {  
17 - private:  
18 - int _numMats;  
19 - uint8_t** _mats; // holds all the mats  
20 - bool* _matTaken; // holds whether or not they are taken  
21 - int* _matsDimension; // holds the dimension of the Mats  
22 -  
23 - pthread_mutex_t* _matTakenLock; // lock for matTaken table  
24 - pthread_mutex_t* _matsDimensionLock; // lock for _matsDimension table and _mats table  
25 - sem_t* _matSemaphore;  
26 -  
27 - public:  
28 - typedef int matindex;  
29 - MatManager(int num);  
30 -  
31 - int reserve(Mat &mat);  
32 - void upload(matindex reservedMatIndex, Mat& mat);  
33 - void download(matindex reservedMatIndex, Mat& dstMat);  
34 - void release(matindex matIndex);  
35 - uint8_t* get_mat_pointer_from_index(matindex matIndex);  
36 -  
37 - ~MatManager();  
38 - };  
39 -}}