dnomd343
/
klotski
mirror of https://github.com/dnomd343/klotski.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

perf: tiny short codec

master
Dnomd343 1 year ago
parent
48a6d17fa8
commit
f1b04b7680
2 changed files with 49 additions and 157 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 15
      src/main.cc
  2. 191
      src/short_code/convert.cc

15
src/main.cc
View File

@ -178,13 +178,13 @@ int main() {
// AllCases::build();
BasicRanges::build();
// std::vector<uint64_t> all_cases;
// for (uint64_t head = 0; head < 16; ++head) {
// for (const auto &range : AllCases::fetch()[head]) {
// all_cases.emplace_back(head << 32 | range);
// }
// }
// std::cout << "test data size: " << all_cases.size() << std::endl;
std::vector<uint64_t> all_cases;
for (uint64_t head = 0; head < 16; ++head) {
for (const auto &range : AllCases::fetch()[head]) {
all_cases.emplace_back(head << 32 | range);
}
}
std::cout << "test data size: " << all_cases.size() << std::endl;
// std::cout << "start benchmark" << std::endl;
auto start_time = clock();
@ -273,6 +273,7 @@ int main() {
for (uint32_t i = 1000000; i < 1010000; ++i) {
ShortCode::tiny_decode(i);
ShortCode::tiny_encode(all_cases[i]);
}
// printf("%09lX\n", ShortCode::tiny_decode(14323231));

191
src/short_code/convert.cc
View File

@ -1,10 +1,7 @@
#include <algorithm>
#include <functional>
#include "common.h"
#include "short_code.h"
#include "basic_ranges.h"
#include "all_cases.h"
#include "short_code.h"
#include "all_cases_offset.h"
#include "basic_ranges_offset.h"
#include "range_prefix_offset.h"
@ -24,14 +21,7 @@ ShortCode::ShortCode(const CommonCode &common_code) { // convert from common cod
}
}
uint64_t ShortCode::fast_decode(uint32_t short_code) { // short code --> common code
auto offset = std::upper_bound( // using binary search
ALL_CASES_OFFSET, ALL_CASES_OFFSET + 16, short_code
) - 1;
uint64_t head = offset - ALL_CASES_OFFSET; // head index
return (head << 32) | AllCases::fetch()[head][short_code - *offset]; // release common code
}
/// NOTE: ensure that input common code is valid !!!
uint32_t ShortCode::fast_encode(uint64_t common_code) { // common code --> short code
auto head = common_code >> 32; // head index
const auto &ranges = AllCases::fetch()[head]; // available ranges
@ -39,170 +29,71 @@ uint32_t ShortCode::fast_encode(uint64_t common_code) { // common code --> short
return ALL_CASES_OFFSET[head] + offset; // release short code
}
void run(uint32_t head, uint32_t prefix, const std::function<bool(uint32_t)>& f) {
/// NOTE: ensure that input short code is valid !!!
uint64_t ShortCode::fast_decode(uint32_t short_code) { // short code --> common code
auto offset = std::upper_bound( // using binary search
ALL_CASES_OFFSET, ALL_CASES_OFFSET + 16, short_code
) - 1;
uint64_t head = offset - ALL_CASES_OFFSET; // head index
return (head << 32) | AllCases::fetch()[head][short_code - *offset]; // release common code
}
/// NOTE: ensure that input common code is valid !!!
uint32_t ShortCode::tiny_encode(uint64_t common_code) { // common code --> short code
/// load head index and range prefix
uint32_t head = common_code >> 32;
uint32_t prefix = (common_code >> 20) & 0xFFF;
/// search for target range
uint32_t offset = 0;
auto index = BASIC_RANGES_OFFSET[prefix];
const auto &basic_ranges = BasicRanges::fetch();
for (auto index = BASIC_RANGES_OFFSET[prefix]; index < basic_ranges.size(); ++index) {
auto target = Common::range_reverse((uint32_t)common_code); // target range
for (; index < basic_ranges.size(); ++index) {
auto broken_offset = Common::check_range(head, basic_ranges[index]);
if (broken_offset) { // case invalid
if (!broken_offset) { // valid case
if (basic_ranges[index] == target) {
break; // found target range
}
++offset; // record sub offset
} else {
auto delta = (uint32_t)1 << (32 - broken_offset * 2); // delta to next possible range
/// !! -> broken
/// ( xx xx xx ) xx xx xx ... (reversed range)
/// +1 00 00 00 ... (delta)
auto next_min = (Common::range_reverse(basic_ranges[index]) & ~(delta - 1)) + delta;
while (Common::range_reverse(basic_ranges[++index]) < next_min); // located next range
--index;
} else {
if (f(basic_ranges[index])) {
// printf("ret -> %09lX\n", (uint64_t)head << 32 | Common::range_reverse(basic_ranges[index]));
return;
}
}
}
return ALL_CASES_OFFSET[head] + RANGE_PREFIX_OFFSET[head][prefix] + offset;
}
#include <iostream>
/// NOTE: ensure that input short code is valid
/// NOTE: ensure that input short code is valid !!!
uint64_t ShortCode::tiny_decode(uint32_t short_code) { // short code --> common code
/// match head index
auto offset = std::upper_bound( // binary search
ALL_CASES_OFFSET, ALL_CASES_OFFSET + 16, short_code
) - 1;
uint64_t head = offset - ALL_CASES_OFFSET; // head index
auto head = offset - ALL_CASES_OFFSET; // head index
short_code -= *offset;
/// match range prefix
offset = std::upper_bound( // binary search
RANGE_PREFIX_OFFSET[head], RANGE_PREFIX_OFFSET[head] + 4096, short_code
) - 1;
uint32_t prefix = offset - RANGE_PREFIX_OFFSET[head]; // range prefix
auto prefix = offset - RANGE_PREFIX_OFFSET[head]; // range prefix
short_code -= *offset;
/// search target range
// const auto &basic_ranges = BasicRanges::fetch();
// for (auto index = BASIC_RANGES_OFFSET[prefix]; index < basic_ranges.size(); ++index) {
//
// auto broken_offset = Common::check_range(head, basic_ranges[index]);
// if (broken_offset) { // case invalid
// auto delta = (uint32_t)1 << (32 - broken_offset * 2); // delta to next possible range
// /// !! -> broken
// /// ( xx xx xx ) xx xx xx ... (reversed range)
// /// +1 00 00 00 ... (delta)
// auto next_min = (Common::range_reverse(basic_ranges[index]) & ~(delta - 1)) + delta;
// while (Common::range_reverse(basic_ranges[++index]) < next_min); // located next range
// --index;
// } else {
//
// if (!short_code--) { // short code approximate
//
// /// found target range
// return head << 32 | Common::range_reverse(basic_ranges[index]);
//
// }
//
// }
//
//
// }
// std::cout << "short code = " << short_code << std::endl;
// return 0;
uint32_t range;
auto lambda = [&short_code, &range](uint32_t dat) -> bool {
// return (!short_code--);
// std::cout << "short code = " << short_code << std::endl;
if (!short_code--) { // short code approximate
// std::cout << "short code reach 0" << std::endl;
range = dat;
return true;
/// found target range
// return head << 32 | Common::range_reverse(basic_ranges[index]);
}
return false;
};
run(head, prefix, lambda);
return (uint64_t)head << 32 | Common::range_reverse(range);
printf("ret -> %09lX\n", (uint64_t)head << 32 | Common::range_reverse(range));
printf("error\n");
return 0; // never reach when input valid
}
/// NOTE: ensure that input common code is valid
uint32_t ShortCode::tiny_encode(uint64_t common_code) { // common code --> short code
// printf("%09lX\n", common_code);
// uint64_t raw = common_code;
uint32_t head = common_code >> 32;
uint32_t prefix = (common_code >> 20) & 0xFFF;
// printf("head = %d\n", head);
// printf("prefix = %X\n", prefix);
uint32_t offset = 0;
auto target = Common::range_reverse((uint32_t)common_code); // target range
// printf("target range: %08X\n", target);
// printf("start search at %d\n", BASIC_RANGES_OFFSET[prefix]);
//
/// search for target range
auto index = BASIC_RANGES_OFFSET[prefix];
const auto &basic_ranges = BasicRanges::fetch();
// auto true_index = std::find(basic_ranges.begin(), basic_ranges.end(), 0x0FF00F34) - basic_ranges.begin();
// printf("true index: %td\n", true_index);
// printf("basic_ranges[1294828] = %08X\n", basic_ranges[1294828]);
for (auto index = BASIC_RANGES_OFFSET[prefix]; index < basic_ranges.size(); ++index) { // traverse basic ranges
uint32_t range = basic_ranges[index];
// bool flag = false;
// if (range == 0x0FF00F34) {
// flag = true;
// std::cout << "get target range" << std::endl;
// std::cout << "check result -> " << Common::check_case(head, range) << std::endl;
// }
// TODO: using Common::check_range
if (Common::check_case(head, range)) { // search for valid cases
// if (flag) {
// std::cout << "check ok" << std::endl;
// }
if (range == target) { // found target range
// std::cout << "sum = " << sum << std::endl;
return ALL_CASES_OFFSET[head] + RANGE_PREFIX_OFFSET[head][prefix] + offset;
}
++offset; // record sub offset
for (; index < basic_ranges.size(); ++index) { // traverse basic ranges
auto broken_offset = Common::check_range(head, basic_ranges[index]);
if (!broken_offset && !short_code--) { // valid case -> short code approximate
break;
}
auto delta = (uint32_t)1 << (32 - broken_offset * 2); // delta to next possible range
auto next_min = (Common::range_reverse(basic_ranges[index]) & ~(delta - 1)) + delta;
while (Common::range_reverse(basic_ranges[++index]) < next_min); // located next range
--index;
}
printf("error\n");
return 0;
return (uint64_t)head << 32 | Common::range_reverse(basic_ranges[index]);
}

Write Preview
Loading…
Cancel
Save