X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;f=pv%2Fdata%2Fsegment.cpp;h=4533c9b41ef7eae4d5f092c05cb58970f8af7b8d;hb=f4e61cbe0babc594285625e51b6d2705e37288c5;hp=8745e8740dc582f8a53d33ae7ed8e81d36a87398;hpb=558ad6ceb934ab7406d286c1a4ae08da4aba1448;p=pulseview.git diff --git a/pv/data/segment.cpp b/pv/data/segment.cpp index 8745e874..4533c9b4 100644 --- a/pv/data/segment.cpp +++ b/pv/data/segment.cpp @@ -24,6 +24,9 @@ #include #include +#include + +using std::bad_alloc; using std::lock_guard; using std::min; using std::recursive_mutex; @@ -33,7 +36,8 @@ namespace data { const uint64_t Segment::MaxChunkSize = 10 * 1024 * 1024; /* 10MiB */ -Segment::Segment(uint64_t samplerate, unsigned int unit_size) : +Segment::Segment(uint32_t segment_id, uint64_t samplerate, unsigned int unit_size) : + segment_id_(segment_id), sample_count_(0), start_time_(0), samplerate_(samplerate), @@ -42,7 +46,6 @@ Segment::Segment(uint64_t samplerate, unsigned int unit_size) : mem_optimization_requested_(false), is_complete_(false) { - lock_guard lock(mutex_); assert(unit_size_ > 0); // Determine the number of samples we can fit in one chunk @@ -50,7 +53,7 @@ Segment::Segment(uint64_t samplerate, unsigned int unit_size) : chunk_size_ = min(MaxChunkSize, (MaxChunkSize / unit_size_) * unit_size_); // Create the initial chunk - current_chunk_ = new uint8_t[chunk_size_]; + current_chunk_ = new uint8_t[chunk_size_ + 7]; /* FIXME +7 is workaround for #1284 */ data_chunks_.push_back(current_chunk_); used_samples_ = 0; unused_samples_ = chunk_size_ / unit_size_; @@ -66,7 +69,6 @@ Segment::~Segment() uint64_t Segment::get_sample_count() const { - lock_guard lock(mutex_); return sample_count_; } @@ -90,9 +92,16 @@ unsigned int Segment::unit_size() const return unit_size_; } +uint32_t Segment::segment_id() const +{ + return segment_id_; +} + void Segment::set_complete() { is_complete_ = true; + + completed(); } bool Segment::is_complete() const @@ -110,15 +119,17 @@ void Segment::free_unused_memory() return; } - // No more data will come in, so re-create the last chunk accordingly - uint8_t* resized_chunk = new uint8_t[used_samples_ * unit_size_]; - memcpy(resized_chunk, current_chunk_, used_samples_ * unit_size_); + if (current_chunk_) { + // No more data will come in, so re-create the last chunk accordingly + uint8_t* resized_chunk = new uint8_t[used_samples_ * unit_size_ + 7]; /* FIXME +7 is workaround for #1284 */ + memcpy(resized_chunk, current_chunk_, used_samples_ * unit_size_); - delete[] current_chunk_; - current_chunk_ = resized_chunk; + delete[] current_chunk_; + current_chunk_ = resized_chunk; - data_chunks_.pop_back(); - data_chunks_.push_back(resized_chunk); + data_chunks_.pop_back(); + data_chunks_.push_back(resized_chunk); + } } void Segment::append_single_sample(void *data) @@ -133,7 +144,7 @@ void Segment::append_single_sample(void *data) unused_samples_--; if (unused_samples_ == 0) { - current_chunk_ = new uint8_t[chunk_size_]; + current_chunk_ = new uint8_t[chunk_size_ + 7]; /* FIXME +7 is workaround for #1284 */ data_chunks_.push_back(current_chunk_); used_samples_ = 0; unused_samples_ = chunk_size_ / unit_size_; @@ -171,8 +182,26 @@ void Segment::append_samples(void* data, uint64_t samples) data_offset += (copy_count * unit_size_); if (unused_samples_ == 0) { - // If we're out of memory, this will throw std::bad_alloc - current_chunk_ = new uint8_t[chunk_size_]; + try { + // If we're out of memory, allocating a chunk will throw + // std::bad_alloc. To give the application some usable memory + // to work with in case chunk allocation fails, we allocate + // extra memory and throw it away if it all succeeded. + // This way, memory allocation will fail early enough to let + // PV remain alive. Otherwise, PV will crash in a random + // memory-allocating part of the application. + current_chunk_ = new uint8_t[chunk_size_ + 7]; /* FIXME +7 is workaround for #1284 */ + + const int dummy_size = 2 * chunk_size_; + auto dummy_chunk = new uint8_t[dummy_size]; + memset(dummy_chunk, 0xFF, dummy_size); + delete[] dummy_chunk; + } catch (bad_alloc&) { + delete[] current_chunk_; // The new may have succeeded + current_chunk_ = nullptr; + throw; + } + data_chunks_.push_back(current_chunk_); used_samples_ = 0; unused_samples_ = chunk_size_ / unit_size_; @@ -182,21 +211,34 @@ void Segment::append_samples(void* data, uint64_t samples) sample_count_ += samples; } -void Segment::get_raw_samples(uint64_t start, uint64_t count, - uint8_t* dest) const +const uint8_t* Segment::get_raw_sample(uint64_t sample_num) const +{ + assert(sample_num <= sample_count_); + + uint64_t chunk_num = (sample_num * unit_size_) / chunk_size_; + uint64_t chunk_offs = (sample_num * unit_size_) % chunk_size_; + + lock_guard lock(mutex_); // Because of free_unused_memory() + + const uint8_t* chunk = data_chunks_[chunk_num]; + + return chunk + chunk_offs; +} + +void Segment::get_raw_samples(uint64_t start, uint64_t count, uint8_t* dest) const { assert(start < sample_count_); assert(start + count <= sample_count_); assert(count > 0); assert(dest != nullptr); - lock_guard lock(mutex_); - uint8_t* dest_ptr = dest; uint64_t chunk_num = (start * unit_size_) / chunk_size_; uint64_t chunk_offs = (start * unit_size_) % chunk_size_; + lock_guard lock(mutex_); // Because of free_unused_memory() + while (count > 0) { const uint8_t* chunk = data_chunks_[chunk_num]; @@ -213,9 +255,9 @@ void Segment::get_raw_samples(uint64_t start, uint64_t count, } } -SegmentRawDataIterator* Segment::begin_raw_sample_iteration(uint64_t start) +SegmentDataIterator* Segment::begin_sample_iteration(uint64_t start) { - SegmentRawDataIterator* it = new SegmentRawDataIterator; + SegmentDataIterator* it = new SegmentDataIterator; assert(start < sample_count_); @@ -225,17 +267,12 @@ SegmentRawDataIterator* Segment::begin_raw_sample_iteration(uint64_t start) it->chunk_num = (start * unit_size_) / chunk_size_; it->chunk_offs = (start * unit_size_) % chunk_size_; it->chunk = data_chunks_[it->chunk_num]; - it->value = it->chunk + it->chunk_offs; return it; } -void Segment::continue_raw_sample_iteration(SegmentRawDataIterator* it, uint64_t increase) +void Segment::continue_sample_iteration(SegmentDataIterator* it, uint64_t increase) { - // Fail gracefully if we are asked to deliver data we don't have - if (it->sample_index > sample_count_) - return; - it->sample_index += increase; it->chunk_offs += (increase * unit_size_); @@ -244,11 +281,9 @@ void Segment::continue_raw_sample_iteration(SegmentRawDataIterator* it, uint64_t it->chunk_offs -= chunk_size_; it->chunk = data_chunks_[it->chunk_num]; } - - it->value = it->chunk + it->chunk_offs; } -void Segment::end_raw_sample_iteration(SegmentRawDataIterator* it) +void Segment::end_sample_iteration(SegmentDataIterator* it) { delete it; @@ -260,5 +295,19 @@ void Segment::end_raw_sample_iteration(SegmentRawDataIterator* it) } } +uint8_t* Segment::get_iterator_value(SegmentDataIterator* it) +{ + assert(it->sample_index <= (sample_count_ - 1)); + + return (it->chunk + it->chunk_offs); +} + +uint64_t Segment::get_iterator_valid_length(SegmentDataIterator* it) +{ + assert(it->sample_index <= (sample_count_ - 1)); + + return ((chunk_size_ - it->chunk_offs) / unit_size_); +} + } // namespace data } // namespace pv