Function ABSL_FLAG

eval/tests/benchmark_test.cc:32–186

#include "google/protobuf/text_format.h"

ABSL_FLAG(bool, enable_optimizations, false, "enable const folding opt");
ABSL_FLAG(bool, enable_recursive_planning, false, "enable recursive planning");

namespace google {
namespace api {
namespace expr {
namespace runtime {

namespace {

using ::cel::expr::Expr;
using ::cel::expr::ParsedExpr;
using ::cel::expr::SourceInfo;
using ::google::rpc::context::AttributeContext;

InterpreterOptions GetOptions(google::protobuf::Arena& arena) {
  InterpreterOptions options;

  if (absl::GetFlag(FLAGS_enable_optimizations)) {
    options.constant_arena = &arena;
    options.constant_folding = true;
  }

  if (absl::GetFlag(FLAGS_enable_recursive_planning)) {
    options.max_recursion_depth = -1;
  }

  return options;
}

// Benchmark test
// Evaluates cel expression:
// '1 + 1 + 1 .... +1'
static void BM_Eval(benchmark::State& state) {
  google::protobuf::Arena arena;
  InterpreterOptions options = GetOptions(arena);

  auto builder = CreateCelExpressionBuilder(options);
  ASSERT_OK(RegisterBuiltinFunctions(builder->GetRegistry(), options));

  int len = state.range(0);

  Expr root_expr;
  Expr* cur_expr = &root_expr;

  for (int i = 0; i < len; i++) {
    Expr::Call* call = cur_expr->mutable_call_expr();
    call->set_function("_+_");
    call->add_args()->mutable_const_expr()->set_int64_value(1);
    cur_expr = call->add_args();
  }

  cur_expr->mutable_const_expr()->set_int64_value(1);

  SourceInfo source_info;
  ASSERT_OK_AND_ASSIGN(auto cel_expr,
                       builder->CreateExpression(&root_expr, &source_info));