Improve memory alloc and free for each capture

DSView/pv/data/snapshot.cpp

@@ -35,45 +35,31 @@ namespace pv {
 namespace data {
 
 Snapshot::Snapshot(int unit_size, uint64_t total_sample_count, unsigned int channel_num) :
+    _data(NULL),
+    _capacity(0),
     _channel_num(channel_num),
     _sample_count(0),
     _total_sample_count(total_sample_count),
     _ring_sample_count(0),
     _unit_size(unit_size),
-    _memory_failed(true),
+    _memory_failed(false),
     _last_ended(true)
 {
-	boost::lock_guard<boost::recursive_mutex> lock(_mutex);
-	assert(_unit_size > 0);
+    assert(_unit_size > 0);
 }
 
 Snapshot::~Snapshot()
 {
-	boost::lock_guard<boost::recursive_mutex> lock(_mutex);
-    _data.clear();
+    free_data();
 }
 
-int Snapshot::init(uint64_t _total_sample_len)
+void Snapshot::free_data()
 {
-//    boost::lock_guard<boost::recursive_mutex> lock(_mutex);
-//    _data = malloc(_total_sample_len * _unit_size +
-//        sizeof(uint64_t));
-
-//    if (_data == NULL)
-//        return SR_ERR_MALLOC;
-//    else
-//        return SR_OK;
-
-    boost::lock_guard<boost::recursive_mutex> lock(_mutex);
-    uint64_t size = _total_sample_len * _unit_size + sizeof(uint64_t);
-    try{
-        _data.resize(size);
-    } catch(...) {
-        _memory_failed = true;
-        return SR_ERR_MALLOC;
+    if (_data) {
+        free(_data);
+        _data = NULL;
+        _capacity = 0;
     }
-    _memory_failed = false;
-    return SR_OK;
 }
 
 bool Snapshot::memory_failed() const
@@ -83,7 +69,7 @@ bool Snapshot::memory_failed() const
 
 bool Snapshot::empty() const
 {
-    if (_sample_count == 0 || _memory_failed)
+    if (get_sample_count() == 0 || _memory_failed || !_data)
         return true;
     else
         return false;
@@ -101,41 +87,35 @@ void Snapshot::set_last_ended(bool ended)
 
 uint64_t Snapshot::get_sample_count() const
 {
-	boost::lock_guard<boost::recursive_mutex> lock(_mutex);
+    boost::lock_guard<boost::recursive_mutex> lock(_mutex);
     return _sample_count;
 }
 
 const void* Snapshot::get_data() const
 {
-    boost::lock_guard<boost::recursive_mutex> lock(_mutex);
-    return _data.data();
+    return _data;
 }
 
 int Snapshot::unit_size() const
 {
-    boost::lock_guard<boost::recursive_mutex> lock(_mutex);
     return _unit_size;
 }
 
 unsigned int Snapshot::get_channel_num() const
 {
-    boost::lock_guard<boost::recursive_mutex> lock(_mutex);
     return _channel_num;
 }
 
 uint64_t Snapshot::get_sample(uint64_t index) const
 {
-    boost::lock_guard<boost::recursive_mutex> lock(_mutex);
+    assert(_data);
+    assert(index < get_sample_count());
 
-    assert(_data.data());
-    assert(index < _sample_count);
-
-    return *(uint64_t*)((uint8_t*)_data.data() + index * _unit_size);
+    return *(uint64_t*)((uint8_t*)_data + index * _unit_size);
 }
 
 void Snapshot::append_data(void *data, uint64_t samples)
 {
-    boost::lock_guard<boost::recursive_mutex> lock(_mutex);
 //	_data = realloc(_data, (_sample_count + samples) * _unit_size +
 //		sizeof(uint64_t));
     if (_sample_count + samples < _total_sample_count)
@@ -144,13 +124,13 @@ void Snapshot::append_data(void *data, uint64_t samples)
         _sample_count = _total_sample_count;
 
     if (_ring_sample_count + samples > _total_sample_count) {
-        memcpy((uint8_t*)_data.data() + _ring_sample_count * _unit_size,
+        memcpy((uint8_t*)_data + _ring_sample_count * _unit_size,
             data, (_total_sample_count - _ring_sample_count) * _unit_size);
         _ring_sample_count = (samples + _ring_sample_count - _total_sample_count) % _total_sample_count;
-        memcpy((uint8_t*)_data.data(),
+        memcpy((uint8_t*)_data,
             data, _ring_sample_count * _unit_size);
     } else {
-        memcpy((uint8_t*)_data.data() + _ring_sample_count * _unit_size,
+        memcpy((uint8_t*)_data + _ring_sample_count * _unit_size,
             data, samples * _unit_size);
         _ring_sample_count += samples;
     }
@@ -158,13 +138,11 @@ void Snapshot::append_data(void *data, uint64_t samples)
 
 void Snapshot::refill_data(void *data, uint64_t samples, bool instant)
 {
-    boost::lock_guard<boost::recursive_mutex> lock(_mutex);
-
     if (instant) {
-        memcpy((uint8_t*)_data.data() + _sample_count * _channel_num, data, samples*_channel_num);
+        memcpy((uint8_t*)_data + _sample_count * _channel_num, data, samples*_channel_num);
         _sample_count = (_sample_count + samples) % (_total_sample_count + 1);
     } else {
-        memcpy((uint8_t*)_data.data(), data, samples*_channel_num);
+        memcpy((uint8_t*)_data, data, samples*_channel_num);
         _sample_count = samples;
     }