该模板类可以将模乘优化为乘法和移位，只需要一次初始化。适合重复除数的情况。

```cpp

template <typename NumTy, typename ProdTy> class DivSupporter {

private:

NumTy divisor = 0;

NumTy inv = 0;

int shift = 0, shift1 = 0, shift2 = 0;

enum : int { NUM_BITS = sizeof(NumTy) * CHAR_BIT };

public:

constexpr DivSupporter(NumTy divisor_in) : divisor(divisor_in) {

inv = getInv(divisor, shift);

divisor <<= shift;

shift1 = shift / 2;

shift2 = shift - shift1;

}

NumTy divMod(ProdTy &dividend) const {

dividend <<= shift;

NumTy r = NumTy(dividend);

dividend = (dividend >> NUM_BITS) \* inv + dividend;

NumTy q1 = NumTy(dividend >> NUM_BITS) + 1;

r -= q1 \* divisor;

if (r > NumTy(dividend)) {

  q1--;

  r += divisor;

}

if (r >= divisor) {

  q1++;

  r -= divisor;

}

dividend = r >> shift;

return q1;

}

void prodDivMod(NumTy a, NumTy b, NumTy &quot, NumTy &rem) const {

ProdTy dividend = ProdTy(a << shift1) \* (b << shift2);

rem = NumTy(dividend);

dividend = (dividend >> NUM_BITS) \* inv + dividend;

quot = NumTy(dividend >> NUM_BITS) + 1;

rem -= quot \* divisor;

if (rem > NumTy(dividend)) {

  quot--;

  rem += divisor;

}

if (rem >= divisor) {

  quot++;

  rem -= divisor;

}

rem >>= shift;

}

NumTy div(ProdTy dividend) const { return divMod(dividend); }

NumTy mod(ProdTy dividend) const {

divMod(dividend);

return dividend;

}

static constexpr NumTy getInv(NumTy divisor, int &leading_zero) {

constexpr NumTy MAX = all_one<NumTy>(NUM_BITS);

leading_zero = hint_clz(divisor);

divisor <<= leading_zero;

ProdTy x = ProdTy(MAX - divisor) << NUM_BITS;

return NumTy((x + MAX) / divisor);

}

};

```

详细的性能对比：

```cpp

#include <chrono>

#include <climits>

#include <cstdint>

#include <cstdio>

#include <cstring>

#include <random>

#define _MAX 0×1fffffffffffffffULL

// 编译期常数除数定义（可自定义，确保非0）

constexpr uint64_t CONST_DIVISOR = 0xf634567979ABCEF1ULL;

// 补充模板类依赖的辅助函数

template <typename T> constexpr T all_one(int bits) {

return (bits == sizeof(T) * CHAR_BIT) ? ~T(0) : (T(1) << bits) - 1;

}

template <typename T> constexpr int hint_clz(T val) {

if (val == 0)

return sizeof(T) \* CHAR_BIT;

int cnt = 0;

while ((val & (T(1) << (sizeof(T) * CHAR_BIT - 1))) == 0) {

val <<= 1;

cnt++;

}

return cnt;

}

// 原模板类

template <typename NumTy, typename ProdTy> class DivSupporter {

private:

NumTy divisor = 0;

NumTy inv = 0;

int shift = 0, shift1 = 0, shift2 = 0;

enum : int { NUM_BITS = sizeof(NumTy) * CHAR_BIT };

public:

constexpr DivSupporter(NumTy divisor_in) : divisor(divisor_in) {

inv = getInv(divisor, shift);

divisor <<= shift;

shift1 = shift / 2;

shift2 = shift - shift1;

}

NumTy divMod(ProdTy &dividend) const {

dividend <<= shift;

NumTy r = NumTy(dividend);

dividend = (dividend >> NUM_BITS) \* inv + dividend;

NumTy q1 = NumTy(dividend >> NUM_BITS) + 1;

r -= q1 \* divisor;

if (r > NumTy(dividend)) {

  q1--;

  r += divisor;

}

if (r >= divisor) {

  q1++;

  r -= divisor;

}

dividend = r >> shift;

return q1;

}

void prodDivMod(NumTy a, NumTy b, NumTy &quot, NumTy &rem) const {

ProdTy dividend = ProdTy(a << shift1) \* (b << shift2);

rem = NumTy(dividend);

dividend = (dividend >> NUM_BITS) \* inv + dividend;

quot = NumTy(dividend >> NUM_BITS) + 1;

rem -= quot \* divisor;

if (rem > NumTy(dividend)) {

  quot--;

  rem += divisor;

}

if (rem >= divisor) {

  quot++;

  rem -= divisor;

}

rem >>= shift;

}

NumTy div(ProdTy dividend) const { return divMod(dividend); }

NumTy mod(ProdTy dividend) const {

divMod(dividend);

return dividend;

}

static constexpr NumTy getInv(NumTy divisor, int &leading_zero) {

constexpr NumTy MAX = all_one<NumTy>(NUM_BITS);

leading_zero = hint_clz(divisor);

divisor <<= leading_zero;

ProdTy x = ProdTy(MAX - divisor) << NUM_BITS;

return NumTy((x + MAX) / divisor);

}

};

// 汇编实现的128位除以64位函数

static inline uint64_t div128by64to64(uint64_t dividend_hi64,

                                  uint64_t &dividend_lo64,

                                  uint64_t divisor) {

#if defined(x86_64) && !defined(_LAMMP_MSVC)

uint64_t quotient_low, remainder;

asm(“div %[divisor]”

      : "=a"(quotient_low), "=d"(remainder)

      : "a"(dividend_lo64), "d"(dividend_hi64), [divisor] "r"(divisor)

      :);

dividend_lo64 = remainder;

return quotient_low;

#else

uint128_t dividend = (uint128_t)dividend_hi64 << 64 | dividend_lo64;

uint64_t quotient = (uint64_t)(dividend / divisor);

dividend_lo64 = (uint64_t)(dividend % divisor);

return quotient;

#endif

}

// 性能测试工具类（扩展常数除数+依赖链测试）

class PerformanceTester {

public:

// 生成随机测试数据（仅生成被除数，除数用常数/动态）

static void generateDividendData(uint64_t *dividends_high,

                               uint64_t \*dividends_low, size_t count) {

std::random_device rd;

std::mt19937_64 gen(rd());

std::uniform_int_distribution<uint64_t> dist(1, CONST_DIVISOR - 1);

for (size_t i = 0; i < count; ++i) {

  dividends_high[i] = dist(gen);

  dividends_low[i] = dist(gen);

}

}

// 生成动态除数数据（原有逻辑）

static void generateDynamicDivisorData(uint64_t *divisors, size_t count) {

std::random_device rd;

std::mt19937_64 gen(rd());

std::uniform_int_distribution<uint64_t> dist(CONST_DIVISOR, UINT64_MAX);

for (size_t i = 0; i < count; ++i) {

  divisors[i] = dist(gen);

}

}

// ————————– 基础测试（无依赖链） ————————–

// 动态除数-原生

static double testNativeDiv_Dynamic(const uint64_t *dividends_high,

                                  const uint64_t \*dividends_low,

                                  const uint64_t \*divisors, size_t count,

                                  uint64_t \*results) {

auto start = std::chrono::high_resolution_clock::now();

for (size_t i = 0; i < count; ++i) {

  __uint128_t dividend =

      (__uint128_t)dividends_high[i] << 64 | dividends_low[i];

  uint64_t divisor = divisors[i];

  results[i] = (uint64_t)(dividend / divisor);

}

auto end = std::chrono::high_resolution_clock::now();

return std::chrono::duration<double, std::milli>(end - start).count();

}

// 动态除数-DivSupporter

static double testDivSupporter_Dynamic(const uint64_t *dividends_high,

                                     const uint64_t \*dividends_low,

                                     const uint64_t \*divisors, size_t count,

                                     uint64_t \*results) {

auto start = std::chrono::high_resolution_clock::now();

for (size_t i = 0; i < count; ++i) {

  DivSupporter<uint64_t, __uint128_t> ds(divisors[i]);

  __uint128_t dividend =

      (__uint128_t)dividends_high[i] << 64 | dividends_low[i];

  results[i] = ds.div(dividend);

}

auto end = std::chrono::high_resolution_clock::now();

return std::chrono::duration<double, std::milli>(end - start).count();

}

// 动态除数-汇编

static double testAsmDiv_Dynamic(const uint64_t *dividends_high,

                               const uint64_t \*dividends_low,

                               const uint64_t \*divisors, size_t count,

                               uint64_t \*results) {

auto start = std::chrono::high_resolution_clock::now();

uint64_t \*temp_low = new uint64_t[count];

memcpy(temp_low, dividends_low, count \* sizeof(uint64_t));

for (size_t i = 0; i < count; ++i) {

  results[i] = div128by64to64(dividends_high[i], temp_low[i], divisors[i]);

}

delete[] temp_low;

auto end = std::chrono::high_resolution_clock::now();

return std::chrono::duration<double, std::milli>(end - start).count();

}

// 常数除数-原生

static double testNativeDiv_Const(const uint64_t *dividends_high,

                                const uint64_t \*dividends_low, size_t count,

                                uint64_t \*results) {

auto start = std::chrono::high_resolution_clock::now();

constexpr uint64_t divisor = CONST_DIVISOR;

for (size_t i = 0; i < count; ++i) {

  __uint128_t dividend =

      (__uint128_t)dividends_high[i] << 64 | dividends_low[i];

  results[i] = (uint64_t)(dividend / divisor);

}

auto end = std::chrono::high_resolution_clock::now();

return std::chrono::duration<double, std::milli>(end - start).count();

}

// 常数除数-DivSupporter（预初始化）

static double testDivSupporter_Const(const uint64_t *dividends_high,

                                   const uint64_t \*dividends_low,

                                   size_t count, uint64_t \*results) {

auto start = std::chrono::high_resolution_clock::now();

constexpr DivSupporter<uint64_t, __uint128_t> ds(CONST_DIVISOR);

for (size_t i = 0; i < count; ++i) {

  __uint128_t dividend =

      (__uint128_t)dividends_high[i] << 64 | dividends_low[i];

  results[i] = ds.div(dividend);

}

auto end = std::chrono::high_resolution_clock::now();

return std::chrono::duration<double, std::milli>(end - start).count();

}

// 常数除数-汇编

static double testAsmDiv_Const(const uint64_t *dividends_high,

                             const uint64_t \*dividends_low, size_t count,

                             uint64_t \*results) {

auto start = std::chrono::high_resolution_clock::now();

constexpr uint64_t divisor = CONST_DIVISOR;

uint64_t \*temp_low = new uint64_t[count];

memcpy(temp_low, dividends_low, count \* sizeof(uint64_t));

for (size_t i = 0; i < count; ++i) {

  results[i] = div128by64to64(dividends_high[i], temp_low[i], divisor);

}

delete[] temp_low;

auto end = std::chrono::high_resolution_clock::now();

return std::chrono::duration<double, std::milli>(end - start).count();

}

// ————————– 依赖链测试（新增核心逻辑）

// ————————– 动态除数-原生（依赖链：后一次被除数 = 前一次商 +

// 前一次余数）

static double testNativeDiv_Dynamic_Chain(size_t count,

                                        uint64_t &final_result) {

auto start = std::chrono::high_resolution_clock::now();

// 初始化种子（避免编译器优化）

uint64_t seed_hi = 0x123456789ABCDEF0ULL;

uint64_t seed_lo = 0xFEDCBA9876543210ULL;

uint64_t seed_div = 0x9876543210ABCDEFULL;

uint64_t last_q = 0, last_r = 0;

for (size_t i = 0; i < count; ++i) {

  // 后一次被除数 = 前一次商（高64位） + 前一次余数（低64位） +

  // 随机偏移（避免重复）

  __uint128_t dividend = (__uint128_t)(last_q + i) << 64 | (last_r + i \* 3);

  // 动态除数 = 种子 + 循环偏移（保证除数非0且动态）

  uint64_t divisor = (seed_div + i \* 7) % _MAX + 1;

  // 计算商和余数（构建依赖）

  last_q = (uint64_t)(dividend / divisor);

  last_r = (uint64_t)(dividend % divisor);

}

final_result = last_q + last_r; // 保存最终结果，避免编译器优化整个循环

auto end = std::chrono::high_resolution_clock::now();

return std::chrono::duration<double, std::milli>(end - start).count();

}

// 常数除数-原生（依赖链）

static double testNativeDiv_Const_Chain(size_t count,

                                      uint64_t &final_result) {

auto start = std::chrono::high_resolution_clock::now();

constexpr uint64_t divisor = CONST_DIVISOR;

// 初始化种子

uint64_t seed_hi = 0x123456789ABCDEF0ULL;

uint64_t seed_lo = 0xFEDCBA9876543210ULL;

uint64_t last_q = 0, last_r = 0;

for (size_t i = 0; i < count; ++i) {

    __uint128_t dividend =

        (__uint128_t)((last_q + i \* 5) % CONST_DIVISOR) << 64 | ((last_r + i \* 9) % CONST_DIVISOR);

    last_q = (uint64_t)(dividend / divisor);

    last_r = (uint64_t)(dividend % divisor);

}

final_result = last_q + last_r;

auto end = std::chrono::high_resolution_clock::now();

return std::chrono::duration<double, std::milli>(end - start).count();

}

// 常数除数-DivSupporter（依赖链，预初始化）

static double testDivSupporter_Const_Chain(size_t count,

                                         uint64_t &final_result) {

auto start = std::chrono::high_resolution_clock::now();

constexpr DivSupporter<uint64_t, __uint128_t> ds(CONST_DIVISOR);

// 初始化种子

uint64_t seed_hi = 0x123456789ABCDEF0ULL;

uint64_t seed_lo = 0xFEDCBA9876543210ULL;

uint64_t last_q = 0;

__uint128_t last_dividend = 0;

for (size_t i = 0; i < count; ++i) {

  // 构建依赖型被除数

  last_dividend = (__uint128_t)((last_q + i \* 7) % CONST_DIVISOR) << 64 |

                  ((i \* 11 + seed_lo) % CONST_DIVISOR);

  last_q = ds.div(last_dividend);

  // 额外依赖余数（divMod会修改dividend为余数）

  (void)ds.mod(last_dividend);

}

final_result = last_q + (uint64_t)last_dividend;

auto end = std::chrono::high_resolution_clock::now();

return std::chrono::duration<double, std::milli>(end - start).count();

}

// 常数除数-汇编（依赖链）

static double testAsmDiv_Const_Chain(size_t count, uint64_t &final_result) {

auto start = std::chrono::high_resolution_clock::now();

constexpr uint64_t divisor = CONST_DIVISOR;

// 初始化种子

uint64_t seed_hi = 0x123456789ABCDEF0ULL;

uint64_t seed_lo = 0xFEDCBA9876543210ULL;

uint64_t last_q = 0, last_r = 0;

for (size_t i = 0; i < count; ++i) {

  uint64_t curr_hi = (last_q + i \* 13) % CONST_DIVISOR;

  uint64_t curr_lo = (last_r + i \* 17) % CONST_DIVISOR;

  // 汇编调用（修改curr_lo为余数）

  last_q = div128by64to64(curr_hi, curr_lo, divisor);

  last_r = curr_lo; // 余数依赖

}

final_result = last_q + last_r;

auto end = std::chrono::high_resolution_clock::now();

return std::chrono::duration<double, std::milli>(end - start).count();

}

// 验证结果一致性（原有逻辑）

static bool verifyDynamicResults(const uint64_t *native, const uint64_t *ds,

                               const uint64_t \*asm_, size_t count) {

for (size_t i = 0; i < count; ++i) {

  if (native[i] != ds[i] || native[i] != asm_[i]) {

    printf("Dynamic Divisor Verify Failed: No.%zu (native=%lu, ds=%lu, "

           "asm=%lu)\\n",

           i, native[i], ds[i], asm_[i]);

    return false;

  }

}

printf("Dynamic Divisor Verify Passed\\n");

return true;

}

static bool verifyConstResults(const uint64_t *native, const uint64_t *ds,

                             const uint64_t \*asm_, size_t count) {

for (size_t i = 0; i < count; ++i) {

  if (native[i] != ds[i] || native[i] != asm_[i]) {

    printf("Const Divisor Verify Failed: No.%zu (native=%lu, ds=%lu, "

           "asm=%lu)\\n",

           i, native[i], ds[i], asm_[i]);

    return false;

  }

}

printf("Const Divisor Verify Passed\\n");

return true;

}

};

// 打印性能结果辅助函数

void printResult(const char *name, double avg_time, size_t count) {

double ns_per_iter = avg_time * 1000000 / count;

printf(“ %-30s: %.2f ms (%.2f ns/iter)\n”, name, avg_time, ns_per_iter);

}

int main() {

// 测试配置

const size_t TEST_COUNT = 10000000; // 1000万次运算

const int WARMUP_ROUNDS = 3; // 预热轮数

const int TEST_ROUNDS = 5; // 测试轮数

// 内存分配（原有逻辑）

uint64_t *dividends_high = new uint64_t[TEST_COUNT];

uint64_t *dividends_low = new uint64_t[TEST_COUNT];

uint64_t *dynamic_divisors = new uint64_t[TEST_COUNT];

uint64_t *dyn_native_res = new uint64_t[TEST_COUNT];

uint64_t *dyn_ds_res = new uint64_t[TEST_COUNT];

uint64_t *dyn_asm_res = new uint64_t[TEST_COUNT];

uint64_t *const_native_res = new uint64_t[TEST_COUNT];

uint64_t *const_ds_res = new uint64_t[TEST_COUNT];

uint64_t *const_asm_res = new uint64_t[TEST_COUNT];

// 生成测试数据

printf(“Generating Test Data…\n”);

PerformanceTester::generateDividendData(dividends_high, dividends_low,

                                      TEST_COUNT);

PerformanceTester::generateDynamicDivisorData(dynamic_divisors, TEST_COUNT);

// ————————– 预热阶段（含依赖链预热）

// ————————–

printf(“Warming Up…\n”);

uint64_t dummy_result = 0;

for (int i = 0; i < WARMUP_ROUNDS; ++i) {

// 原有预热

PerformanceTester::testNativeDiv_Dynamic(dividends_high, dividends_low,

                                         dynamic_divisors, TEST_COUNT,

                                         dyn_native_res);

PerformanceTester::testDivSupporter_Dynamic(dividends_high, dividends_low,

                                            dynamic_divisors, TEST_COUNT,

                                            dyn_ds_res);

PerformanceTester::testAsmDiv_Dynamic(dividends_high, dividends_low,

                                      dynamic_divisors, TEST_COUNT,

                                      dyn_asm_res);

PerformanceTester::testNativeDiv_Const(dividends_high, dividends_low,

                                       TEST_COUNT, const_native_res);

PerformanceTester::testDivSupporter_Const(dividends_high, dividends_low,

                                          TEST_COUNT, const_ds_res);

PerformanceTester::testAsmDiv_Const(dividends_high, dividends_low,

                                    TEST_COUNT, const_asm_res);

// 依赖链预热

PerformanceTester::testNativeDiv_Dynamic_Chain(TEST_COUNT / 10,

                                               dummy_result);

PerformanceTester::testNativeDiv_Const_Chain(TEST_COUNT / 10, dummy_result);

PerformanceTester::testDivSupporter_Const_Chain(TEST_COUNT / 10,

                                                dummy_result);

PerformanceTester::testAsmDiv_Const_Chain(TEST_COUNT / 10, dummy_result);

}

// ————————– 原有结果验证 ————————–

if (!PerformanceTester::verifyDynamicResults(dyn_native_res, dyn_ds_res,

                                           dyn_asm_res, TEST_COUNT) ||

  !PerformanceTester::verifyConstResults(const_native_res, const_ds_res,

                                         const_asm_res, TEST_COUNT)) {

// 释放内存

delete[] dividends_high;

delete[] dividends_low;

delete[] dynamic_divisors;

delete[] dyn_native_res;

delete[] dyn_ds_res;

delete[] dyn_asm_res;

delete[] const_native_res;

delete[] const_ds_res;

delete[] const_asm_res;

return 1;

}

// ————————– 原有无依赖测试 ————————–

printf(“\n=== No Dependency Chain Test ===\n”);

// 动态除数

printf(“\n— Dynamic Divisor —\n”);

double dyn_native_total = 0, dyn_ds_total = 0, dyn_asm_total = 0;

for (int i = 0; i < TEST_ROUNDS; ++i) {

double t1 = PerformanceTester::testNativeDiv_Dynamic(

    dividends_high, dividends_low, dynamic_divisors, TEST_COUNT,

    dyn_native_res);

double t2 = PerformanceTester::testDivSupporter_Dynamic(

    dividends_high, dividends_low, dynamic_divisors, TEST_COUNT,

    dyn_ds_res);

double t3 = PerformanceTester::testAsmDiv_Dynamic(

    dividends_high, dividends_low, dynamic_divisors, TEST_COUNT,

    dyn_asm_res);

dyn_native_total += t1;

dyn_ds_total += t2;

dyn_asm_total += t3;

}

printResult(“__uint128_t/uint64_t”, dyn_native_total / TEST_ROUNDS,

          TEST_COUNT);

printResult(“DivSupporter (Dynamic)”, dyn_ds_total / TEST_ROUNDS, TEST_COUNT);

printResult(“Asm div128by64to64”, dyn_asm_total / TEST_ROUNDS, TEST_COUNT);

// 常数除数

printf(“\n— Const Divisor (0x%lx) —\n”, CONST_DIVISOR);

double const_native_total = 0, const_ds_total = 0, const_asm_total = 0;

for (int i = 0; i < TEST_ROUNDS; ++i) {

double t1 = PerformanceTester::testNativeDiv_Const(

    dividends_high, dividends_low, TEST_COUNT, const_native_res);

double t2 = PerformanceTester::testDivSupporter_Const(

    dividends_high, dividends_low, TEST_COUNT, const_ds_res);

double t3 = PerformanceTester::testAsmDiv_Const(

    dividends_high, dividends_low, TEST_COUNT, const_asm_res);

const_native_total += t1;

const_ds_total += t2;

const_asm_total += t3;

}

printResult(“__uint128_t/uint64_t (Const)”, const_native_total / TEST_ROUNDS,

          TEST_COUNT);

printResult(“DivSupporter (Const Pre-init)”, const_ds_total / TEST_ROUNDS,

          TEST_COUNT);

printResult(“Asm div128by64to64 (Const)”, const_asm_total / TEST_ROUNDS,

          TEST_COUNT);

// ————————– 新增依赖链测试 ————————–

printf(“\n=== Dependency Chain Test (Strong Data Dependency) ===\n”);

// 动态除数-原生（依赖链）

printf(“\n— Dynamic Divisor (Native) —\n”);

double chain_dyn_native_total = 0;

uint64_t final_chain_dyn = 0;

for (int i = 0; i < TEST_ROUNDS; ++i) {

double t = PerformanceTester::testNativeDiv_Dynamic_Chain(TEST_COUNT,

                                                          final_chain_dyn);

chain_dyn_native_total += t;

}

printResult(“__uint128_t/uint64_t (Chain)”,

          chain_dyn_native_total / TEST_ROUNDS, TEST_COUNT);

printf(“ Final result (avoid opt): %lu\n”, final_chain_dyn);

// 常数除数（依赖链）

printf(“\n— Const Divisor (0x%llx) —\n”, CONST_DIVISOR);

double chain_const_native_total = 0, chain_const_ds_total = 0,

     chain_const_asm_total = 0;

uint64_t final_chain_native = 0, final_chain_ds = 0, final_chain_asm = 0;

for (int i = 0; i < TEST_ROUNDS; ++i) {

chain_const_native_total += PerformanceTester::testNativeDiv_Const_Chain(

    TEST_COUNT, final_chain_native);

chain_const_ds_total += PerformanceTester::testDivSupporter_Const_Chain(

    TEST_COUNT, final_chain_ds);

chain_const_asm_total +=

    PerformanceTester::testAsmDiv_Const_Chain(TEST_COUNT, final_chain_asm);

}

printResult(“__uint128_t/uint64_t (Const Chain)”,

          chain_const_native_total / TEST_ROUNDS, TEST_COUNT);

printResult(“DivSupporter (Const Chain)”, chain_const_ds_total / TEST_ROUNDS,

          TEST_COUNT);

printResult(“Asm div128by64to64 (Const Chain)”,

          chain_const_asm_total / TEST_ROUNDS, TEST_COUNT);

printf(“ Final results (avoid opt): native=%lu, ds=%lu, asm=%lu\n”,

     final_chain_native, final_chain_ds, final_chain_asm);

// ————————– 性能对比总结 ————————–

printf(“\n=== Performance Summary ===\n”);

double no_chain_const_native = const_native_total / TEST_ROUNDS;

double chain_const_native = chain_const_native_total / TEST_ROUNDS;

double no_chain_const_ds = const_ds_total / TEST_ROUNDS;

double chain_const_ds = chain_const_ds_total / TEST_ROUNDS;

double no_chain_const_asm = const_asm_total / TEST_ROUNDS;

double chain_const_asm = chain_const_asm_total / TEST_ROUNDS;

printf(“ Const Divisor - No Chain vs Chain:\n”);

printf(“ Native: %.2fx slower (chain)\n”,

     chain_const_native / no_chain_const_native);

printf(“ DivSupporter: %.2fx slower (chain)\n”,

     chain_const_ds / no_chain_const_ds);

printf(“ Asm: %.2fx slower (chain)\n”,

     chain_const_asm / no_chain_const_asm);

// 释放内存

delete[] dividends_high;

delete[] dividends_low;

delete[] dynamic_divisors;

delete[] dyn_native_res;

delete[] dyn_ds_res;

delete[] dyn_asm_res;

delete[] const_native_res;

delete[] const_ds_res;

delete[] const_asm_res;

return 0;

}

```