Skip to content

Commit 94d11bb

Browse files
danielrhdanielrh
authored
Merge pull request #194 from nyurik/loop-FindLongestMatch
Simplify loop in FindLongestMatch
2 parents 5e582b2 + 59bd97a commit 94d11bb

File tree

1 file changed

+75
-89
lines changed
  • src/enc/backward_references

1 file changed

+75
-89
lines changed

‎src/enc/backward_references/mod.rs‎

Lines changed: 75 additions & 89 deletions
Original file line numberDiff line numberDiff line change
@@ -1655,110 +1655,96 @@ impl<
16551655
let mut is_match_found = false;
16561656
let mut best_score: u64 = out.score;
16571657
let mut best_len: usize = out.len;
1658-
let mut i: usize;
16591658
out.len = 0usize;
16601659
out.len_x_code = 0usize;
1661-
i = 0usize;
16621660
let cur_data = data.split_at(cur_ix_masked).1;
1663-
while i < self.GetHasherCommon.params.num_last_distances_to_check as usize {
1664-
'continue45: loop {
1665-
{
1666-
let backward: usize = distance_cache[i] as usize;
1667-
let mut prev_ix: usize = cur_ix.wrapping_sub(backward);
1668-
if prev_ix >= cur_ix {
1669-
break 'continue45;
1670-
}
1671-
if backward > max_backward {
1672-
break 'continue45;
1673-
}
1674-
prev_ix &= ring_buffer_mask;
1675-
if (cur_ix_masked.wrapping_add(best_len) > ring_buffer_mask
1676-
|| prev_ix.wrapping_add(best_len) > ring_buffer_mask
1677-
|| cur_data[best_len] != data[prev_ix.wrapping_add(best_len)])
1678-
{
1679-
break 'continue45;
1661+
for i in 0..self.GetHasherCommon.params.num_last_distances_to_check as usize {
1662+
let backward: usize = distance_cache[i] as usize;
1663+
let mut prev_ix: usize = cur_ix.wrapping_sub(backward);
1664+
if prev_ix >= cur_ix || backward > max_backward {
1665+
continue;
1666+
}
1667+
prev_ix &= ring_buffer_mask;
1668+
if (cur_ix_masked.wrapping_add(best_len) > ring_buffer_mask
1669+
|| prev_ix.wrapping_add(best_len) > ring_buffer_mask
1670+
|| cur_data[best_len] != data[prev_ix.wrapping_add(best_len)])
1671+
{
1672+
continue;
1673+
}
1674+
let prev_data = data.split_at(prev_ix).1;
1675+
1676+
let len = FindMatchLengthWithLimit(prev_data, cur_data, max_length);
1677+
if len >= 3 || (len == 2 && i < 2) {
1678+
let mut score: u64 = BackwardReferenceScoreUsingLastDistance(len, opts);
1679+
if best_score < score {
1680+
if i != 0 {
1681+
score = score.wrapping_sub(BackwardReferencePenaltyUsingLastDistance(i));
16801682
}
1681-
let prev_data = data.split_at(prev_ix).1;
1682-
1683-
let len: usize = FindMatchLengthWithLimit(prev_data, cur_data, max_length);
1684-
if len >= 3usize || len == 2usize && (i < 2usize) {
1685-
let mut score: u64 = BackwardReferenceScoreUsingLastDistance(len, opts);
1686-
if best_score < score {
1687-
if i != 0usize {
1688-
score = score
1689-
.wrapping_sub(BackwardReferencePenaltyUsingLastDistance(i));
1690-
}
1691-
if best_score < score {
1692-
best_score = score;
1693-
best_len = len;
1694-
out.len = best_len;
1695-
out.distance = backward;
1696-
out.score = best_score;
1697-
is_match_found = true;
1698-
}
1699-
}
1683+
if best_score < score {
1684+
best_score = score;
1685+
best_len = len;
1686+
out.len = best_len;
1687+
out.distance = backward;
1688+
out.score = best_score;
1689+
is_match_found = true;
17001690
}
17011691
}
1702-
break;
17031692
}
1704-
i = i.wrapping_add(1);
17051693
}
1706-
{
1707-
let key: u32 = self.HashBytes(cur_data) as u32;
1708-
let common_block_bits = self.specialization.block_bits();
1709-
let num_ref_mut = &mut self.num.slice_mut()[key as usize];
1710-
let num_copy = *num_ref_mut;
1711-
let bucket: &mut [u32] = self
1712-
.buckets
1713-
.slice_mut()
1714-
.split_at_mut((key << common_block_bits) as usize)
1715-
.1
1716-
.split_at_mut(self.specialization.block_size() as usize)
1717-
.0;
1718-
assert!(bucket.len() > self.specialization.block_mask() as usize);
1719-
if num_copy != 0 {
1720-
let down: usize = max(
1721-
i32::from(num_copy) - self.specialization.block_size() as i32,
1722-
0,
1723-
) as usize;
1724-
i = num_copy as usize;
1725-
while i > down {
1726-
i -= 1;
1727-
let mut prev_ix =
1728-
bucket[i & self.specialization.block_mask() as usize] as usize;
1729-
let backward = cur_ix.wrapping_sub(prev_ix);
1730-
prev_ix &= ring_buffer_mask;
1731-
if (cur_ix_masked.wrapping_add(best_len) > ring_buffer_mask
1732-
|| prev_ix.wrapping_add(best_len) > ring_buffer_mask
1733-
|| cur_data[best_len] != data[prev_ix.wrapping_add(best_len)])
1734-
{
1735-
if backward > max_backward {
1736-
break;
1737-
}
1738-
continue;
1739-
}
1694+
1695+
let key: u32 = self.HashBytes(cur_data) as u32;
1696+
let common_block_bits = self.specialization.block_bits();
1697+
let num_ref_mut = &mut self.num.slice_mut()[key as usize];
1698+
let num_copy = *num_ref_mut;
1699+
let bucket: &mut [u32] = self
1700+
.buckets
1701+
.slice_mut()
1702+
.split_at_mut((key << common_block_bits) as usize)
1703+
.1
1704+
.split_at_mut(self.specialization.block_size() as usize)
1705+
.0;
1706+
assert!(bucket.len() > self.specialization.block_mask() as usize);
1707+
if num_copy != 0 {
1708+
let down: usize = max(
1709+
i32::from(num_copy) - self.specialization.block_size() as i32,
1710+
0,
1711+
) as usize;
1712+
let mut i = num_copy as usize;
1713+
while i > down {
1714+
i -= 1;
1715+
let mut prev_ix = bucket[i & self.specialization.block_mask() as usize] as usize;
1716+
let backward = cur_ix.wrapping_sub(prev_ix);
1717+
prev_ix &= ring_buffer_mask;
1718+
if (cur_ix_masked.wrapping_add(best_len) > ring_buffer_mask
1719+
|| prev_ix.wrapping_add(best_len) > ring_buffer_mask
1720+
|| cur_data[best_len] != data[prev_ix.wrapping_add(best_len)])
1721+
{
17401722
if backward > max_backward {
17411723
break;
17421724
}
1743-
let prev_data = data.split_at(prev_ix).1;
1744-
let len = FindMatchLengthWithLimitMin4(prev_data, cur_data, max_length);
1745-
if len != 0 {
1746-
let score: u64 = BackwardReferenceScore(len, backward, opts);
1747-
if best_score < score {
1748-
best_score = score;
1749-
best_len = len;
1750-
out.len = best_len;
1751-
out.distance = backward;
1752-
out.score = best_score;
1753-
is_match_found = true;
1754-
}
1725+
continue;
1726+
}
1727+
if backward > max_backward {
1728+
break;
1729+
}
1730+
let prev_data = data.split_at(prev_ix).1;
1731+
let len = FindMatchLengthWithLimitMin4(prev_data, cur_data, max_length);
1732+
if len != 0 {
1733+
let score: u64 = BackwardReferenceScore(len, backward, opts);
1734+
if best_score < score {
1735+
best_score = score;
1736+
best_len = len;
1737+
out.len = best_len;
1738+
out.distance = backward;
1739+
out.score = best_score;
1740+
is_match_found = true;
17551741
}
17561742
}
17571743
}
1758-
bucket[((num_copy as u32 & (self).specialization.block_mask()) as usize)] =
1759-
cur_ix as u32;
1760-
*num_ref_mut = num_ref_mut.wrapping_add(1);
17611744
}
1745+
bucket[(num_copy as u32 & self.specialization.block_mask()) as usize] = cur_ix as u32;
1746+
*num_ref_mut = num_ref_mut.wrapping_add(1);
1747+
17621748
if !is_match_found && dictionary.is_some() {
17631749
let (_, cur_data) = data.split_at(cur_ix_masked);
17641750
is_match_found = SearchInStaticDictionary(

0 commit comments

Comments
 (0)