SW/DSView
2
0
Fork 0
forked from Ivasoft/DSView
Code Pull Requests Activity

Restore code file:logicsnapshot.cpp

Browse Source
This commit is contained in:
dreamsourcelabTAI
2022-11-21 17:12:57 +08:00
parent 92cb8ba33f
commit da6b8ff426
2 changed files with 139 additions and 210 deletions
Download Patch File Download Diff File Expand all files Collapse all files

339
DSView/pv/data/logicsnapshot.cpp
View File

@@ -54,7 +54,6 @@ LogicSnapshot::LogicSnapshot() :
_channel_num = 0;
_block_num = 0;
_total_sample_count = 0;
_rootnode_size = 0;
}
LogicSnapshot::~LogicSnapshot()
@@ -66,14 +65,13 @@ void LogicSnapshot::free_data()
Snapshot::free_data();
for(auto& iter : _ch_data) {
for(RootNode *r : iter) {
for(auto& iter_rn : iter) {
for (unsigned int k = 0; k < Scale; k++){
if (r->lbp[k] != NULL)
free(r->lbp[k]);
if (iter_rn.lbp[k] != NULL)
free(iter_rn.lbp[k]);
}
delete r;
}
std::vector<class RootNode*> void_vector;
std::vector<struct RootNode> void_vector;
iter.swap(void_vector);
}
_ch_data.clear();
@@ -88,13 +86,13 @@ void LogicSnapshot::init()
void LogicSnapshot::init_all()
{
_sample_count = 0;
_real_sample_count = 0;
_sample_count = 0;
_ring_sample_count = 0;
_block_num = 0;
_byte_fraction = 0;
_ch_fraction = 0;
_dest_wrt_ptr = NULL;
_src_ptr = NULL;
_dest_ptr = NULL;
_data = NULL;
_memory_failed = false;
_last_ended = true;
@@ -114,27 +112,24 @@ void LogicSnapshot::capture_ended()
uint64_t block_index = _ring_sample_count / LeafBlockSamples;
uint64_t block_offset = (_ring_sample_count % LeafBlockSamples) / Scale;
if (block_offset != 0) {
uint64_t index0 = block_index / RootScale;
uint64_t index1 = block_index % RootScale;
int order = 0;
for(auto& iter : _ch_data)
{
RootNode *r = iter[index0];
if (r->lbp[index1] == NULL){
r->lbp[index1] = malloc(LeafBlockSpace);
if (r->lbp[index1] == NULL){
for(auto& iter : _ch_data) {
if (iter[index0].lbp[index1] == NULL){
iter[index0].lbp[index1] = malloc(LeafBlockSpace);
if (iter[index0].lbp[index1] == NULL)
{
_memory_failed = true;
return;
}
memset(r->lbp[index1], 0, LeafBlockSpace);
memset(iter[index0].lbp[index1], 0, LeafBlockSpace);
}
const uint64_t *end_ptr = (uint64_t *)r->lbp[index1] + (LeafBlockSamples / Scale);
uint64_t *ptr = (uint64_t *)r->lbp[index1] + block_offset;
const uint64_t *end_ptr = (uint64_t *)iter[index0].lbp[index1] + (LeafBlockSamples / Scale);
uint64_t *ptr = (uint64_t *)iter[index0].lbp[index1] + block_offset;
while (ptr < end_ptr)
*ptr++ = 0;
@@ -143,16 +138,14 @@ void LogicSnapshot::capture_ended()
calc_mipmap(order, index0, index1, block_offset * Scale);
// calc root of current block
if (*((uint64_t *)r->lbp[index1]) != 0)
r->value += 1ULL << index1;
if (*((uint64_t *)r->lbp[index1] + LeafBlockSpace / sizeof(uint64_t) - 1) != 0) {
r->tog += 1ULL << index1;
}
else {
if (*((uint64_t *)iter[index0].lbp[index1]) != 0)
iter[index0].value += 1ULL << index1;
if (*((uint64_t *)iter[index0].lbp[index1] + LeafBlockSpace / sizeof(uint64_t) - 1) != 0) {
iter[index0].tog += 1ULL << index1;
} else {
// trim leaf to free space
free(r->lbp[index1]);
r->lbp[index1] = NULL;
free(iter[index0].lbp[index1]);
iter[index0].lbp[index1] = NULL;
}
order++;
@@ -186,31 +179,29 @@ void LogicSnapshot::first_payload(const sr_datafeed_logic &logic, uint64_t total
_total_sample_count = total_sample_count;
_channel_num = channel_num;
_rootnode_size = (_total_sample_count + RootNodeSamples - 1) / RootNodeSamples;
uint64_t rootnode_size = (_total_sample_count + RootNodeSamples - 1) / RootNodeSamples;
for (const GSList *l = channels; l; l = l->next) {
sr_channel *const probe = (sr_channel*)l->data;
if (probe->type == SR_CHANNEL_LOGIC && probe->enabled) {
std::vector<class RootNode*> root_vector;
for (uint64_t j = 0; j < _rootnode_size; j++) {
class RootNode *r = new RootNode();
r->tog = 0;
r->value = 0;
memset(r->lbp, 0, sizeof(r->lbp));
root_vector.push_back(r);
std::vector<struct RootNode> root_vector;
for (uint64_t j = 0; j < rootnode_size; j++) {
struct RootNode rn;
rn.tog = 0;
rn.value = 0;
memset(rn.lbp, 0, sizeof(rn.lbp));
root_vector.push_back(rn);
}
_ch_data.push_back(root_vector);
_ch_index.push_back(probe->index); //The channel data root node index.
_ch_index.push_back(probe->index);
}
}
}
else {
for(auto& iter : _ch_data) {
for(RootNode *r : iter) {
r->tog = 0;
r->value = 0;
for(auto& iter_rn : iter) {
iter_rn.tog = 0;
iter_rn.value = 0;
}
}
}
@@ -250,61 +241,54 @@ void LogicSnapshot::append_cross_payload(const sr_datafeed_logic &logic)
if (_sample_count >= _total_sample_count)
return;
void *src_data_ptr = logic.data;
uint64_t data_len = logic.length;
_src_ptr = logic.data;
uint64_t len = logic.length;
// samples not accurate, lead to a larger _sampole_count
// _sample_count should be fixed in the last packet
// so _total_sample_count must be align to LeafBlock
uint64_t sample_num = ceil(data_len * 8.0 / _channel_num);
if (_sample_count + sample_num < _total_sample_count)
_sample_count += sample_num;
else
uint64_t samples = ceil(logic.length * 8.0 / _channel_num);
if (_sample_count + samples < _total_sample_count) {
_sample_count += samples;
} else {
//len = ceil((_total_sample_count - _sample_count) * _channel_num / 8.0);
_sample_count = _total_sample_count;
// malloc memory buffer.
}
while (_sample_count > _block_num * LeafBlockSamples) {
uint8_t index0 = _block_num / RootScale;
uint8_t index1 = _block_num % RootScale;
for(auto& iter : _ch_data) {
RootNode *r = iter[index0];
if (r->lbp[index1] == NULL){
r->lbp[index1] = malloc(LeafBlockSpace);
if (iter[index0].lbp[index1] == NULL){
iter[index0].lbp[index1] = malloc(LeafBlockSpace);
if (r->lbp[index1] == NULL) {
if (iter[index0].lbp[index1] == NULL) {
_memory_failed = true;
dsv_err("%s", "LogicSnapshot::append_cross_payload(), malloc failed.");
return;
}
}
uint64_t *mipmap_ptr = (uint64_t *)r->lbp[index1] + (LeafBlockSamples / Scale);
uint64_t *mipmap_ptr = (uint64_t *)iter[index0].lbp[index1] +
(LeafBlockSamples / Scale);
memset(mipmap_ptr, 0, LeafBlockSpace - (LeafBlockSamples / 8));
}
_block_num++;
}
// bit align
while (((_ch_fraction != 0) || (_byte_fraction != 0)) && (data_len != 0)) {
uint8_t *dp_tmp = (uint8_t *)_dest_wrt_ptr;
uint8_t *sp_tmp = (uint8_t *)src_data_ptr;
if (_dest_wrt_ptr == NULL){
assert(false);
}
while (((_ch_fraction != 0) || (_byte_fraction != 0)) && (len != 0)) {
uint8_t *dp_tmp = (uint8_t *)_dest_ptr;
uint8_t *sp_tmp = (uint8_t *)_src_ptr;
do {
//*(uint8_t *)_dest_ptr++ = *(uint8_t *)_src_ptr++;
*dp_tmp++ = *sp_tmp++;
_byte_fraction = (_byte_fraction + 1) % ScaleSize;
data_len--;
}
while ((_byte_fraction != 0) && (data_len != 0));
len--;
} while ((_byte_fraction != 0) && (len != 0));
_dest_wrt_ptr = dp_tmp;
src_data_ptr = sp_tmp;
_dest_ptr = dp_tmp;
_src_ptr = sp_tmp;
if (_byte_fraction == 0) {
const uint64_t index0 = _ring_sample_count / RootNodeSamples;
@@ -312,12 +296,9 @@ void LogicSnapshot::append_cross_payload(const sr_datafeed_logic &logic)
const uint64_t offset = (_ring_sample_count % LeafBlockSamples) / Scale;
_ch_fraction = (_ch_fraction + 1) % _channel_num;
if (_ch_fraction == 0)
_ring_sample_count += Scale;
RootNode *r = _ch_data[_ch_fraction][index0];
_dest_wrt_ptr = (uint8_t *)r->lbp[index1] + (offset * ScaleSize);
_dest_ptr = (uint8_t *)_ch_data[_ch_fraction][index0].lbp[index1] + (offset * ScaleSize);
}
}
@@ -326,46 +307,41 @@ void LogicSnapshot::append_cross_payload(const sr_datafeed_logic &logic)
assert(_ch_fraction == 0);
assert(_byte_fraction == 0);
assert(_ring_sample_count % Scale == 0);
uint64_t pre_index0 = _ring_sample_count / RootNodeSamples;
uint64_t pre_index1 = (_ring_sample_count >> LeafBlockPower) % RootScale;
uint64_t pre_offset = (_ring_sample_count % LeafBlockSamples) / Scale;
uint64_t *src_ptr = NULL;
uint64_t *dest_ptr;
int order = 0;
const uint64_t align_size = data_len / _channel_num / ScaleSize;
const uint64_t align_size = len / ScaleSize / _channel_num;
_ring_sample_count += align_size * Scale;
for(auto& iter : _ch_data)
{
for(auto& iter : _ch_data) {
uint64_t index0 = pre_index0;
uint64_t index1 = pre_index1;
RootNode *r = iter[index0];
src_ptr = (uint64_t *)_src_ptr + order;
_dest_ptr = iter[index0].lbp[index1];
dest_ptr = (uint64_t *)_dest_ptr + pre_offset;
src_ptr = (uint64_t *)src_data_ptr + order;
_dest_wrt_ptr = r->lbp[index1];
dest_ptr = (uint64_t *)_dest_wrt_ptr + pre_offset;
while (src_ptr < (uint64_t *)src_data_ptr + (align_size * _channel_num)) {
*dest_ptr++ = *src_ptr;
while (src_ptr < (uint64_t *)_src_ptr + (align_size * _channel_num)) {
const uint64_t tmp_u64 = *src_ptr;
*dest_ptr++ = tmp_u64;
src_ptr += _channel_num;
//mipmap
if (dest_ptr == (uint64_t *)_dest_wrt_ptr + (LeafBlockSamples / Scale)) {
if (dest_ptr == (uint64_t *)_dest_ptr + (LeafBlockSamples / Scale)) {
// calc mipmap of current block
calc_mipmap(order, index0, index1, LeafBlockSamples);
// calc root of current block
if (*((uint64_t *)r->lbp[index1]) != 0)
r->value += 1ULL<< index1;
if (*((uint64_t *)r->lbp[index1] + LeafBlockSpace / sizeof(uint64_t) - 1) != 0) {
r->tog += 1ULL << index1;
}
else {
if (*((uint64_t *)iter[index0].lbp[index1]) != 0)
iter[index0].value += 1ULL<< index1;
if (*((uint64_t *)iter[index0].lbp[index1] + LeafBlockSpace / sizeof(uint64_t) - 1) != 0) {
iter[index0].tog += 1ULL << index1;
} else {
// trim leaf to free space
free(r->lbp[index1]);
r->lbp[index1] = NULL;
free(iter[index0].lbp[index1]);
iter[index0].lbp[index1] = NULL;
}
index1++;
@@ -373,14 +349,14 @@ void LogicSnapshot::append_cross_payload(const sr_datafeed_logic &logic)
index0++;
index1 = 0;
}
_dest_wrt_ptr = r->lbp[index1];
dest_ptr = (uint64_t *)_dest_wrt_ptr;
_dest_ptr = iter[index0].lbp[index1];
dest_ptr = (uint64_t *)_dest_ptr;
}
}
order++;
}
data_len -= align_size * _channel_num * ScaleSize;
src_data_ptr = src_ptr - _channel_num + 1;
len -= align_size * _channel_num * ScaleSize;
_src_ptr = src_ptr - _channel_num + 1;
}
// fraction data append
@@ -388,42 +364,36 @@ void LogicSnapshot::append_cross_payload(const sr_datafeed_logic &logic)
uint64_t index0 = _ring_sample_count / RootNodeSamples;
uint64_t index1 = (_ring_sample_count >> LeafBlockPower) % RootScale;
uint64_t offset = (_ring_sample_count % LeafBlockSamples) / 8;
RootNode *r = _ch_data[_ch_fraction][index0];
_dest_wrt_ptr = (uint8_t *)r->lbp[index1] + offset;
_dest_ptr = (uint8_t *)_ch_data[_ch_fraction][index0].lbp[index1] + offset;
uint8_t *dp_tmp = (uint8_t *)_dest_wrt_ptr;
uint8_t *sp_tmp = (uint8_t *)src_data_ptr;
while(data_len-- != 0) {
uint8_t *dp_tmp = (uint8_t *)_dest_ptr;
uint8_t *sp_tmp = (uint8_t *)_src_ptr;
while(len-- != 0) {
*dp_tmp++ = *sp_tmp++;
if (++_byte_fraction == ScaleSize) {
_ch_fraction = (_ch_fraction + 1) % _channel_num;
_byte_fraction = 0;
dp_tmp = (uint8_t *)r->lbp[index1] + offset;
dp_tmp = (uint8_t *)_ch_data[_ch_fraction][index0].lbp[index1] + offset;
}
}
_dest_wrt_ptr = dp_tmp + _byte_fraction;
_dest_ptr = dp_tmp + _byte_fraction;
}
_real_sample_count = _sample_count / RootNodeSamples * RootNodeSamples;
}
void LogicSnapshot::append_split_payload(const sr_datafeed_logic &logic)
{
{
assert(logic.format == LA_SPLIT_DATA);
uint64_t samples = logic.length * 8;
uint16_t order = logic.order;
assert(logic.format == LA_SPLIT_DATA);
assert(order < _ch_data.size());
assert(order < _ch_data.size());
if (_sample_cnt[order] >= _total_sample_count)
return;
if (_sample_cnt[order] + samples < _total_sample_count) {
_sample_cnt[order] += samples;
}
else {
} else {
samples = _total_sample_count - _sample_cnt[order];
_sample_cnt[order] = _total_sample_count;
}
@@ -431,18 +401,18 @@ void LogicSnapshot::append_split_payload(const sr_datafeed_logic &logic)
while (_sample_cnt[order] > _block_cnt[order] * LeafBlockSamples) {
uint8_t index0 = _block_cnt[order] / RootScale;
uint8_t index1 = _block_cnt[order] % RootScale;
RootNode *r = _ch_data[order][index0];
if (r->lbp[index1] == NULL){
r->lbp[index1] = malloc(LeafBlockSpace);
if (r->lbp[index1] == NULL){
if (_ch_data[order][index0].lbp[index1] == NULL)
{
_ch_data[order][index0].lbp[index1] = malloc(LeafBlockSpace);
if (_ch_data[order][index0].lbp[index1] == NULL)
{
_memory_failed = true;
return;
}
}
memset(r->lbp[index1], 0, LeafBlockSpace);
memset(_ch_data[order][index0].lbp[index1], 0, LeafBlockSpace);
_block_cnt[order]++;
}
@@ -450,13 +420,11 @@ void LogicSnapshot::append_split_payload(const sr_datafeed_logic &logic)
const uint64_t index0 = _ring_sample_cnt[order] / RootNodeSamples;
const uint64_t index1 = (_ring_sample_cnt[order] >> LeafBlockPower) % RootScale;
const uint64_t offset = (_ring_sample_cnt[order] % LeafBlockSamples) / 8;
RootNode *r = _ch_data[order][index0];
_dest_wrt_ptr = (uint8_t *)r->lbp[index1] + offset;
_dest_ptr = (uint8_t *)_ch_data[order][index0].lbp[index1] + offset;
uint64_t bblank = (LeafBlockSamples - (_ring_sample_cnt[order] & LeafMask));
if (samples >= bblank) {
memcpy((uint8_t*)_dest_wrt_ptr, (uint8_t *)logic.data, bblank/8);
memcpy((uint8_t*)_dest_ptr, (uint8_t *)logic.data, bblank/8);
_ring_sample_cnt[order] += bblank;
samples -= bblank;
@@ -464,20 +432,18 @@ void LogicSnapshot::append_split_payload(const sr_datafeed_logic &logic)
calc_mipmap(order, index0, index1, LeafBlockSamples);
// calc root of current block
if (*((uint64_t *)r->lbp[index1]) != 0)
r->value += 1ULL<< index1;
if (*((uint64_t *)r->lbp[index1] + LeafBlockSpace / sizeof(uint64_t) - 1) != 0) {
r->tog += 1ULL << index1;
}
else {
if (*((uint64_t *)_ch_data[order][index0].lbp[index1]) != 0)
_ch_data[order][index0].value += 1ULL<< index1;
if (*((uint64_t *)_ch_data[order][index0].lbp[index1] + LeafBlockSpace / sizeof(uint64_t) - 1) != 0) {
_ch_data[order][index0].tog += 1ULL << index1;
} else {
// trim leaf to free space
free(r->lbp[index1]);
r->lbp[index1] = NULL;
free(_ch_data[order][index0].lbp[index1]);
_ch_data[order][index0].lbp[index1] = NULL;
}
}
else {
memcpy((uint8_t*)_dest_wrt_ptr, (uint8_t *)logic.data, samples/8);
} else {
memcpy((uint8_t*)_dest_ptr, (uint8_t *)logic.data, samples/8);
_ring_sample_cnt[order] += samples;
samples = 0;
}
@@ -488,18 +454,16 @@ void LogicSnapshot::append_split_payload(const sr_datafeed_logic &logic)
}
void LogicSnapshot::calc_mipmap(unsigned int order, uint8_t index0, uint8_t index1, uint64_t samples)
{
{
uint8_t offset;
uint64_t *src_ptr;
uint64_t *dest_ptr;
unsigned int i;
RootNode *r = _ch_data[order][index0];
// level 1
src_ptr = (uint64_t *)r->lbp[index1];
src_ptr = (uint64_t *)_ch_data[order][index0].lbp[index1];
dest_ptr = src_ptr + (LeafBlockSamples / Scale) - 1;
const uint64_t mask = 1ULL << (Scale - 1);
for(i = 0; i < samples / Scale; i++) {
offset = i % Scale;
if (offset == 0)
@@ -510,9 +474,8 @@ void LogicSnapshot::calc_mipmap(unsigned int order, uint8_t index0, uint8_t inde
}
// level 2/3
src_ptr = (uint64_t *)r->lbp[index1] + (LeafBlockSamples / Scale);
src_ptr = (uint64_t *)_ch_data[order][index0].lbp[index1] + (LeafBlockSamples / Scale);
dest_ptr = src_ptr + (LeafBlockSamples / Scale / Scale) - 1;
for(i = LeafBlockSamples / Scale; i < LeafBlockSpace / sizeof(uint64_t) - 1; i++) {
offset = i % Scale;
if (offset == 0)
@@ -534,24 +497,16 @@ const uint8_t *LogicSnapshot::get_samples(uint64_t start_sample, uint64_t &end_s
uint64_t root_index = start_sample >> (LeafBlockPower + RootScalePower);
uint8_t root_pos = (start_sample & RootMask) >> LeafBlockPower;
uint64_t block_offset = (start_sample & LeafMask) / 8;
end_sample = (root_index << (LeafBlockPower + RootScalePower)) +
(root_pos << LeafBlockPower) +
~(~0ULL << LeafBlockPower);
end_sample = min(end_sample + 1, get_sample_count());
RootNode *r = NULL;
if (order >= 0){
r = _ch_data[order][root_index];
}
if (r == NULL || r->lbp[root_pos] == NULL){
if (order == -1 ||
_ch_data[order][root_index].lbp[root_pos] == NULL)
return NULL;
}
else{
return (uint8_t *)r->lbp[root_pos] + block_offset;
}
else
return (uint8_t *)_ch_data[order][root_index].lbp[root_pos] + block_offset;
}
bool LogicSnapshot::get_sample(uint64_t index, int sig_index)
@@ -565,17 +520,14 @@ bool LogicSnapshot::get_sample(uint64_t index, int sig_index)
uint64_t root_index = index >> (LeafBlockPower + RootScalePower);
uint8_t root_pos = (index & RootMask) >> LeafBlockPower;
uint64_t root_pos_mask = 1ULL << root_pos;
RootNode *r = _ch_data[order][root_index];
if ((r->tog & root_pos_mask) == 0) {
return (r->value & root_pos_mask) != 0;
}
else {
uint64_t *lbp = (uint64_t *)r->lbp[root_pos];
if ((_ch_data[order][root_index].tog & root_pos_mask) == 0) {
return (_ch_data[order][root_index].value & root_pos_mask) != 0;
} else {
uint64_t *lbp = (uint64_t *)_ch_data[order][root_index].lbp[root_pos];
return *(lbp + ((index & LeafMask) >> ScalePower)) & index_mask;
}
}
else {
} else {
return false;
}
}
@@ -604,7 +556,6 @@ bool LogicSnapshot::get_display_edges(std::vector<std::pair<bool, bool> > &edges
// Get the initial state
start_sample = last_sample = get_sample(index++, sig_index);
togs.push_back(pair<uint16_t, bool>(0, last_sample));
while(edges.size() < width) {
// search next edge
bool has_edge = get_nxt_edge(index, last_sample, end, 0, sig_index);
@@ -612,10 +563,8 @@ bool LogicSnapshot::get_display_edges(std::vector<std::pair<bool, bool> > &edges
// calc the edge position
int64_t gap = (index / min_length) - pixels_offset;
index = max((uint64_t)ceil((floor(index/min_length) + 1) * min_length), index + 1);
while(gap > (int64_t)edges.size() && edges.size() < width){
while(gap > (int64_t)edges.size() && edges.size() < width)
edges.push_back(pair<bool, bool>(false, last_sample));
}
if (index > end)
last_sample = get_sample(end, sig_index);
@@ -660,37 +609,28 @@ bool LogicSnapshot::get_nxt_edge(
// linear search for the next transition on the root level
for (int64_t i = root_index; !edge_hit && (index <= end) && i < (int64_t)_ch_data[order].size(); i++) {
uint64_t cur_mask = (~0ULL << root_pos);
RootNode *r = _ch_data[order][i];
do {
uint64_t cur_tog = r->tog & cur_mask;
uint64_t cur_tog = _ch_data[order][i].tog & cur_mask;
if (cur_tog != 0) {
uint64_t first_edge_pos = bsf_folded(cur_tog);
uint64_t *lbp = (uint64_t *)r->lbp[first_edge_pos];
uint64_t *lbp = (uint64_t *)_ch_data[order][i].lbp[first_edge_pos];
uint64_t blk_start = (i << (LeafBlockPower + RootScalePower)) + (first_edge_pos << LeafBlockPower);
index = max(blk_start, index);
if (min_level < ScaleLevel) {
uint64_t block_end = min(index | LeafMask, end);
edge_hit = block_nxt_edge(lbp, index, block_end, last_sample, min_level);
}
else {
} else {
edge_hit = true;
}
if (first_edge_pos == RootScale - 1)
break;
cur_mask = (~0ULL << (first_edge_pos + 1));
}
else {
} else {
index = (index + (1 << (LeafBlockPower + RootScalePower))) &
(~0ULL << (LeafBlockPower + RootScalePower));
break;
}
}
while (!edge_hit && index < end);
} while (!edge_hit && index < end);
root_pos = 0;
}
return edge_hit;
@@ -714,34 +654,26 @@ bool LogicSnapshot::get_pre_edge(uint64_t &index, bool last_sample,
// linear search for the previous transition on the root level
for (int64_t i = root_index; !edge_hit && i >= 0; i--) {
uint64_t cur_mask = (~0ULL >> (RootScale - root_pos - 1));
RootNode *r = _ch_data[order][i];
do {
uint64_t cur_tog = r->tog & cur_mask;
uint64_t cur_tog = _ch_data[order][i].tog & cur_mask;
if (cur_tog != 0) {
uint64_t first_edge_pos = bsr64(cur_tog);
uint64_t *lbp = (uint64_t *)r->lbp[first_edge_pos];
uint64_t *lbp = (uint64_t *)_ch_data[order][i].lbp[first_edge_pos];
uint64_t blk_end = ((i << (LeafBlockPower + RootScalePower)) +
(first_edge_pos << LeafBlockPower)) | LeafMask;
index = min(blk_end, index);
if (min_level < ScaleLevel) {
edge_hit = block_pre_edge(lbp, index, last_sample, min_level, sig_index);
}
else {
} else {
edge_hit = true;
}
if (first_edge_pos == 0)
break;
cur_mask = (~0ULL >> (RootScale - first_edge_pos));
}
else {
} else {
break;
}
}
while (!edge_hit);
} while (!edge_hit);
root_pos = RootScale - 1;
}
@@ -766,12 +698,10 @@ bool LogicSnapshot::block_nxt_edge(uint64_t *lbp, uint64_t &index, uint64_t bloc
if (sample ^ last) {
index = (index & ~LevelMask[0]) + bsf_folded(last_sample ? ~sample : sample);
fast_forward = false;
}
else {
} else {
index = ((index >> ScalePower) + 1) << ScalePower;
}
}
else {
} else {
index = ((index >> level*ScalePower) + 1) << level*ScalePower;
}
@@ -1079,12 +1009,11 @@ uint8_t *LogicSnapshot::get_block_buf(int block_index, int sig_index, bool &samp
return NULL;
}
uint64_t index = block_index / RootScale;
RootNode *r = _ch_data[order][index];
uint8_t pos = block_index % RootScale;
uint8_t *lbp = (uint8_t *)r->lbp[pos];
uint8_t *lbp = (uint8_t *)_ch_data[order][index].lbp[pos];
if (lbp == NULL)
sample = (r->value & 1ULL << pos) != 0;
sample = (_ch_data[order][index].value & 1ULL << pos) != 0;
return lbp;
}

10
DSView/pv/data/logicsnapshot.h
View File

@@ -66,9 +66,9 @@ private:
static const uint64_t LevelMask[ScaleLevel];
static const uint64_t LevelOffset[ScaleLevel];
class RootNode
private:
struct RootNode
{
public:
uint64_t tog;
uint64_t value;
void *lbp[Scale];
@@ -186,17 +186,17 @@ private:
}
private:
std::vector<std::vector<class RootNode*>> _ch_data;
std::vector<std::vector<struct RootNode>> _ch_data;
uint64_t _block_num;
uint8_t _byte_fraction;
uint16_t _ch_fraction;
void *_dest_wrt_ptr;
void *_src_ptr;
void *_dest_ptr;
uint64_t _sample_cnt[LOGIC_TMP_BUF_MAX_SIZE];
uint64_t _block_cnt[LOGIC_TMP_BUF_MAX_SIZE];
uint64_t _ring_sample_cnt[LOGIC_TMP_BUF_MAX_SIZE];
uint64_t _last_sample[LOGIC_TMP_BUF_MAX_SIZE];
uint64_t _rootnode_size;
friend class LogicSnapshotTest::Pow2;
friend class LogicSnapshotTest::Basic;