kuntz
/
compress
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

fixes

This commit is contained in:
kuntz 2021-02-17 21:19:18 -06:00
parent 4f55363035
commit 1b51cc3bb7
4 changed files with 455 additions and 318 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

437
compress.c
View File

@ -96,13 +96,23 @@ static void check(void)
exit(EXIT_FAILURE);
}
s8 buf[2048];
sprintf(buf, "VERIFICATION: find_hash(128), find_p_hash(");
for (ui j=0;j<CUTS_LENGTH;j++)
{
sprintf(&buf[strlen(buf)], "%u, ", CHAIN_CUTS[j]);
}
buf[strlen(buf) - 2] = ')';
buf[strlen(buf) - 1] = 0;
puts(buf);
u64 total = 0;
const u64 start = tick();
for (u64 i=0;i<SAMPLES_PER_TEST;i++)
{
if (i & 1)
if ((i & 3) == 1)
{
const r64 m = (tick() - start) / 60000.;
const r64 pm = i / m;
@ -142,6 +152,91 @@ static void check(void)
sem_post(&csoutput);
}
//----------------------------------------------------------------------------------------------------------------------
static u64 find_hash(ui * const restrict distance, u8 * const restrict output_block, u8 const * const restrict input_block, u64 * const restrict v, u64 * const restrict m, u8 const * const restrict input_iv, const u64 block_n, const ui limit)
{
u64 best_n = 0;
ui best_distance = 0;
const u64 total_n = (u64)1 << (limit - 1);
u64 RO_IV[16];
memcpy(RO_IV, input_iv, 128);
for (ui i=0;i<16;i++)
{
RO_IV[i] += BLAKE_IV * block_n;
}
memcpy(m, input_iv, 128);
for (u64 n=0;n<total_n;n++)
{
u8 block[128];
hash(block, RO_IV, v, m, input_block);
const si dist = labs(get_hash_score(block));
if (dist > best_distance)
{
best_n = n;
best_distance = dist;
}
for (ui i=0;i<16;i++)
{
m[i] += BLAKE_IV;
}
}
memcpy(m, input_iv, 128);
for (ui i=0;i<16;i++)
{
m[i] += BLAKE_IV * best_n;
}
hash(output_block, RO_IV, v, m, input_block);
si temp_distance = get_hash_score(output_block);
if (temp_distance < 0)
{
for (ui i=0;i<128;i++)
{
output_block[i] = ~output_block[i];
}
temp_distance = -temp_distance;
}
if (temp_distance != best_distance)
{
printf("ERROR: temp_distance [%d] != best_distance [%u]\nHash confirmation failed!!\n", temp_distance, best_distance);
fflush(0);
exit(EXIT_FAILURE);
}
if (distance)
{
*distance = temp_distance;
}
return best_n;
}
//----------------------------------------------------------------------------------------------------------------------
static void hash(u8 * const restrict block, u64 const * const restrict RO_IV, u64 * const v, u64 const * const restrict m, u8 const * const restrict input_block)
{
u8 const * const restrict vp = (u8 *)v;
memcpy(v, RO_IV, 128);
blake2b(v, m);
for (ui i=0;i<128;i++)
{
block[i] = vp[i] ^ input_block[i];
}
}
//----------------------------------------------------------------------------------------------------------------------
static u64 find_p_hash(ui * const restrict distance, u8 * const restrict output_block, u8 const * const restrict input_block, u64 * const restrict v, u64 * const restrict m, u8 const * const restrict input_iv, const u64 block_n, const u8 cutoff, const ui limit)
{
u64 best_n = 0;
@ -163,12 +258,12 @@ static u64 find_p_hash(ui * const restrict distance, u8 * const restrict output_
u8 block[128];
p_hash(block, RO_IV, v, m, cutoff, input_block);
const si distance = labs(get_hash_score(block));
const si dist = labs(get_hash_score(block));
if (distance > best_distance)
if (dist > best_distance)
{
best_n = n;
best_distance = distance;
best_distance = dist;
}
for (ui i=0;i<16;i++)
@ -244,7 +339,7 @@ static void p_hash(u8 * const restrict block, u64 const * const restrict RO_IV,
}
}
//----------------------------------------------------------------------------------------------------------------------
static u64 find_hash2(ui * const restrict distance, u8 * const restrict output_block, u8 const * const restrict input_block, u64 * const restrict v, u64 * const restrict m, u8 const * const restrict input_iv, const u64 block_n, const r64 lbit_p, const r64 rbit_p, const ui limit)
static u64 find_p_hash2(ui * const restrict distance, u8 * const restrict output_block, u8 const * const restrict input_block, u64 * const restrict v, u64 * const restrict m, u8 const * const restrict input_iv, const u64 block_n, const ui cutoff, const ui limit)
{
u64 best_n = 0;
ui best_distance = 0;
@ -263,14 +358,14 @@ static u64 find_hash2(ui * const restrict distance, u8 * const restrict output_b
for (u64 n=0;n<total_n;n++)
{
u8 block[128];
hash2(block, RO_IV, v, m, lbit_p, rbit_p, input_block);
p_hash2(block, RO_IV, v, m, cutoff, input_block);
const si distance = labs(get_hash_score(block));
const si dist = labs(get_hash_score(block));
if (distance > best_distance)
if (dist > best_distance)
{
best_n = n;
best_distance = distance;
best_distance = dist;
}
for (ui i=0;i<16;i++)
@ -286,7 +381,7 @@ static u64 find_hash2(ui * const restrict distance, u8 * const restrict output_b
m[i] += BLAKE_IV * best_n;
}
hash2(output_block, RO_IV, v, m, lbit_p, rbit_p, input_block);
p_hash2(output_block, RO_IV, v, m, cutoff, input_block);
si temp_distance = get_hash_score(output_block);
@ -315,146 +410,41 @@ static u64 find_hash2(ui * const restrict distance, u8 * const restrict output_b
return best_n;
}
//----------------------------------------------------------------------------------------------------------------------
static void hash2(u8 * const restrict block, u64 const * const restrict RO_IV, u64 * const v, u64 const * const restrict m, const r64 lbit_p, const r64 rbit_p, u8 const * const restrict input_block)
static void p_hash2(u8 * const restrict block, u64 const * const restrict RO_IV, u64 * const v, u64 const * const restrict m, const ui cutoff, u8 const * const restrict input_block)
{
u8 const * const restrict vp = (u8 *)v;
memcpy(v, RO_IV, 128);
memset(block, 0, 128);
blake2b(v, m);
ui p = 0;
const r64 unit = (lbit_p - rbit_p) / 127.;
u8 const * vp = (u8 *)v;
u8 const * const vl = &vp[128];
vp -= 2;
for (ui i=0;i<128;i++)
for (ui i=0;i<cutoff;i++)
{
const r64 temp_hash_p = lbit_p - (i * unit);
const u16 cutoff = round(65536 * temp_hash_p);
if (p == 64)
if ((vp += 2) == vl)
{
p = 0;
vp = (u8 *)v;
blake2b(v, m);
}
u8 byte = 0;
u16 word;
memcpy(&word, vp, 2);
for (ui b=0;b<8;b++)
{
u16 n;
memcpy(&n, &vp[p * 2], 2);
const ui random_offset = word & 127;
const ui random_bit = 1 << ((word >> 7) & 7);
p++;
byte <<= 1;
block[random_offset] |= random_bit;
}
if (n < cutoff)
{
byte |= 1;
}
}
block[i] = byte ^ input_block[i];
for (ui i=0;i<128;i++)
{
block[i] ^= input_block[i];
}
}
//----------------------------------------------------------------------------------------------------------------------
static void shuffle(u8 * const restrict block, u64 const * const restrict RO_IV, u64 * const restrict v, u64 const * const restrict m, u8 const * const restrict input_block)
{
memcpy(v, RO_IV, 128);
blake2b(v, m);
memcpy(block, input_block, 128);
ui p = 0;
for (ui i=1023;i;i--)
{
const ui j = rng(v, m, i, &p);
const ui bi = get_bit(block, i);
const ui bj = get_bit(block, j);
set_bit(block, i, bj);
set_bit(block, j, bi);
}
}
//----------------------------------------------------------------------------------------------------------------------
static u64 find_shuffle(u32 * const restrict score, u8 * const restrict output_block, u8 const * const restrict input_block, u64 * const restrict v, u64 * const restrict m, u8 const * const restrict input_iv, const u64 block_n, const ui limit)
{
u64 RO_IV[16];
memcpy(RO_IV, input_iv, 128);
for (ui i=0;i<16;i++)
{
RO_IV[i] += BLAKE_IV * block_n;
}
u64 best_n = 0;
u32 best_score = 0;
const u64 total_n = (u64)1 << (limit - 1);
memcpy(m, input_iv, 128);
for (u64 n=0;n<total_n;n++)
{
u8 block[128];
shuffle(block, RO_IV, v, m, input_block);
const u32 score = labs(get_shuffle_score(block));
if (score > best_score)
{
best_score = score;
best_n = n;
}
for (ui i=0;i<16;i++)
{
m[i] += BLAKE_IV;
}
}
memcpy(m, input_iv, 128);
for (ui i=0;i<16;i++)
{
m[i] += BLAKE_IV * best_n;
}
shuffle(output_block, RO_IV, v, m, input_block);
s32 temp_score = get_shuffle_score(output_block);
if (temp_score < 0)
{
for (ui i=0;i<512;i++)
{
const ui bi = get_bit(output_block, i);
const ui bj = get_bit(output_block, 1023 - i);
set_bit(output_block, i, bj);
set_bit(output_block, 1023 - i, bi);
}
temp_score = -temp_score;
}
if (temp_score != best_score)
{
printf("ERROR: temp_score [%"PRIi32"] != best_score [%"PRIu32"]\nShuffle confirmation failed!!\n", temp_score, best_score);
fflush(0);
exit(EXIT_FAILURE);
}
if (score)
{
*score = temp_score;
}
return best_n;
}
//----------------------------------------------------------------------------------------------------------------------
static u64 find_hash(ui * const restrict distance, u8 * const restrict output_block, u8 const * const restrict input_block, u64 * const restrict v, u64 * const restrict m, u8 const * const restrict input_iv, const u64 block_n, const ui limit)
static u64 find_p_hash3(ui * const restrict distance, u8 * const restrict output_block, u8 const * const restrict input_block, u64 * const restrict v, u64 * const restrict m, u8 const * const restrict input_iv, const u64 block_n, const ui cutoff, const ui limit)
{
u64 best_n = 0;
ui best_distance = 0;
@ -473,14 +463,14 @@ static u64 find_hash(ui * const restrict distance, u8 * const restrict output_bl
for (u64 n=0;n<total_n;n++)
{
u8 block[128];
hash(block, RO_IV, v, m, input_block);
p_hash3(block, RO_IV, v, m, cutoff, input_block);
const si distance = labs(get_hash_score(block));
const si dist = labs(get_hash_score(block));
if (distance > best_distance)
if (dist > best_distance)
{
best_n = n;
best_distance = distance;
best_distance = dist;
}
for (ui i=0;i<16;i++)
@ -496,7 +486,7 @@ static u64 find_hash(ui * const restrict distance, u8 * const restrict output_bl
m[i] += BLAKE_IV * best_n;
}
hash(output_block, RO_IV, v, m, input_block);
p_hash3(output_block, RO_IV, v, m, cutoff, input_block);
si temp_distance = get_hash_score(output_block);
@ -525,17 +515,43 @@ static u64 find_hash(ui * const restrict distance, u8 * const restrict output_bl
return best_n;
}
//----------------------------------------------------------------------------------------------------------------------
static void hash(u8 * const restrict block, u64 const * const restrict RO_IV, u64 * const v, u64 const * const restrict m, u8 const * const restrict input_block)
static void p_hash3(u8 * const restrict block, u64 const * const restrict RO_IV, u64 * const v, u64 const * const restrict m, const ui cutoff, u8 const * const restrict input_block)
{
u8 const * const restrict vp = (u8 *)v;
memcpy(v, RO_IV, 128);
memset(block, 0, 128);
blake2b(v, m);
u8 const * vp = (u8 *)v;
u8 const * const vl = &vp[128];
vp -= 2;
for (ui i=0;i<cutoff;i++)
{
u8 random_offset, random_bit;
do
{
if ((vp += 2) == vl)
{
vp = (u8 *)v;
blake2b(v, m);
}
u16 word;
memcpy(&word, vp, 2);
random_offset = word & 127;
random_bit = 1 << ((word >> 7) & 7);
}
while (block[random_offset] & random_bit);
block[random_offset] |= random_bit;
}
for (ui i=0;i<128;i++)
{
block[i] = vp[i] ^ input_block[i];
block[i] ^= input_block[i];
}
}
//----------------------------------------------------------------------------------------------------------------------
@ -555,26 +571,6 @@ static si get_hash_score(void const * const block)
return 512 - population;
}
//----------------------------------------------------------------------------------------------------------------------
static s32 get_shuffle_score(void const * const restrict block)
{
s32 score = 0, mscore = 0;
for (ui i=0;i<1024;i++)
{
if (!get_bit(block, i))
{
score += i;
}
if (!get_bit(block, 1023 - i))
{
mscore += i;
}
}
return score > mscore ? score : -mscore ;
}
//----------------------------------------------------------------------------------------------------------------------
static void blake2b(u64 * const restrict v, u64 const * const restrict m)
{
#define G(x, y, a, b, c, d) \
@ -720,4 +716,121 @@ static void gen_test_file(s8 const * const restrict filename, const r64 p)
fclose(f);
}
//----------------------------------------------------------------------------------------------------------------------
static void shuffle(u8 * const restrict block, u64 const * const restrict RO_IV, u64 * const restrict v, u64 const * const restrict m, u8 const * const restrict input_block)
{
memcpy(v, RO_IV, 128);
blake2b(v, m);
memcpy(block, input_block, 128);
ui p = 0;
for (ui i=1023;i;i--)
{
const ui j = rng(v, m, i, &p);
const ui bi = get_bit(block, i);
const ui bj = get_bit(block, j);
set_bit(block, i, bj);
set_bit(block, j, bi);
}
}
//----------------------------------------------------------------------------------------------------------------------
static u64 find_shuffle(u32 * const restrict score, u8 * const restrict output_block, u8 const * const restrict input_block, u64 * const restrict v, u64 * const restrict m, u8 const * const restrict input_iv, const u64 block_n, const ui limit)
{
u64 RO_IV[16];
memcpy(RO_IV, input_iv, 128);
for (ui i=0;i<16;i++)
{
RO_IV[i] += BLAKE_IV * block_n;
}
u64 best_n = 0;
u32 best_score = 0;
const u64 total_n = (u64)1 << (limit - 1);
memcpy(m, input_iv, 128);
for (u64 n=0;n<total_n;n++)
{
u8 block[128];
shuffle(block, RO_IV, v, m, input_block);
const u32 score = labs(get_shuffle_score(block));
if (score > best_score)
{
best_score = score;
best_n = n;
}
for (ui i=0;i<16;i++)
{
m[i] += BLAKE_IV;
}
}
memcpy(m, input_iv, 128);
for (ui i=0;i<16;i++)
{
m[i] += BLAKE_IV * best_n;
}
shuffle(output_block, RO_IV, v, m, input_block);
s32 temp_score = get_shuffle_score(output_block);
if (temp_score < 0)
{
for (ui i=0;i<512;i++)
{
const ui bi = get_bit(output_block, i);
const ui bj = get_bit(output_block, 1023 - i);
set_bit(output_block, i, bj);
set_bit(output_block, 1023 - i, bi);
}
temp_score = -temp_score;
}
if (temp_score != best_score)
{
printf("ERROR: temp_score [%"PRIi32"] != best_score [%"PRIu32"]\nShuffle confirmation failed!!\n", temp_score, best_score);
fflush(0);
exit(EXIT_FAILURE);
}
if (score)
{
*score = temp_score;
}
return best_n;
}
//----------------------------------------------------------------------------------------------------------------------
static s32 get_shuffle_score(void const * const restrict block)
{
s32 score = 0, mscore = 0;
for (ui i=0;i<1024;i++)
{
if (!get_bit(block, i))
{
score += i;
}
if (!get_bit(block, 1023 - i))
{
mscore += i;
}
}
return score > mscore ? score : -mscore ;
}
//----------------------------------------------------------------------------------------------------------------------

42
compress.h
View File

@ -66,22 +66,46 @@ static const u64 BLAKE_IV = UINT64_C(0xA54FF53A5F1D36F1);
//----------------------------------------------------------------------------------------------------------------------
static void check(void);
static u64 find_hash(ui * const restrict, u8 * const restrict, u8 const * const restrict, u64 * const restrict, u64 * const restrict, u8 const * const restrict, const u64, const ui);
static u64 find_hash2(ui * const restrict, u8 * const restrict, u8 const * const restrict, u64 * const restrict, u64 * const restrict, u8 const * const restrict, const u64, const r64, const r64, const ui);
static u64 find_p_hash(ui * const restrict, u8 * const restrict, u8 const * const restrict, u64 * const restrict, u64 * const restrict, u8 const * const restrict, const u64, const u8, const ui);
static u64 find_shuffle(u32 * const restrict, u8 * const restrict, u8 const * const restrict, u64 * const restrict, u64 * const restrict, u8 const * const restrict, const u64, const ui);
static u64 find_p_hash2(ui * const restrict, u8 * const restrict, u8 const * const restrict, u64 * const restrict, u64 * const restrict, u8 const * const restrict, const u64, const ui, const ui);
static u64 find_p_hash3(ui * const restrict, u8 * const restrict, u8 const * const restrict, u64 * const restrict, u64 * const restrict, u8 const * const restrict, const u64, const ui, const ui);
static void hash(u8 * const restrict, u64 const * const restrict, u64 * const, u64 const * const restrict, u8 const * const restrict);
static void hash2(u8 * const restrict, u64 const * const restrict, u64 * const, u64 const * const restrict, const r64, const r64, u8 const * const restrict);
static void p_hash(u8 * const restrict, u64 const * const restrict, u64 * const, u64 const * const restrict, const u8, u8 const * const restrict);
static void shuffle(u8 * const restrict, u64 const * const restrict, u64 * const restrict, u64 const * const restrict, u8 const * const restrict);
static void p_hash2(u8 * const restrict, u64 const * const restrict, u64 * const, u64 const * const restrict, const ui, u8 const * const restrict);
static void p_hash3(u8 * const restrict, u64 const * const restrict, u64 * const, u64 const * const restrict, const ui, u8 const * const restrict);
static si get_hash_score(void const * const);
static void blake2b(u64 * const restrict, u64 const * const restrict);
static u64 tick(void);
static void set_bit(void * const restrict, const ui, const ui);
static ui get_bit(void const * const restrict, const ui);
static u16 rng_word(u64 * const, u64 const * const restrict, ui * const restrict);
static u16 rng(u64 * const restrict, u64 const * const restrict, const u16, ui * const restrict);
static s32 get_shuffle_score(void const * const restrict);
static u16 rng_word(u64 * const, u64 const * const restrict, ui * const restrict);
static ui get_bit(void const * const restrict, const ui);
static void set_bit(void * const restrict, const ui, const ui);
static void print_bytes(s8 const * const restrict, void const * const, const ui);
static void print_population(s8 const * const restrict, void const * const);
static void gen_test_file(s8 const * const restrict, const r64);
//----------------------------------------------------------------------------------------------------------------------
static void shuffle(u8 * const restrict, u64 const * const restrict, u64 * const restrict, u64 const * const restrict, u8 const * const restrict);
static u64 find_shuffle(u32 * const restrict, u8 * const restrict, u8 const * const restrict, u64 * const restrict, u64 * const restrict, u8 const * const restrict, const u64, const ui);
static s32 get_shuffle_score(void const * const restrict);
//----------------------------------------------------------------------------------------------------------------------

290
compress4.c
View File

@ -120,7 +120,7 @@ static void check(void)
for (u64 i=0;i<SAMPLES_PER_TEST;i++)
{
if ((i & 7) == 1)
if ((i & 3) == 1)
{
const r64 m = (tick() - start) / 60000.;
const r64 pm = i / m;
@ -166,7 +166,7 @@ static void check(void)
sem_post(&csoutput);
}
//----------------------------------------------------------------------------------------------------------------------
static u64 find_p_hash2(ui * const restrict distance, u8 * const restrict output_block, u8 const * const restrict input_block, u64 * const restrict v, u64 * const restrict m, u8 const * const restrict input_iv, const u64 block_n, const ui cutoff, const ui limit)
static u64 find_hash(ui * const restrict distance, u8 * const restrict output_block, u8 const * const restrict input_block, u64 * const restrict v, u64 * const restrict m, u8 const * const restrict input_iv, const u64 block_n, const ui limit)
{
u64 best_n = 0;
ui best_distance = 0;
@ -185,7 +185,7 @@ static u64 find_p_hash2(ui * const restrict distance, u8 * const restrict output
for (u64 n=0;n<total_n;n++)
{
u8 block[128];
p_hash2(block, RO_IV, v, m, cutoff, input_block);
hash(block, RO_IV, v, m, input_block);
const si dist = labs(get_hash_score(block));
@ -208,7 +208,7 @@ static u64 find_p_hash2(ui * const restrict distance, u8 * const restrict output
m[i] += BLAKE_IV * best_n;
}
p_hash2(output_block, RO_IV, v, m, cutoff, input_block);
hash(output_block, RO_IV, v, m, input_block);
si temp_distance = get_hash_score(output_block);
@ -237,148 +237,17 @@ static u64 find_p_hash2(ui * const restrict distance, u8 * const restrict output
return best_n;
}
//----------------------------------------------------------------------------------------------------------------------
static u64 find_p_hash3(ui * const restrict distance, u8 * const restrict output_block, u8 const * const restrict input_block, u64 * const restrict v, u64 * const restrict m, u8 const * const restrict input_iv, const u64 block_n, const ui cutoff, const ui limit)
static void hash(u8 * const restrict block, u64 const * const restrict RO_IV, u64 * const v, u64 const * const restrict m, u8 const * const restrict input_block)
{
u64 best_n = 0;
ui best_distance = 0;
const u64 total_n = (u64)1 << (limit - 1);
u8 const * const restrict vp = (u8 *)v;
u64 RO_IV[16];
memcpy(RO_IV, input_iv, 128);
for (ui i=0;i<16;i++)
{
RO_IV[i] += BLAKE_IV * block_n;
}
memcpy(m, input_iv, 128);
for (u64 n=0;n<total_n;n++)
{
u8 block[128];
p_hash3(block, RO_IV, v, m, cutoff, input_block);
const si dist = labs(get_hash_score(block));
if (dist > best_distance)
{
best_n = n;
best_distance = dist;
}
for (ui i=0;i<16;i++)
{
m[i] += BLAKE_IV;
}
}
memcpy(m, input_iv, 128);
for (ui i=0;i<16;i++)
{
m[i] += BLAKE_IV * best_n;
}
p_hash3(output_block, RO_IV, v, m, cutoff, input_block);
si temp_distance = get_hash_score(output_block);
if (temp_distance < 0)
{
for (ui i=0;i<128;i++)
{
output_block[i] = ~output_block[i];
}
temp_distance = -temp_distance;
}
if (temp_distance != best_distance)
{
printf("ERROR: temp_distance [%d] != best_distance [%u]\nHash confirmation failed!!\n", temp_distance, best_distance);
fflush(0);
exit(EXIT_FAILURE);
}
if (distance)
{
*distance = temp_distance;
}
return best_n;
}
//----------------------------------------------------------------------------------------------------------------------
static void p_hash2(u8 * const restrict block, u64 const * const restrict RO_IV, u64 * const v, u64 const * const restrict m, const ui cutoff, u8 const * const restrict input_block)
{
memcpy(v, RO_IV, 128);
memset(block, 0, 128);
blake2b(v, m);
u8 const * vp = (u8 *)v;
u8 const * const vl = &vp[128];
vp -= 2;
for (ui i=0;i<cutoff;i++)
{
if ((vp += 2) == vl)
{
vp = (u8 *)v;
blake2b(v, m);
}
u16 word;
memcpy(&word, vp, 2);
const ui random_offset = word & 127;
const ui random_bit = 1 << ((word >> 7) & 7);
block[random_offset] |= random_bit;
}
for (ui i=0;i<128;i++)
{
block[i] ^= input_block[i];
}
}
//----------------------------------------------------------------------------------------------------------------------
static void p_hash3(u8 * const restrict block, u64 const * const restrict RO_IV, u64 * const v, u64 const * const restrict m, const ui cutoff, u8 const * const restrict input_block)
{
memcpy(v, RO_IV, 128);
memset(block, 0, 128);
blake2b(v, m);
u8 const * vp = (u8 *)v;
u8 const * const vl = &vp[128];
vp -= 2;
for (ui i=0;i<cutoff;i++)
{
u8 random_offset, random_bit;
do
{
if ((vp += 2) == vl)
{
vp = (u8 *)v;
blake2b(v, m);
}
u16 word;
memcpy(&word, vp, 2);
random_offset = word & 127;
random_bit = 1 << ((word >> 7) & 7);
}
while (block[random_offset] & random_bit);
block[random_offset] |= random_bit;
}
for (ui i=0;i<128;i++)
{
block[i] ^= input_block[i];
block[i] = vp[i] ^ input_block[i];
}
}
//----------------------------------------------------------------------------------------------------------------------
@ -484,7 +353,7 @@ static void p_hash(u8 * const restrict block, u64 const * const restrict RO_IV,
}
}
//----------------------------------------------------------------------------------------------------------------------
static u64 find_hash(ui * const restrict distance, u8 * const restrict output_block, u8 const * const restrict input_block, u64 * const restrict v, u64 * const restrict m, u8 const * const restrict input_iv, const u64 block_n, const ui limit)
static u64 find_p_hash2(ui * const restrict distance, u8 * const restrict output_block, u8 const * const restrict input_block, u64 * const restrict v, u64 * const restrict m, u8 const * const restrict input_iv, const u64 block_n, const ui cutoff, const ui limit)
{
u64 best_n = 0;
ui best_distance = 0;
@ -503,7 +372,7 @@ static u64 find_hash(ui * const restrict distance, u8 * const restrict output_bl
for (u64 n=0;n<total_n;n++)
{
u8 block[128];
hash(block, RO_IV, v, m, input_block);
p_hash2(block, RO_IV, v, m, cutoff, input_block);
const si dist = labs(get_hash_score(block));
@ -526,7 +395,7 @@ static u64 find_hash(ui * const restrict distance, u8 * const restrict output_bl
m[i] += BLAKE_IV * best_n;
}
hash(output_block, RO_IV, v, m, input_block);
p_hash2(output_block, RO_IV, v, m, cutoff, input_block);
si temp_distance = get_hash_score(output_block);
@ -555,17 +424,148 @@ static u64 find_hash(ui * const restrict distance, u8 * const restrict output_bl
return best_n;
}
//----------------------------------------------------------------------------------------------------------------------
static void hash(u8 * const restrict block, u64 const * const restrict RO_IV, u64 * const v, u64 const * const restrict m, u8 const * const restrict input_block)
static void p_hash2(u8 * const restrict block, u64 const * const restrict RO_IV, u64 * const v, u64 const * const restrict m, const ui cutoff, u8 const * const restrict input_block)
{
u8 const * const restrict vp = (u8 *)v;
memcpy(v, RO_IV, 128);
memset(block, 0, 128);
blake2b(v, m);
u8 const * vp = (u8 *)v;
u8 const * const vl = &vp[128];
vp -= 2;
for (ui i=0;i<cutoff;i++)
{
if ((vp += 2) == vl)
{
vp = (u8 *)v;
blake2b(v, m);
}
u16 word;
memcpy(&word, vp, 2);
const ui random_offset = word & 127;
const ui random_bit = 1 << ((word >> 7) & 7);
block[random_offset] |= random_bit;
}
for (ui i=0;i<128;i++)
{
block[i] = vp[i] ^ input_block[i];
block[i] ^= input_block[i];
}
}
//----------------------------------------------------------------------------------------------------------------------
static u64 find_p_hash3(ui * const restrict distance, u8 * const restrict output_block, u8 const * const restrict input_block, u64 * const restrict v, u64 * const restrict m, u8 const * const restrict input_iv, const u64 block_n, const ui cutoff, const ui limit)
{
u64 best_n = 0;
ui best_distance = 0;
const u64 total_n = (u64)1 << (limit - 1);
u64 RO_IV[16];
memcpy(RO_IV, input_iv, 128);
for (ui i=0;i<16;i++)
{
RO_IV[i] += BLAKE_IV * block_n;
}
memcpy(m, input_iv, 128);
for (u64 n=0;n<total_n;n++)
{
u8 block[128];
p_hash3(block, RO_IV, v, m, cutoff, input_block);
const si dist = labs(get_hash_score(block));
if (dist > best_distance)
{
best_n = n;
best_distance = dist;
}
for (ui i=0;i<16;i++)
{
m[i] += BLAKE_IV;
}
}
memcpy(m, input_iv, 128);
for (ui i=0;i<16;i++)
{
m[i] += BLAKE_IV * best_n;
}
p_hash3(output_block, RO_IV, v, m, cutoff, input_block);
si temp_distance = get_hash_score(output_block);
if (temp_distance < 0)
{
for (ui i=0;i<128;i++)
{
output_block[i] = ~output_block[i];
}
temp_distance = -temp_distance;
}
if (temp_distance != best_distance)
{
printf("ERROR: temp_distance [%d] != best_distance [%u]\nHash confirmation failed!!\n", temp_distance, best_distance);
fflush(0);
exit(EXIT_FAILURE);
}
if (distance)
{
*distance = temp_distance;
}
return best_n;
}
//----------------------------------------------------------------------------------------------------------------------
static void p_hash3(u8 * const restrict block, u64 const * const restrict RO_IV, u64 * const v, u64 const * const restrict m, const ui cutoff, u8 const * const restrict input_block)
{
memcpy(v, RO_IV, 128);
memset(block, 0, 128);
blake2b(v, m);
u8 const * vp = (u8 *)v;
u8 const * const vl = &vp[128];
vp -= 2;
for (ui i=0;i<cutoff;i++)
{
u8 random_offset, random_bit;
do
{
if ((vp += 2) == vl)
{
vp = (u8 *)v;
blake2b(v, m);
}
u16 word;
memcpy(&word, vp, 2);
random_offset = word & 127;
random_bit = 1 << ((word >> 7) & 7);
}
while (block[random_offset] & random_bit);
block[random_offset] |= random_bit;
}
for (ui i=0;i<128;i++)
{
block[i] ^= input_block[i];
}
}
//----------------------------------------------------------------------------------------------------------------------

4
make.sh
View File

@ -2,5 +2,5 @@
# Copyright © 2021 by Brett Kuntz. All rights reserved.
clang compress4.c -o compute -pthread -lm -Wall -Werror -Wfatal-errors -Wno-unused-function -pipe -O3 -flto -fomit-frame-pointer -march=native -mtune=native
#clang compress4.c -o compute4.exe -pthread -lm -Wall -Werror -Wfatal-errors -Wno-unused-function -pipe -O3 -fomit-frame-pointer -march=native -mtune=native
#clang compress4.c -o compute -pthread -lm -Wall -Werror -Wfatal-errors -Wno-unused-function -pipe -O3 -flto -fomit-frame-pointer -march=native -mtune=native
clang compress4.c -o compute.exe -pthread -lm -Wall -Werror -Wfatal-errors -Wno-unused-function -pipe -O3 -fomit-frame-pointer -march=native -mtune=native