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

feat: try lambda in ShortCode tiny codec

legacy
Dnomd343 2 years ago
parent
0c614bd29b
commit
48a6d17fa8
4 changed files with 96 additions and 1327 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 77
      src/main.cc
  2. 155
      src/short_code/convert.cc
  3. 2
      src/short_code/data_loader.cc
  4. 1181
      src/short_code/short_code_mark.h

77
src/main.cc
View File

@ -178,13 +178,13 @@ int main() {
// AllCases::build(); // AllCases::build();
BasicRanges::build(); BasicRanges::build();
std::vector<uint64_t> all_cases; // std::vector<uint64_t> all_cases;
for (uint64_t head = 0; head < 16; ++head) { // for (uint64_t head = 0; head < 16; ++head) {
for (const auto &range : AllCases::fetch()[head]) { // for (const auto &range : AllCases::fetch()[head]) {
all_cases.emplace_back(head << 32 | range); // all_cases.emplace_back(head << 32 | range);
} // }
} // }
std::cout << "test data size: " << all_cases.size() << std::endl; // std::cout << "test data size: " << all_cases.size() << std::endl;
// std::cout << "start benchmark" << std::endl; // std::cout << "start benchmark" << std::endl;
auto start_time = clock(); auto start_time = clock();
@ -271,67 +271,12 @@ int main() {
// } // }
// } // }
// for (uint32_t i = 0; i < 29334498; ++i) { for (uint32_t i = 1000000; i < 1010000; ++i) {
// if (ShortCode::fast_encode(ShortCode::fast_decode(i)) != i) { ShortCode::tiny_decode(i);
// std::cout << "error" << std::endl; }
// }
// ShortCode::fast_encode_legacy(i);
// ShortCode::fast_decode(i);
// ShortCode::fast_encode(all_cases[i]);
// }
// for (uint32_t i = 1000000; i < 1100000; ++i) {
// ShortCode::tiny_decode(i);
// ShortCode::tiny_decode_10b(i);
// ShortCode::tiny_encode(all_cases[i]);
// ShortCode::tiny_encode_10b(all_cases[i]);
// }
// printf("%09lX\n", ShortCode::tiny_decode(14323231)); // printf("%09lX\n", ShortCode::tiny_decode(14323231));
// std::cout << ShortCode::tiny_encode_demo(0x6EC0F8800) << std::endl; // std::cout << ShortCode::tiny_encode(0x6EC0F8800) << std::endl;
// printf("%09lX\n", ShortCode::tiny_decode_10b(14323231));
// std::cout << ShortCode::tiny_encode_10b(0x6EC0F8800) << std::endl;
// auto br = BasicRanges::fetch();
// for (auto &range : br) {
// range = Common::range_reverse(range);
// }
/// 1017983: 0FFFFFFF
/// 1017984: 10000000
/// 1017985: 1000000C
// int sum = 0;
// printf(" ");
// for (uint32_t prefix = 0; prefix < 0x400; ++prefix) {
// printf("%7td, ", std::lower_bound(br.begin(), br.end(), prefix << 22) - br.begin());
// if (sum++ % 8 == 7) {
// printf("\n ");
// }
// }
// const uint32_t TEST[3][4] = {
// {1,1,1,1}, {2,2,}, {3,3,3,}
// };
// for (auto &x : TEST) {
// for (auto &y: x) {
// std::cout << y << std::endl;
// }
// }
// int sum = 0;
// for (int head = 0; head < 16; ++head) {
// auto &a = AllCases::fetch()[head];
// printf("\n/// --------------------------------- 0x%X ---------------------------------\n ", head);
// printf("\n/// --------------------------------------------------------------------- 0x%X ---------------------------------------------------------------------\n ", head);
// for (uint32_t prefix = 0; prefix < 0x1000; ++prefix) {
// printf("%7td, ", std::lower_bound(a.begin(), a.end(), prefix << 20) - a.begin());
// if (sum++ % 16 == 15 and prefix != 0xFFF) {
// printf("\n ");
// }
// }
// }
// printf("\n");
// printf("%09lX\n", ShortCode::fast_decode(14323231)); // printf("%09lX\n", ShortCode::fast_decode(14323231));
// std::cout << ShortCode::fast_encode(0x6EC0F8800) << std::endl; // std::cout << ShortCode::fast_encode(0x6EC0F8800) << std::endl;

155
src/short_code/convert.cc
View File

@ -1,9 +1,13 @@
#include <algorithm> #include <algorithm>
#include <functional>
#include "common.h" #include "common.h"
#include "short_code.h" #include "short_code.h"
#include "basic_ranges.h" #include "basic_ranges.h"
//#include "short_code_mark.h" #include "all_cases.h"
#include "all_cases_offset.h"
#include "basic_ranges_offset.h"
#include "range_prefix_offset.h"
CommonCode ShortCode::to_common_code() const { // convert to common code CommonCode ShortCode::to_common_code() const { // convert to common code
if (ShortCode::check_mode() == ShortCode::NORMAL) { if (ShortCode::check_mode() == ShortCode::NORMAL) {
@ -20,12 +24,7 @@ ShortCode::ShortCode(const CommonCode &common_code) { // convert from common cod
} }
} }
#include "all_cases.h" uint64_t ShortCode::fast_decode(uint32_t short_code) { // short code --> common code
#include "all_cases_offset.h"
#include "basic_ranges_offset.h"
#include "range_prefix_offset.h"
uint64_t ShortCode::fast_decode(uint32_t short_code) { // short code => common code
auto offset = std::upper_bound( // using binary search auto offset = std::upper_bound( // using binary search
ALL_CASES_OFFSET, ALL_CASES_OFFSET + 16, short_code ALL_CASES_OFFSET, ALL_CASES_OFFSET + 16, short_code
) - 1; ) - 1;
@ -33,64 +32,46 @@ uint64_t ShortCode::fast_decode(uint32_t short_code) { // short code => common c
return (head << 32) | AllCases::fetch()[head][short_code - *offset]; // release common code return (head << 32) | AllCases::fetch()[head][short_code - *offset]; // release common code
} }
uint32_t ShortCode::fast_encode(uint64_t common_code) { // common code => short code uint32_t ShortCode::fast_encode(uint64_t common_code) { // common code --> short code
auto head = common_code >> 32; // head index auto head = common_code >> 32; // head index
const auto &ranges = AllCases::fetch()[head]; // available ranges const auto &ranges = AllCases::fetch()[head]; // available ranges
auto offset = std::lower_bound(ranges.begin(), ranges.end(), (uint32_t)common_code) - ranges.begin(); auto offset = std::lower_bound(ranges.begin(), ranges.end(), (uint32_t)common_code) - ranges.begin();
return ALL_CASES_OFFSET[head] + offset; // release short code return ALL_CASES_OFFSET[head] + offset; // release short code
} }
/// ensure that input common code is valid void run(uint32_t head, uint32_t prefix, const std::function<bool(uint32_t)>& f) {
//uint32_t ShortCode::tiny_encode(uint64_t common_code) { // common_code --low-memory--> short_code
// uint32_t offset = 0;
// uint32_t head = common_code >> 32; // common code head const auto &basic_ranges = BasicRanges::fetch();
// uint32_t prefix = (common_code >> 24) & 0xFF; // common code range prefix for (auto index = BASIC_RANGES_OFFSET[prefix]; index < basic_ranges.size(); ++index) {
// auto target = Common::range_reverse((uint32_t)common_code); // target range
// auto broken_offset = Common::check_range(head, basic_ranges[index]);
// for (int index = 0; index < BASIC_RANGES_INDEX[prefix]; ++index) { // traverse basic ranges if (broken_offset) { // case invalid
// uint32_t range = BasicRanges::fetch()[index + BASIC_RANGES_OFFSET[prefix]]; auto delta = (uint32_t)1 << (32 - broken_offset * 2); // delta to next possible range
// if (range == target) { /// !! -> broken
// break; // found target range /// ( xx xx xx ) xx xx xx ... (reversed range)
// } /// +1 00 00 00 ... (delta)
// if (Common::check_case(head, range)) { // search for valid cases auto next_min = (Common::range_reverse(basic_ranges[index]) & ~(delta - 1)) + delta;
// ++offset; // record sub offset while (Common::range_reverse(basic_ranges[++index]) < next_min); // located next range
// } --index;
// } } else {
// return ALL_CASES_OFFSET[head] + RANGE_PREFIX_OFFSET[head][prefix] + offset;
//} if (f(basic_ranges[index])) {
/// ensure that input short code is valid
//uint64_t ShortCode::tiny_decode(uint32_t short_code) { // short_code --low-memory--> common_code
// uint32_t head = 0, prefix = 0;
// for (; head < 16; ++head) {
// if (short_code < ALL_CASES_INDEX[head]) { // match head
// break;
// }
// short_code -= ALL_CASES_INDEX[head]; // short code approximate
// }
// for (; prefix < 256; ++prefix) {
// if (short_code < RANGE_PREFIX_INDEX[head][prefix]) { // match range prefix
// break;
// }
// short_code -= RANGE_PREFIX_INDEX[head][prefix]; // short code approximate
// }
//
// uint32_t range;
// for (int index = 0; index < BASIC_RANGES_INDEX[prefix]; ++index) { // traverse basic ranges
// range = BasicRanges::fetch()[index + BASIC_RANGES_OFFSET[prefix]];
// if (Common::check_case(head, range)) { // search for valid cases
// if (short_code == 0) {
// break; // found target range
// }
// --short_code; // short code approximate
// }
// }
// return (uint64_t)head << 32 | Common::range_reverse(range); // release common code
//}
// TODO: try to using 10-bits range prefix -> less static data // printf("ret -> %09lX\n", (uint64_t)head << 32 | Common::range_reverse(basic_ranges[index]));
uint64_t ShortCode::tiny_decode(uint32_t short_code) { return;
}
}
}
}
#include <iostream>
/// NOTE: ensure that input short code is valid
uint64_t ShortCode::tiny_decode(uint32_t short_code) { // short code --> common code
/// match head index /// match head index
auto offset = std::upper_bound( // binary search auto offset = std::upper_bound( // binary search
ALL_CASES_OFFSET, ALL_CASES_OFFSET + 16, short_code ALL_CASES_OFFSET, ALL_CASES_OFFSET + 16, short_code
@ -106,41 +87,65 @@ uint64_t ShortCode::tiny_decode(uint32_t short_code) {
short_code -= *offset; short_code -= *offset;
/// search target range /// search target range
const auto &basic_ranges = BasicRanges::fetch(); // const auto &basic_ranges = BasicRanges::fetch();
for (auto index = BASIC_RANGES_OFFSET[prefix]; index < basic_ranges.size(); ++index) { // 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]);
//
// }
//
// }
//
//
// }
uint32_t range = basic_ranges[index]; // traverse basic ranges // std::cout << "short code = " << short_code << std::endl;
// return 0;
uint32_t broken = Common::check_range(head, basic_ranges[index]); // check and get broken address uint32_t range;
auto range_rev = Common::range_reverse(basic_ranges[index]); // reversed range auto lambda = [&short_code, &range](uint32_t dat) -> bool {
if (broken) { // invalid case // return (!short_code--);
auto delta = (uint32_t)1 << (32 - broken * 2); // this --delta--> next possible range
auto next_min = (range_rev & ~(delta - 1)) + delta;
while (Common::range_reverse(basic_ranges[++index]) < next_min); // located next range
--index;
} else {
// std::cout << "short code = " << short_code << std::endl;
if (!short_code--) { // short code approximate if (!short_code--) { // short code approximate
// std::cout << "short code reach 0" << std::endl;
range = dat;
return true;
/// found target range /// found target range
return head << 32 | range_rev; // 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"); printf("error\n");
return 0; // never reach when input valid return 0; // never reach when input valid
} }
#include <iostream> /// NOTE: ensure that input common code is valid
uint32_t ShortCode::tiny_encode(uint64_t common_code) { // common code --> short code
uint32_t ShortCode::tiny_encode(uint64_t common_code) {

2
src/short_code/data_loader.cc
View File

@ -1,7 +1,7 @@
#include "all_cases.h" #include "all_cases.h"
#include "short_code.h" #include "short_code.h"
#include "basic_ranges.h" #include "basic_ranges.h"
#include "short_code_mark.h" //#include "short_code_mark.h"
//std::mutex ShortCode::map_building; //std::mutex ShortCode::map_building;
bool ShortCode::fast_mode_available = false; bool ShortCode::fast_mode_available = false;

1181
src/short_code/short_code_mark.h
View File

File diff suppressed because it is too large
Write Preview
Loading…
Cancel
Save