X-Git-Url: https://sigrok.org/gitweb/?p=pulseview.git;a=blobdiff_plain;f=pv%2Fdata%2Flogicsegment.cpp;h=b77c102d8ba2266de397f42223ffc9d5b4b0e3a5;hp=3e18b85ef4143bb399c5dd1dcff2fb7e6375d7ed;hb=65c92359634f672e5f472a5214719dabc7e20883;hpb=2ad82c2e40b6865481733913a2c32735602f63c4 diff --git a/pv/data/logicsegment.cpp b/pv/data/logicsegment.cpp index 3e18b85e..b77c102d 100644 --- a/pv/data/logicsegment.cpp +++ b/pv/data/logicsegment.cpp @@ -14,17 +14,20 @@ * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * along with this program; if not, see . */ +#include "config.h" // For HAVE_UNALIGNED_LITTLE_ENDIAN_ACCESS + #include -#include -#include -#include +#include #include +#include +#include +#include +#include "logic.hpp" #include "logicsegment.hpp" #include @@ -33,8 +36,8 @@ using std::lock_guard; using std::recursive_mutex; using std::max; using std::min; -using std::pair; using std::shared_ptr; +using std::vector; using sigrok::Logic; @@ -44,18 +47,15 @@ namespace data { const int LogicSegment::MipMapScalePower = 4; const int LogicSegment::MipMapScaleFactor = 1 << MipMapScalePower; const float LogicSegment::LogMipMapScaleFactor = logf(MipMapScaleFactor); -const uint64_t LogicSegment::MipMapDataUnit = 64*1024; // bytes +const uint64_t LogicSegment::MipMapDataUnit = 64 * 1024; // bytes -LogicSegment::LogicSegment(shared_ptr logic, uint64_t samplerate, - const uint64_t expected_num_samples) : - Segment(samplerate, logic->unit_size()), +LogicSegment::LogicSegment(pv::data::Logic& owner, uint32_t segment_id, + unsigned int unit_size, uint64_t samplerate) : + Segment(segment_id, samplerate, unit_size), + owner_(owner), last_append_sample_(0) { - set_capacity(expected_num_samples); - - lock_guard lock(mutex_); memset(mip_map_, 0, sizeof(mip_map_)); - append_payload(logic); } LogicSegment::~LogicSegment() @@ -65,7 +65,7 @@ LogicSegment::~LogicSegment() free(l.data); } -uint64_t LogicSegment::unpack_sample(const uint8_t *ptr) const +inline uint64_t LogicSegment::unpack_sample(const uint8_t *ptr) const { #ifdef HAVE_UNALIGNED_LITTLE_ENDIAN_ACCESS return *(uint64_t*)ptr; @@ -103,7 +103,7 @@ uint64_t LogicSegment::unpack_sample(const uint8_t *ptr) const #endif } -void LogicSegment::pack_sample(uint8_t *ptr, uint64_t value) +inline void LogicSegment::pack_sample(uint8_t *ptr, uint64_t value) { #ifdef HAVE_UNALIGNED_LITTLE_ENDIAN_ACCESS *(uint64_t*)ptr = value; @@ -139,144 +139,61 @@ void LogicSegment::pack_sample(uint8_t *ptr, uint64_t value) #endif } -void LogicSegment::append_payload(shared_ptr logic) +void LogicSegment::append_payload(shared_ptr logic) { assert(unit_size_ == logic->unit_size()); assert((logic->data_length() % unit_size_) == 0); + append_payload(logic->data_pointer(), logic->data_length()); +} + +void LogicSegment::append_payload(void *data, uint64_t data_size) +{ + assert((data_size % unit_size_) == 0); + lock_guard lock(mutex_); - append_data(logic->data_pointer(), - logic->data_length() / unit_size_); + const uint64_t prev_sample_count = sample_count_; + const uint64_t sample_count = data_size / unit_size_; + + append_samples(data, sample_count); // Generate the first mip-map from the data append_payload_to_mipmap(); + + if (sample_count > 1) + owner_.notify_samples_added(this, prev_sample_count + 1, + prev_sample_count + 1 + sample_count); + else + owner_.notify_samples_added(this, prev_sample_count + 1, + prev_sample_count + 1); } -void LogicSegment::get_samples(uint8_t *const data, - int64_t start_sample, int64_t end_sample) const +void LogicSegment::get_samples(int64_t start_sample, + int64_t end_sample, uint8_t* dest) const { - assert(data); assert(start_sample >= 0); assert(start_sample <= (int64_t)sample_count_); assert(end_sample >= 0); assert(end_sample <= (int64_t)sample_count_); assert(start_sample <= end_sample); + assert(dest != nullptr); lock_guard lock(mutex_); - const size_t size = (end_sample - start_sample) * unit_size_; - memcpy(data, (const uint8_t*)data_.data() + start_sample * unit_size_, size); -} - -void LogicSegment::reallocate_mipmap_level(MipMapLevel &m) -{ - const uint64_t new_data_length = ((m.length + MipMapDataUnit - 1) / - MipMapDataUnit) * MipMapDataUnit; - if (new_data_length > m.data_length) { - m.data_length = new_data_length; - - // Padding is added to allow for the uint64_t write word - m.data = realloc(m.data, new_data_length * unit_size_ + - sizeof(uint64_t)); - } -} - -void LogicSegment::append_payload_to_mipmap() -{ - MipMapLevel &m0 = mip_map_[0]; - uint64_t prev_length; - const uint8_t *src_ptr; - uint8_t *dest_ptr; - uint64_t accumulator; - unsigned int diff_counter; - - // Expand the data buffer to fit the new samples - prev_length = m0.length; - m0.length = sample_count_ / MipMapScaleFactor; - - // Break off if there are no new samples to compute - if (m0.length == prev_length) - return; - - reallocate_mipmap_level(m0); - - dest_ptr = (uint8_t*)m0.data + prev_length * unit_size_; - - // Iterate through the samples to populate the first level mipmap - const uint8_t *const end_src_ptr = (uint8_t*)data_.data() + - m0.length * unit_size_ * MipMapScaleFactor; - for (src_ptr = (uint8_t*)data_.data() + - prev_length * unit_size_ * MipMapScaleFactor; - src_ptr < end_src_ptr;) { - // Accumulate transitions which have occurred in this sample - accumulator = 0; - diff_counter = MipMapScaleFactor; - while (diff_counter-- > 0) { - const uint64_t sample = unpack_sample(src_ptr); - accumulator |= last_append_sample_ ^ sample; - last_append_sample_ = sample; - src_ptr += unit_size_; - } - - pack_sample(dest_ptr, accumulator); - dest_ptr += unit_size_; - } - - // Compute higher level mipmaps - for (unsigned int level = 1; level < ScaleStepCount; level++) { - MipMapLevel &m = mip_map_[level]; - const MipMapLevel &ml = mip_map_[level-1]; - - // Expand the data buffer to fit the new samples - prev_length = m.length; - m.length = ml.length / MipMapScaleFactor; - - // Break off if there are no more samples to computed - if (m.length == prev_length) - break; - - reallocate_mipmap_level(m); - - // Subsample the level lower level - src_ptr = (uint8_t*)ml.data + - unit_size_ * prev_length * MipMapScaleFactor; - const uint8_t *const end_dest_ptr = - (uint8_t*)m.data + unit_size_ * m.length; - for (dest_ptr = (uint8_t*)m.data + - unit_size_ * prev_length; - dest_ptr < end_dest_ptr; - dest_ptr += unit_size_) { - accumulator = 0; - diff_counter = MipMapScaleFactor; - while (diff_counter-- > 0) { - accumulator |= unpack_sample(src_ptr); - src_ptr += unit_size_; - } - - pack_sample(dest_ptr, accumulator); - } - } -} - -uint64_t LogicSegment::get_sample(uint64_t index) const -{ - assert(index < sample_count_); - - return unpack_sample((uint8_t*)data_.data() + index * unit_size_); + get_raw_samples(start_sample, (end_sample - start_sample), dest); } void LogicSegment::get_subsampled_edges( - std::vector &edges, + vector &edges, uint64_t start, uint64_t end, - float min_length, int sig_index) + float min_length, int sig_index, bool first_change_only) { uint64_t index = start; unsigned int level; bool last_sample; bool fast_forward; - assert(end <= get_sample_count()); assert(start <= end); assert(min_length > 0); assert(sig_index >= 0); @@ -284,34 +201,38 @@ void LogicSegment::get_subsampled_edges( lock_guard lock(mutex_); + // Make sure we only process as many samples as we have + if (end > get_sample_count()) + end = get_sample_count(); + const uint64_t block_length = (uint64_t)max(min_length, 1.0f); const unsigned int min_level = max((int)floorf(logf(min_length) / LogMipMapScaleFactor) - 1, 0); const uint64_t sig_mask = 1ULL << sig_index; // Store the initial state - last_sample = (get_sample(start) & sig_mask) != 0; - edges.push_back(pair(index++, last_sample)); + last_sample = (get_unpacked_sample(start) & sig_mask) != 0; + if (!first_change_only) + edges.emplace_back(index++, last_sample); while (index + block_length <= end) { //----- Continue to search -----// level = min_level; // We cannot fast-forward if there is no mip-map data at - // at the minimum level. + // the minimum level. fast_forward = (mip_map_[level].data != nullptr); if (min_length < MipMapScaleFactor) { // Search individual samples up to the beginning of // the next first level mip map block - const uint64_t final_index = min(end, - pow2_ceil(index, MipMapScalePower)); + const uint64_t final_index = min(end, pow2_ceil(index, MipMapScalePower)); for (; index < final_index && - (index & ~(~0 << MipMapScalePower)) != 0; + (index & ~((uint64_t)(~0) << MipMapScalePower)) != 0; index++) { - const bool sample = - (get_sample(index) & sig_mask) != 0; + + const bool sample = (get_unpacked_sample(index) & sig_mask) != 0; // If there was a change we cannot fast forward if (sample != last_sample) { @@ -323,15 +244,13 @@ void LogicSegment::get_subsampled_edges( // If resolution is less than a mip map block, // round up to the beginning of the mip-map block // for this level of detail - const int min_level_scale_power = - (level + 1) * MipMapScalePower; + const int min_level_scale_power = (level + 1) * MipMapScalePower; index = pow2_ceil(index, min_level_scale_power); if (index >= end) break; // We can fast forward only if there was no change - const bool sample = - (get_sample(index) & sig_mask) != 0; + const bool sample = (get_unpacked_sample(index) & sig_mask) != 0; if (last_sample != sample) fast_forward = false; } @@ -345,51 +264,43 @@ void LogicSegment::get_subsampled_edges( // Slide right and zoom out at the beginnings of mip-map // blocks until we encounter a change - while (1) { - const int level_scale_power = - (level + 1) * MipMapScalePower; - const uint64_t offset = - index >> level_scale_power; + while (true) { + const int level_scale_power = (level + 1) * MipMapScalePower; + const uint64_t offset = index >> level_scale_power; // Check if we reached the last block at this // level, or if there was a change in this block if (offset >= mip_map_[level].length || - (get_subsample(level, offset) & - sig_mask)) + (get_subsample(level, offset) & sig_mask)) break; - if ((offset & ~(~0 << MipMapScalePower)) == 0) { + if ((offset & ~((uint64_t)(~0) << MipMapScalePower)) == 0) { // If we are now at the beginning of a // higher level mip-map block ascend one // level - if (level + 1 >= ScaleStepCount || - !mip_map_[level + 1].data) + if ((level + 1 >= ScaleStepCount) || (!mip_map_[level + 1].data)) break; level++; } else { // Slide right to the beginning of the // next mip map block - index = pow2_ceil(index + 1, - level_scale_power); + index = pow2_ceil(index + 1, level_scale_power); } } // Zoom in, and slide right until we encounter a change, // and repeat until we reach min_level - while (1) { + while (true) { assert(mip_map_[level].data); - const int level_scale_power = - (level + 1) * MipMapScalePower; - const uint64_t offset = - index >> level_scale_power; + const int level_scale_power = (level + 1) * MipMapScalePower; + const uint64_t offset = index >> level_scale_power; // Check if we reached the last block at this // level, or if there was a change in this block if (offset >= mip_map_[level].length || - (get_subsample(level, offset) & - sig_mask)) { + (get_subsample(level, offset) & sig_mask)) { // Zoom in unless we reached the minimum // zoom if (level == min_level) @@ -399,8 +310,7 @@ void LogicSegment::get_subsampled_edges( } else { // Slide right to the beginning of the // next mip map block - index = pow2_ceil(index + 1, - level_scale_power); + index = pow2_ceil(index + 1, level_scale_power); } } @@ -409,8 +319,7 @@ void LogicSegment::get_subsampled_edges( // block if (min_length < MipMapScaleFactor) { for (; index < end; index++) { - const bool sample = (get_sample(index) & - sig_mask) != 0; + const bool sample = (get_unpacked_sample(index) & sig_mask) != 0; if (sample != last_sample) break; } @@ -425,19 +334,171 @@ void LogicSegment::get_subsampled_edges( break; // Store the final state - const bool final_sample = - (get_sample(final_index - 1) & sig_mask) != 0; - edges.push_back(pair(index, final_sample)); + const bool final_sample = (get_unpacked_sample(final_index - 1) & sig_mask) != 0; + edges.emplace_back(index, final_sample); index = final_index; last_sample = final_sample; + + if (first_change_only) + break; } // Add the final state - const bool end_sample = get_sample(end) & sig_mask; - if (last_sample != end_sample) - edges.push_back(pair(end, end_sample)); - edges.push_back(pair(end + 1, end_sample)); + if (!first_change_only) { + const bool end_sample = get_unpacked_sample(end) & sig_mask; + if (last_sample != end_sample) + edges.emplace_back(end, end_sample); + edges.emplace_back(end + 1, end_sample); + } +} + +void LogicSegment::get_surrounding_edges(vector &dest, + uint64_t origin_sample, float min_length, int sig_index) +{ + if (origin_sample >= sample_count_) + return; + + // Put the edges vector on the heap, it can become quite big until we can + // use a get_subsampled_edges() implementation that searches backwards + vector* edges = new vector; + + // Get all edges to the left of origin_sample + get_subsampled_edges(*edges, 0, origin_sample, min_length, sig_index, false); + + // If we don't specify "first only", the first and last edge are the states + // at samples 0 and origin_sample. If only those exist, there are no edges + if (edges->size() == 2) { + delete edges; + return; + } + + // Dismiss the entry for origin_sample so that back() gives us the + // real last entry + edges->pop_back(); + dest.push_back(edges->back()); + edges->clear(); + + // Get first edge to the right of origin_sample + get_subsampled_edges(*edges, origin_sample, sample_count_, min_length, sig_index, true); + + // "first only" is specified, so nothing needs to be dismissed + if (edges->size() == 0) { + delete edges; + return; + } + + dest.push_back(edges->front()); + + delete edges; +} + +void LogicSegment::reallocate_mipmap_level(MipMapLevel &m) +{ + lock_guard lock(mutex_); + + const uint64_t new_data_length = ((m.length + MipMapDataUnit - 1) / + MipMapDataUnit) * MipMapDataUnit; + + if (new_data_length > m.data_length) { + m.data_length = new_data_length; + + // Padding is added to allow for the uint64_t write word + m.data = realloc(m.data, new_data_length * unit_size_ + + sizeof(uint64_t)); + } +} + +void LogicSegment::append_payload_to_mipmap() +{ + MipMapLevel &m0 = mip_map_[0]; + uint64_t prev_length; + uint8_t *dest_ptr; + SegmentDataIterator* it; + uint64_t accumulator; + unsigned int diff_counter; + + // Expand the data buffer to fit the new samples + prev_length = m0.length; + m0.length = sample_count_ / MipMapScaleFactor; + + // Break off if there are no new samples to compute + if (m0.length == prev_length) + return; + + reallocate_mipmap_level(m0); + + dest_ptr = (uint8_t*)m0.data + prev_length * unit_size_; + + // Iterate through the samples to populate the first level mipmap + const uint64_t start_sample = prev_length * MipMapScaleFactor; + const uint64_t end_sample = m0.length * MipMapScaleFactor; + + it = begin_sample_iteration(start_sample); + for (uint64_t i = start_sample; i < end_sample;) { + // Accumulate transitions which have occurred in this sample + accumulator = 0; + diff_counter = MipMapScaleFactor; + while (diff_counter-- > 0) { + const uint64_t sample = unpack_sample(get_iterator_value(it)); + accumulator |= last_append_sample_ ^ sample; + last_append_sample_ = sample; + continue_sample_iteration(it, 1); + i++; + } + + pack_sample(dest_ptr, accumulator); + dest_ptr += unit_size_; + } + end_sample_iteration(it); + + // Compute higher level mipmaps + for (unsigned int level = 1; level < ScaleStepCount; level++) { + MipMapLevel &m = mip_map_[level]; + const MipMapLevel &ml = mip_map_[level - 1]; + + // Expand the data buffer to fit the new samples + prev_length = m.length; + m.length = ml.length / MipMapScaleFactor; + + // Break off if there are no more samples to be computed + if (m.length == prev_length) + break; + + reallocate_mipmap_level(m); + + // Subsample the lower level + const uint8_t* src_ptr = (uint8_t*)ml.data + + unit_size_ * prev_length * MipMapScaleFactor; + const uint8_t *const end_dest_ptr = + (uint8_t*)m.data + unit_size_ * m.length; + + for (dest_ptr = (uint8_t*)m.data + + unit_size_ * prev_length; + dest_ptr < end_dest_ptr; + dest_ptr += unit_size_) { + accumulator = 0; + diff_counter = MipMapScaleFactor; + while (diff_counter-- > 0) { + accumulator |= unpack_sample(src_ptr); + src_ptr += unit_size_; + } + + pack_sample(dest_ptr, accumulator); + } + } +} + +uint64_t LogicSegment::get_unpacked_sample(uint64_t index) const +{ + assert(index < sample_count_); + + assert(unit_size_ <= 8); // 8 * 8 = 64 channels + uint8_t data[8]; + + get_raw_samples(index, 1, data); + + return unpack_sample(data); } uint64_t LogicSegment::get_subsample(int level, uint64_t offset) const @@ -450,7 +511,7 @@ uint64_t LogicSegment::get_subsample(int level, uint64_t offset) const uint64_t LogicSegment::pow2_ceil(uint64_t x, unsigned int power) { - const uint64_t p = 1 << power; + const uint64_t p = UINT64_C(1) << power; return (x + p - 1) / p * p; }