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

update: apply new fast short codec

master
Dnomd343 2 years ago
parent
c530c3f65c
commit
8d82ee362c
8 changed files with 247 additions and 202 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. 38
      src/main.cc
  2. 187
      src/short_code/convert.cc
  3. 100
      src/short_code/data_loader.cc
  4. 2
      src/short_code/offset/all_cases_offset.h
  5. 2
      src/short_code/offset/basic_ranges_offset.h
  6. 2
      src/short_code/offset/range_prefix_offset.h
  7. 22
      src/short_code/short_code.h
  8. 96
      src/short_code/short_code_mark.h

38
src/main.cc
View File

@ -174,8 +174,15 @@ int main() {
// }
// }
// ShortCode::speed_up(ShortCode::FAST);
// AllCases::build();
ShortCode::speed_up(ShortCode::FAST);
AllCases::build();
std::vector<uint64_t> all_cases;
for (uint64_t head = 0; head < 16; ++head) {
for (const auto &range : BasicRanges::fetch()) {
all_cases.emplace_back(head << 32 | range);
}
}
// std::cout << "start benchmark" << std::endl;
auto start_time = clock();
@ -254,21 +261,24 @@ int main() {
// printf("%08X\n", range);
// }
AllCases::build();
for (auto head = 0; head < 16; ++head) {
uint64_t prefix = (uint64_t)head << 32;
for (const auto &range : AllCases::fetch()[head]) {
printf("%09lX\n", prefix | range);
}
}
// AllCases::build();
// for (auto head = 0; head < 16; ++head) {
// uint64_t prefix = (uint64_t)head << 32;
// for (const auto &range : AllCases::fetch()[head]) {
// printf("%09lX\n", prefix | range);
// }
// }
// for (uint32_t i = 0; i < 29334498; ++i) {
for (uint32_t i = 0; i < 29334498; ++i) {
// if (ShortCode::fast_encode(ShortCode::fast_decode(i)) != i) {
// std::cout << "error" << std::endl;
// }
// }
// ShortCode::fast_encode_legacy(i);
// ShortCode::fast_decode(i);
ShortCode::fast_encode(all_cases[i]);
}
// printf("%09lX\n", ShortCode::tiny_decode_demo(14323231));
// printf("%09lX\n", ShortCode::tiny_decode(14323231));
// std::cout << ShortCode::tiny_encode_demo(0x6EC0F8800) << std::endl;
// auto br = BasicRanges::fetch();
@ -302,8 +312,8 @@ int main() {
// printf("%09lX\n", ShortCode::fast_decode(14323231));
// std::cout << ShortCode::fast_encode(0x6EC0F8800) << std::endl;
std::cerr << (clock() - start_time) * 1000 / CLOCKS_PER_SEC << "ms" << std::endl;
// std::cerr << (clock() - start_time) * 1000000 / CLOCKS_PER_SEC << "us" << std::endl;
// std::cerr << (clock() - start_time) * 1000 / CLOCKS_PER_SEC << "ms" << std::endl;
std::cerr << (clock() - start_time) * 1000000 / CLOCKS_PER_SEC << "us" << std::endl;
// std::cout << "complete benchmark" << std::endl;
// pause();

187
src/short_code/convert.cc
View File

@ -1,67 +1,174 @@
#include <algorithm>
#include "common.h"
#include "short_code.h"
#include "basic_ranges.h"
#include "short_code_mark.h"
//#include "short_code_mark.h"
CommonCode ShortCode::to_common_code() const { // convert to common code
if (ShortCode::check_mode() == ShortCode::NORMAL) {
return CommonCode::unsafe_create(tiny_decode(code)); // using normal mode
return CommonCode::unsafe_create(tiny_decode(code)); // normal mode
}
return CommonCode::unsafe_create(all_cases_list[code]); // using fast mode
return CommonCode::unsafe_create(fast_decode(code)); // fast mode
}
ShortCode::ShortCode(const CommonCode &common_code) { // convert from common code
if (ShortCode::check_mode() == ShortCode::NORMAL) {
code = tiny_encode(common_code.unwrap()); // using normal mode
code = tiny_encode(common_code.unwrap()); // normal mode
} else {
code = all_cases_dict[common_code.unwrap()]; // using fast mode
code = fast_encode(common_code.unwrap()); // fast mode
}
}
/// ensure that input common code is valid
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
uint32_t prefix = (common_code >> 24) & 0xFF; // common code range prefix
auto target = Common::range_reverse((uint32_t)common_code); // target range
#include "all_cases.h"
#include "all_cases_offset.h"
#include "basic_ranges_offset.h"
#include "range_prefix_offset.h"
for (int index = 0; index < BASIC_RANGES_INDEX[prefix]; ++index) { // traverse basic ranges
uint32_t range = BasicRanges::fetch()[index + BASIC_RANGES_OFFSET[prefix]];
if (range == target) {
break; // found target range
}
if (Common::check_case(head, range)) { // search for valid cases
++offset; // record sub offset
}
}
return ALL_CASES_OFFSET[head] + RANGE_PREFIX_OFFSET[head][prefix] + offset;
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
}
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
auto offset = std::lower_bound(ranges.begin(), ranges.end(), (uint32_t)common_code) - ranges.begin();
return ALL_CASES_OFFSET[head] + offset; // release short code
}
/// ensure that input common code is valid
//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
// uint32_t prefix = (common_code >> 24) & 0xFF; // common code range prefix
// auto target = Common::range_reverse((uint32_t)common_code); // target range
//
// for (int index = 0; index < BASIC_RANGES_INDEX[prefix]; ++index) { // traverse basic ranges
// uint32_t range = BasicRanges::fetch()[index + BASIC_RANGES_OFFSET[prefix]];
// if (range == target) {
// break; // found target range
// }
// if (Common::check_case(head, range)) { // search for valid cases
// ++offset; // record sub offset
// }
// }
// return ALL_CASES_OFFSET[head] + RANGE_PREFIX_OFFSET[head][prefix] + offset;
//}
/// 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;
//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
uint64_t ShortCode::tiny_decode(uint32_t short_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
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
short_code -= *offset;
/// search target range
const auto &basic_ranges = BasicRanges::fetch();
for (auto index = BASIC_RANGES_OFFSET[prefix]; index < basic_ranges.size(); ++index) {
uint32_t range = basic_ranges[index]; // traverse basic ranges
uint32_t broken = Common::check_range(head, basic_ranges[index]); // check and get broken address
auto range_rev = Common::range_reverse(basic_ranges[index]); // reversed range
if (broken) { // invalid case
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 {
if (!short_code--) { // short code approximate
/// found target range
return head << 32 | range_rev;
}
}
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]];
return 0; // never reach when input valid
}
uint32_t ShortCode::tiny_encode(uint64_t common_code) {
// printf("%09lX\n", 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
const auto &basic_ranges = BasicRanges::fetch();
for (auto index = BASIC_RANGES_OFFSET[prefix]; index < basic_ranges.size(); ++index) { // traverse basic ranges
uint32_t range = basic_ranges[index];
if (Common::check_case(head, range)) { // search for valid cases
if (short_code == 0) {
break; // found target range
if (range == target) { // found target range
return ALL_CASES_OFFSET[head] + RANGE_PREFIX_OFFSET[head][prefix] + offset;
}
--short_code; // short code approximate
++offset; // record sub offset
}
}
return (uint64_t)head << 32 | Common::range_reverse(range); // release common code
return 0;
}

100
src/short_code/data_loader.cc
View File

@ -16,6 +16,10 @@ void ShortCode::speed_up(ShortCode::Mode mode) {
}
if (mode == ShortCode::FAST) { // build fast mode data
build_mappings();
// TODO: confirm AllCases data available
AllCases::build();
} else if (mode == ShortCode::NORMAL && !normal_mode_available) { // build normal mode data
BasicRanges::build(); // blocking function
normal_mode_available = true;
@ -52,20 +56,11 @@ void ShortCode::build_mappings() { // build fast search mappings
map_building.unlock();
}
#include <algorithm>
uint64_t ShortCode::fast_decode(uint32_t short_code) {
auto offset = std::upper_bound(ALL_CASES_OFFSET, ALL_CASES_OFFSET + 16, short_code) - 1; // binary search
uint64_t head = offset - ALL_CASES_OFFSET; // head index
return (head << 32) | AllCases::fetch()[head][short_code - *offset]; // release common code
uint32_t ShortCode::fast_encode_legacy(uint64_t common_code) {
return all_cases_dict[common_code];
}
uint32_t ShortCode::fast_encode(uint64_t common_code) {
auto head = common_code >> 32; // head index
const auto &ranges = AllCases::fetch()[head]; // available ranges
auto offset = std::lower_bound(ranges.begin(), ranges.end(), (uint32_t)common_code) - ranges.begin();
return ALL_CASES_OFFSET[head] + offset; // release short code
}
#include <algorithm>
#include "basic_ranges_offset.h"
#include "range_prefix_offset.h"
@ -73,84 +68,3 @@ uint32_t ShortCode::fast_encode(uint64_t common_code) {
#include <iostream>
#include "common.h"
uint64_t ShortCode::tiny_decode_demo(uint32_t short_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
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
short_code -= *offset;
/// search target range
const auto &basic_ranges = BasicRanges::fetch();
for (auto index = BASIC_RANGES_OFFSET_[prefix]; index < basic_ranges.size(); ++index) {
uint32_t range = basic_ranges[index]; // traverse basic ranges
uint32_t broken = Common::check_range(head, basic_ranges[index]); // check and get broken address
auto range_rev = Common::range_reverse(basic_ranges[index]); // reversed range
if (broken) { // invalid case
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 {
if (!short_code--) { // short code approximate
/// found target range
return head << 32 | range_rev;
}
}
}
return 0; // never reach when input valid
}
uint32_t ShortCode::tiny_encode_demo(uint64_t common_code) {
// printf("%09lX\n", 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
const auto &basic_ranges = BasicRanges::fetch();
for (auto index = BASIC_RANGES_OFFSET_[prefix]; index < basic_ranges.size(); ++index) { // traverse basic ranges
uint32_t range = basic_ranges[index];
if (Common::check_case(head, range)) { // search for valid cases
if (range == target) { // found target range
return ALL_CASES_OFFSET[head] + RANGE_PREFIX_OFFSET_[head][prefix] + offset;
}
++offset; // record sub offset
}
}
return 0;
}

2
src/short_code/offset/all_cases_offset.h
View File

@ -2,7 +2,7 @@
#include <cstdint>
const uint32_t ALL_CASES_OFFSET_[16] = {
const uint32_t ALL_CASES_OFFSET[16] = {
0, 2942906, 5203298, 8146204,
8146204, 10468254, 12345199, 14667249,
14667249, 16989299, 18866244, 21188294,

2
src/short_code/offset/basic_ranges_offset.h
View File

@ -2,7 +2,7 @@
#include <cstdint>
const uint32_t BASIC_RANGES_OFFSET_[4096] = {
const uint32_t BASIC_RANGES_OFFSET[4096] = {
0, 18272, 24960, 31648, 49920, 56608, 59056, 61504,
68192, 74880, 77328, 79776, 86464, 104736, 111424, 118112,
136384, 143072, 145520, 147968, 154656, 157104, 158000, 158896,

2
src/short_code/offset/range_prefix_offset.h
View File

@ -2,7 +2,7 @@
#include <cstdint>
const uint32_t RANGE_PREFIX_OFFSET_[16][4096] = {
const uint32_t RANGE_PREFIX_OFFSET[16][4096] = {
/// --------------------------------- 0x0 ---------------------------------
0, 9527, 12991, 16067, 25594, 29058, 30527, 31657,
35121, 38525, 39766, 41041, 44445, 53972, 57436, 60512,

22
src/short_code/short_code.h
View File

@ -21,6 +21,8 @@ public:
CommonCode to_common_code() const;
static bool check(uint32_t short_code);
// TODO: std::cout << ShortCode(...) << std::endl;
explicit ShortCode(uint32_t short_code);
explicit ShortCode(const CommonCode &common_code);
explicit ShortCode(const std::string &short_code_str);
@ -34,22 +36,34 @@ public:
speed_up(mode);
}
// TODO: mark as private after inner test
static uint64_t fast_decode(uint32_t short_code);
static uint32_t fast_encode(uint64_t common_code);
static uint64_t tiny_decode_demo(uint32_t short_code);
static uint32_t tiny_encode_demo(uint64_t common_code);
static uint64_t tiny_decode(uint32_t short_code);
static uint32_t tiny_encode(uint64_t common_code);
// TODO: ShortCode::create() / ShortCode::from_str(...) / ShortCode::from_common_code(...)
static uint32_t fast_encode_legacy(uint64_t common_code);
private:
uint32_t code;
static std::mutex map_building;
static bool fast_mode_available;
static bool normal_mode_available;
static const uint32_t SHORT_CODE_LIMIT = 29334498;
/// NOTE: using binary search instead of global vector and unordered_map
/// for some test, the new function only using < 170MB memory, while the legacy using > 1.5GB
/// but the legacy one is more easy and a little fast.
/// BTW, the new one init less than 1.2s, legacy one need about 15s
static std::vector<uint64_t> all_cases_list; // short_code -> common_code
static std::unordered_map<uint64_t, uint32_t> all_cases_dict; // common_code -> short_code
static void build_mappings();
static uint64_t tiny_decode(uint32_t short_code);
static uint32_t tiny_encode(uint64_t common_code);
// static uint64_t tiny_decode(uint32_t short_code);
// static uint32_t tiny_encode(uint64_t common_code);
};

96
src/short_code/short_code_mark.h
View File

@ -2,56 +2,56 @@
#include <cstdint>
const uint32_t ALL_CASES_INDEX[16] = {
2942906, 2260392, 2942906, 0,
2322050, 1876945, 2322050, 0,
2322050, 1876945, 2322050, 0,
2942906, 2260392, 2942906, 0,
};
//const uint32_t ALL_CASES_INDEX[16] = {
// 2942906, 2260392, 2942906, 0,
// 2322050, 1876945, 2322050, 0,
// 2322050, 1876945, 2322050, 0,
// 2942906, 2260392, 2942906, 0,
//};
const uint32_t ALL_CASES_OFFSET[16] = {
0, 2942906, 5203298, 8146204,
8146204, 10468254, 12345199, 14667249,
14667249, 16989299, 18866244, 21188294,
21188294, 24131200, 26391592, 29334498,
};
//const uint32_t ALL_CASES_OFFSET[16] = {
// 0, 2942906, 5203298, 8146204,
// 8146204, 10468254, 12345199, 14667249,
// 14667249, 16989299, 18866244, 21188294,
// 21188294, 24131200, 26391592, 29334498,
//};
const uint32_t BASIC_RANGES_INDEX[256] = {
136384, 49920, 49920, 136384, 49920, 18272, 18272, 49920,
49920, 18272, 18272, 49920, 136384, 49920, 49920, 136384,
49920, 18272, 18272, 49920, 18272, 6347, 6347, 17589,
18272, 6347, 6347, 17589, 49920, 17589, 17589, 48555,
49920, 18272, 18272, 49920, 18272, 6347, 6347, 17589,
18272, 6347, 6347, 17589, 49920, 17589, 17589, 48555,
136384, 49920, 49920, 136384, 49920, 17589, 17589, 48555,
49920, 17589, 17589, 48555, 136384, 48555, 48555, 133653,
49920, 18272, 18272, 49920, 18272, 6347, 6347, 17589,
18272, 6347, 6347, 17589, 49920, 17589, 17589, 48555,
18272, 6347, 6347, 17589, 6347, 1785, 1785, 5246,
6347, 1785, 1785, 5246, 17589, 5246, 5246, 15163,
18272, 6347, 6347, 17589, 6347, 1785, 1785, 5246,
6347, 1785, 1785, 5246, 17589, 5246, 5246, 15163,
49920, 17589, 17589, 48555, 17589, 5246, 5246, 15163,
17589, 5246, 5246, 15163, 48555, 15163, 15163, 43244,
49920, 18272, 18272, 49920, 18272, 6347, 6347, 17589,
18272, 6347, 6347, 17589, 49920, 17589, 17589, 48555,
18272, 6347, 6347, 17589, 6347, 1785, 1785, 5246,
6347, 1785, 1785, 5246, 17589, 5246, 5246, 15163,
18272, 6347, 6347, 17589, 6347, 1785, 1785, 5246,
6347, 1785, 1785, 5246, 17589, 5246, 5246, 15163,
49920, 17589, 17589, 48555, 17589, 5246, 5246, 15163,
17589, 5246, 5246, 15163, 48555, 15163, 15163, 43244,
136384, 49920, 49920, 136384, 49920, 17589, 17589, 48555,
49920, 17589, 17589, 48555, 136384, 48555, 48555, 133653,
49920, 17589, 17589, 48555, 17589, 5246, 5246, 15163,
17589, 5246, 5246, 15163, 48555, 15163, 15163, 43244,
49920, 17589, 17589, 48555, 17589, 5246, 5246, 15163,
17589, 5246, 5246, 15163, 48555, 15163, 15163, 43244,
136384, 48555, 48555, 133653, 48555, 15163, 15163, 43244,
48555, 15163, 15163, 43244, 133653, 43244, 43244, 122125,
};
//const uint32_t BASIC_RANGES_INDEX[256] = {
// 136384, 49920, 49920, 136384, 49920, 18272, 18272, 49920,
// 49920, 18272, 18272, 49920, 136384, 49920, 49920, 136384,
// 49920, 18272, 18272, 49920, 18272, 6347, 6347, 17589,
// 18272, 6347, 6347, 17589, 49920, 17589, 17589, 48555,
// 49920, 18272, 18272, 49920, 18272, 6347, 6347, 17589,
// 18272, 6347, 6347, 17589, 49920, 17589, 17589, 48555,
// 136384, 49920, 49920, 136384, 49920, 17589, 17589, 48555,
// 49920, 17589, 17589, 48555, 136384, 48555, 48555, 133653,
// 49920, 18272, 18272, 49920, 18272, 6347, 6347, 17589,
// 18272, 6347, 6347, 17589, 49920, 17589, 17589, 48555,
// 18272, 6347, 6347, 17589, 6347, 1785, 1785, 5246,
// 6347, 1785, 1785, 5246, 17589, 5246, 5246, 15163,
// 18272, 6347, 6347, 17589, 6347, 1785, 1785, 5246,
// 6347, 1785, 1785, 5246, 17589, 5246, 5246, 15163,
// 49920, 17589, 17589, 48555, 17589, 5246, 5246, 15163,
// 17589, 5246, 5246, 15163, 48555, 15163, 15163, 43244,
// 49920, 18272, 18272, 49920, 18272, 6347, 6347, 17589,
// 18272, 6347, 6347, 17589, 49920, 17589, 17589, 48555,
// 18272, 6347, 6347, 17589, 6347, 1785, 1785, 5246,
// 6347, 1785, 1785, 5246, 17589, 5246, 5246, 15163,
// 18272, 6347, 6347, 17589, 6347, 1785, 1785, 5246,
// 6347, 1785, 1785, 5246, 17589, 5246, 5246, 15163,
// 49920, 17589, 17589, 48555, 17589, 5246, 5246, 15163,
// 17589, 5246, 5246, 15163, 48555, 15163, 15163, 43244,
// 136384, 49920, 49920, 136384, 49920, 17589, 17589, 48555,
// 49920, 17589, 17589, 48555, 136384, 48555, 48555, 133653,
// 49920, 17589, 17589, 48555, 17589, 5246, 5246, 15163,
// 17589, 5246, 5246, 15163, 48555, 15163, 15163, 43244,
// 49920, 17589, 17589, 48555, 17589, 5246, 5246, 15163,
// 17589, 5246, 5246, 15163, 48555, 15163, 15163, 43244,
// 136384, 48555, 48555, 133653, 48555, 15163, 15163, 43244,
// 48555, 15163, 15163, 43244, 133653, 43244, 43244, 122125,
//};
const uint32_t BASIC_RANGES_OFFSET[256] = {
const uint32_t BASIC_RANGES_OFFSET_8bits[256] = {
0, 136384, 186304, 236224, 372608, 422528, 440800, 459072,
508992, 558912, 577184, 595456, 645376, 781760, 831680, 881600,
1017984, 1067904, 1086176, 1104448, 1154368, 1172640, 1178987, 1185334,
@ -633,7 +633,7 @@ const uint32_t RANGE_PREFIX_INDEX[16][256] = {
},
};
const uint32_t RANGE_PREFIX_OFFSET[16][256] = {
const uint32_t RANGE_PREFIX_OFFSET_8bits[16][256] = {
{
0, 70039, 70039, 95633, 165672, 191266, 200793, 210117,
235711, 258169, 258169, 267696, 290154, 360193, 360193, 385787,

Write Preview
Loading…
Cancel
Save