"""
//===-- Table Generator for Ryu Printf ------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
This file is used to generate the tables of values in
src/__support/ryu_constants.h and ryu_long_double constants.h. To use it, set
the constants at the top of the file to the values you want to use for the Ryu
algorithm, then run this file. It will output the appropriate tables to stdout,
so it's recommended to pipe stdout to a file. The following is a brief
explenation of each of the constants.
BLOCK_SIZE:
Default: 9
The number of digits that will be calculated together in a block.
Don't touch this unless you really know what you're doing.
CONSTANT:
Default: 120
Also known as c_0 and c_1 in the Ryu Printf paper and SHIFT_CONST in
float_to_string.h.
The table value is shifted left by this amount, and the final value is
shifted right by this amount. It effectively makes the table value a fixed
point number with the decimal point at the bit that is CONSTANT bits from
the right.
Higher values increase accuracy, but also require higher MID_INT_WIDTH
values to fit the result.
IDX_SIZE:
Default: 16
By increasing the MOD_SIZE slightly we can significantly decrease the number
of table entries we need.
We can divide the number of table entries by IDX_SIZE, and multiply MOD_SIZE
by 2^IDX_SIZE, and the math still works out.
This optimization isn't mentioned in the original Ryu Printf paper but it
saves a lot of space.
MID_INT_WIDTH:
Default: 192
This is the size of integer that the tables use. It's called mid int because
it's the integer used in the middle of the calculation. There are large ints
used to calculate the mid int table values, then those are used to calculate
the small int final values.
This must be divisible by 64 since each table entry is an array of 64 bit
integers.
If this is too small, then the results will get cut off. It should be at
least CONSTANT + IDX_SIZE + log_2(10^9) to be able to fit the table values.
MANT_WIDTH:
The width of the widest float mantissa that this table will work for.
This has a small effect on table size.
EXP_WIDTH:
The width of the widest float exponent that this table will work for.
This has a large effect on table size.
Specifically, table size is proportional to the square of this number.
"""
BLOCK_SIZE = 9
# Values for double
# CONSTANT = 120
# IDX_SIZE = 16
# MANT_WIDTH = 52
# EXP_WIDTH = 11
# MID_INT_SIZE = 192
# Values for 128 bit float
CONSTANT = 120
IDX_SIZE = 128
MANT_WIDTH = 112
EXP_WIDTH = 15
MID_INT_SIZE = 256 + 64
MAX_EXP = 2 ** (EXP_WIDTH - 1)
POSITIVE_ARR_SIZE = MAX_EXP // IDX_SIZE
NEGATIVE_ARR_SIZE = (MAX_EXP // IDX_SIZE) + ((MANT_WIDTH + (IDX_SIZE - 1)) // IDX_SIZE)
MOD_SIZE = (10**BLOCK_SIZE) << (CONSTANT + (IDX_SIZE if IDX_SIZE > 1 else 0))
# floor(5^(-9i) * 2^(e + c_1 - 9i) + 1) % (10^9 * 2^c_1)
def get_table_positive(exponent, i):
pow_of_two = 1 << (exponent + CONSTANT - (BLOCK_SIZE * i))
pow_of_five = 5 ** (BLOCK_SIZE * i)
result = (pow_of_two // pow_of_five) + 1
return result % MOD_SIZE
# floor(10^(9*(-i)) * 2^(c_0 + (-e))) % (10^9 * 2^c_0)
def get_table_negative(exponent, i):
result = 1
pow_of_ten = 10 ** (BLOCK_SIZE * i)
shift_amount = CONSTANT - exponent
if shift_amount < 0:
result = pow_of_ten >> (-shift_amount)
else:
result = pow_of_ten << (shift_amount)
return result % MOD_SIZE
# Returns floor(log_10(2^e)); requires 0 <= e <= 42039.
def ceil_log10_pow2(e):
return ((e * 0x13441350FBD) >> 42) + 1
def length_for_num(idx, index_size=IDX_SIZE):
return (
ceil_log10_pow2(idx * index_size) + ceil_log10_pow2(MANT_WIDTH) + BLOCK_SIZE - 1
) // BLOCK_SIZE
def get_64bit_window(num, index):
return (num >> (index * 64)) % (2**64)
def mid_int_to_str(num):
outstr = " {"
outstr += str(get_64bit_window(num, 0)) + "u"
for i in range(1, MID_INT_SIZE // 64):
outstr += ", " + str(get_64bit_window(num, i)) + "u"
outstr += "},"
return outstr
def print_positive_table_for_idx(idx):
positive_blocks = length_for_num(idx)
for i in range(positive_blocks):
table_val = get_table_positive(idx * IDX_SIZE, i)
# print(hex(table_val))
print(mid_int_to_str(table_val))
return positive_blocks
def print_negative_table_for_idx(idx):
i = 0
min_block = -1
table_val = 0
MIN_USEFUL_VAL = 2 ** (CONSTANT - (MANT_WIDTH + 2))
# Iterate through the zero blocks
while table_val < MIN_USEFUL_VAL:
i += 1
table_val = get_table_negative((idx) * IDX_SIZE, i)
else:
i -= 1
min_block = i
# Iterate until another zero block is found
while table_val >= MIN_USEFUL_VAL:
table_val = get_table_negative((idx) * IDX_SIZE, i + 1)
if table_val >= MIN_USEFUL_VAL:
print(mid_int_to_str(table_val))
i += 1
return i - min_block, min_block
positive_size_arr = [0] * (POSITIVE_ARR_SIZE + 1)
negative_size_arr = [0] * (NEGATIVE_ARR_SIZE + 1)
min_block_arr = [0] * (NEGATIVE_ARR_SIZE + 1)
acc = 0
if MOD_SIZE > (2**MID_INT_SIZE):
print(
"Mod size is too big for current MID_INT_SIZE by a factor of",
MOD_SIZE // (2**MID_INT_SIZE),
)
else:
print("static const uint64_t POW10_SPLIT[][" + str(MID_INT_SIZE // 64) + "] = {")
for idx in range(0, POSITIVE_ARR_SIZE + 1):
num_size = print_positive_table_for_idx(idx)
positive_size_arr[idx] = acc
acc += num_size
print("};")
print(
"static const uint32_t POW10_OFFSET_2[" + str(len(positive_size_arr)) + "] = {",
str(positive_size_arr)[1:-2],
"};",
)
print("static const uint64_t POW10_SPLIT_2[][" + str(MID_INT_SIZE // 64) + "] = {")
for idx in range(0, NEGATIVE_ARR_SIZE):
num_size, min_block = print_negative_table_for_idx(idx)
acc += num_size
negative_size_arr[idx + 1] = acc
min_block_arr[idx] = min_block
print("};")
print(
"static const uint32_t POW10_OFFSET_2[" + str(len(negative_size_arr)) + "] = {",
str(negative_size_arr)[1:-2],
"};",
)
print(
"static const uint16_t MIN_BLOCK_2[" + str(len(min_block_arr)) + "] = {",
str(min_block_arr)[1:-2],
"};",
)
Codebase Browser
llvm