C++ std::function & lambda 性能损失

pre

• 习惯 std::function 作为参数参与函数过滤、操作等，起初怀疑 std::function 性能应该是比 inline function 低
• 查到相关资料：https://stackoverflow.com/questions/42856707/can-be-stdfunction-inlined-or-should-i-use-different-approach

以下是基于上述问题做的测试，结果：

• 1. std::function 相当于一次 virtual function 的调用成本
• 2. 如果可能，auto arg / template 是接近原始调用的
• 3. 否则：lambda 是一个更好的选择

代码

static const unsigned N = 10;

struct loop3_lambda {
  static void impl() {
    double sum = 0.0;

    const auto fn = [](double a, double b, double c) {
      const auto subFn = [](double x, double y) { return x / (y + 1); };
      return sin(a) + log(subFn(b, c));
    };

    for (unsigned i = 1; i <= N; ++i) {
      for (unsigned j = 1; j <= N; ++j) {
        for (unsigned k = 1; k <= N; ++k) {
          sum += fn(i, j, k);
        }
      }
    }
  }
};

struct loop3_function {
  static void impl() {
    double sum = 0.0;

    const std::function<double(double, double, double)> fn = [](double a, double b, double c) {
      const auto subFn = [](double x, double y) { return x / (y + 1); };
      return sin(a) + log(subFn(b, c));
    };

    for (unsigned i = 1; i <= N; ++i) {
      for (unsigned j = 1; j <= N; ++j) {
        for (unsigned k = 1; k <= N; ++k) {
          sum += fn(i, j, k);
        }
      }
    }
  }
};

struct loop3_template {
  template <class func_tt, class... args_tt> static void impl(func_tt&& func, args_tt&& ... args) {
    double sum = 0.0;

    for (unsigned i = 1; i <= N; ++i) {
      for (unsigned j = 1; j <= N; ++j) {
        for (unsigned k = 1; k <= N; ++k) {
          sum += func(i, j, k);
        }
      }
    }
  }
};

struct loop3_function_arg {
  static void impl(std::function<double(double, double, double)>&& func) {
    double sum = 0.0;

    for (unsigned i = 1; i <= N; ++i) {
      for (unsigned j = 1; j <= N; ++j) {
        for (unsigned k = 1; k <= N; ++k) {
          sum += func(i, j, k);
        }
      }
    }
  }
};

struct loop3_function_2_lambda {
  static void impl(std::function<double(double, double, double)> &&func) {
    double sum = 0.0;

    const auto lambda_call = [func](double a, double b, double c) {
      return func(a, b, c);
    };

    for (unsigned i = 1; i <= N; ++i) {
      for (unsigned j = 1; j <= N; ++j) {
        for (unsigned k = 1; k <= N; ++k) {
          sum += lambda_call(i, j, k);
        }
      }
    }
  }
};

struct loop3_auto {
  static void impl(auto &&func) {
    double sum = 0.0;

    for (unsigned i = 1; i <= N; ++i) {
      for (unsigned j = 1; j <= N; ++j) {
        for (unsigned k = 1; k <= N; ++k) {
          sum += func(i, j, k);
        }
      }
    }
  }
};

struct loop3_raw {
  static void impl() {
    double sum = 0.0;
    for (unsigned i = 1; i <= N; ++i) {
      for (unsigned j = 1; j <= N; ++j) {
        for (unsigned k = 1; k <= N; ++k) {
          sum += sin((double)i) + log((double)j / (k + 1));
        }
      }
    }
  }
};

static void loop3_lambda_test(benchmark::State &state) {
  for (auto _ : state) {
    loop3_lambda::impl();
  }
}

static void loop3_function_test(benchmark::State &state) {
  for (auto _ : state) {
    loop3_function::impl();
  }
}

static void loop3_template_test(benchmark::State &state) {
  for (auto _ : state) {
    loop3_template::impl([](double a, double b, double c) {
      const auto subFn = [](double x, double y) { return x / (y + 1); };
      return sin(a) + log(subFn(b, c));
    });
  }
}

static void loop3_function_arg_test(benchmark::State &state) {
  for (auto _ : state) {
    loop3_function_arg::impl([](double a, double b, double c) {
      const auto subFn = [](double x, double y) { return x / (y + 1); };
      return sin(a) + log(subFn(b, c));
    });
  }
}

static void loop3_function_2_lambda_test(benchmark::State &state) {
  for (auto _ : state) {
    loop3_function_2_lambda::impl([](double a, double b, double c) {
      const auto subFn = [](double x, double y) { return x / (y + 1); };
      return sin(a) + log(subFn(b, c));
    });
  }
}

static void loop3_auto_test(benchmark::State &state) {
  for (auto _ : state) {
    loop3_auto::impl([](double a, double b, double c) {
      const auto subFn = [](double x, double y) { return x / (y + 1); };
      return sin(a) + log(subFn(b, c));
    });
  }
}

static void loop3_raw_test(benchmark::State &state) {
  for (auto _ : state) {
    loop3_raw::impl();
  }
}

BENCHMARK(loop3_lambda_test);
BENCHMARK(loop3_function_test);
BENCHMARK(loop3_template_test);
BENCHMARK(loop3_function_arg_test);
BENCHMARK(loop3_function_2_lambda_test);
BENCHMARK(loop3_auto_test);
BENCHMARK(loop3_raw_test);