Function BM_SymbolicPolicy

eval/tests/expression_builder_benchmark_test.cc:105–465

}

void BM_SymbolicPolicy(benchmark::State& state) {
  auto param = static_cast<BenchmarkParam>(state.range(0));
  state.SetLabel(LabelForParam(param));

  ASSERT_OK_AND_ASSIGN(ParsedExpr expr, parser::Parse(R"cel(
   !(request.ip in ["10.0.1.4", "10.0.1.5", "10.0.1.6"]) &&
   ((request.path.startsWith("v1") && request.token in ["v1", "v2", "admin"]) ||
    (request.path.startsWith("v2") && request.token in ["v2", "admin"]) ||
    (request.path.startsWith("/admin") && request.token == "admin" &&
     request.ip in ["10.0.1.1",  "10.0.1.2", "10.0.1.3"])
   ))cel"));

  google::protobuf::Arena arena;
  InterpreterOptions options = OptionsForParam(param, arena);

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

  for (auto _ : state) {
    ASSERT_OK_AND_ASSIGN(
        auto expression,
        builder->CreateExpression(&expr.expr(), &expr.source_info()));
    arena.Reset();
  }
}

BENCHMARK(BM_SymbolicPolicy)
    ->Arg(BenchmarkParam::kDefault)
    ->Arg(BenchmarkParam::kFoldConstants)
    ->Arg(BenchmarkParam::kRecursivePlanning)
    ->Arg(BenchmarkParam::kRecursivePlanningWithConstantFolding);

absl::StatusOr<std::unique_ptr<CelExpressionBuilder>> MakeBuilderForEnums(
    absl::string_view container, absl::string_view enum_type,
    int num_enum_values) {
  auto builder =
      CreateCelExpressionBuilder(cel::GetMinimalDescriptorPool(), nullptr, {});
  builder->set_container(std::string(container));
  CelTypeRegistry* type_registry = builder->GetTypeRegistry();
  std::vector<CelTypeRegistry::Enumerator> enumerators;
  enumerators.reserve(num_enum_values);
  for (int i = 0; i < num_enum_values; ++i) {
    enumerators.push_back(
        CelTypeRegistry::Enumerator{absl::StrCat("ENUM_VALUE_", i), i});
  }
  type_registry->RegisterEnum(enum_type, std::move(enumerators));

  CEL_RETURN_IF_ERROR(RegisterBuiltinFunctions(builder->GetRegistry()));
  return builder;
}

void BM_EnumResolutionSimple(benchmark::State& state) {
  static const CelExpressionBuilder* builder = []() {
    auto builder = MakeBuilderForEnums("", "com.example.TestEnum", 4);
    ABSL_CHECK_OK(builder.status());
    return builder->release();
  }();