Use vector for inputs

include/jitmap/query/query.h

@@ -76,8 +76,8 @@ class Query : util::Pimpl<QueryImpl> {
  // auto ordered_bitmaps = ReorderInputs({"a": a, "b": b, "c": c}, order);
  // query->Eval(ordered_bitmaps, output);
  // ```
- void Eval(const EvaluationContext& ctx, const char** inputs, char* output);
- void Eval(const char** inputs, char* output);
+ void Eval(const EvaluationContext& ctx, std::vector<const char*> inputs, char* output);
+ void Eval(std::vector<const char*> inputs, char* output);
 
  // Return the referenced variables and the expected order.o
  //

src/jitmap/query/query.cc

@@ -19,6 +19,7 @@
 #include <string>
 #include <vector>
 
+#include "jitmap/jitmap.h"
 #include "jitmap/query/compiler.h"
 #include "jitmap/query/optimizer.h"
 #include "jitmap/query/parser.h"
@@ -128,30 +129,25 @@ static inline const char* CoalesceInputPointer(const char* input,
  throw Exception("Unreachable in ", __FUNCTION__);
 }
 
-static inline std::vector<const char*> FixupInputs(const std::vector<std::string>& vars,
- const char** inputs,
- MissingPolicy policy) {
- auto n_inputs = vars.size();
- std::vector<const char*> addrs;
- for (size_t i = 0; i < n_inputs; i++) {
- addrs.push_back(CoalesceInputPointer(inputs[i], vars[i], policy));
- }
-
- return addrs;
-}
+void Query::Eval(const EvaluationContext& eval_ctx, std::vector<const char*> inputs,
+ char* output) {
+ auto vars = variables();
 
-void Query::Eval(const EvaluationContext& eval_ctx, const char** inputs, char* output) {
- JITMAP_PRE_NE(inputs, nullptr);
+ JITMAP_PRE_EQ(vars.size(), inputs.size());
  JITMAP_PRE_NE(output, nullptr);
 
- auto addrs = FixupInputs(variables(), inputs, eval_ctx.missing_policy());
+ auto policy = eval_ctx.missing_policy();
+ for (size_t i = 0; i < inputs.size(); i++) {
+ inputs[i] = CoalesceInputPointer(inputs[i], vars[i], policy);
+ }
+
  auto eval_fn = impl().dense_eval_fn();
- eval_fn(addrs.data(), output);
+ eval_fn(inputs.data(), output);
 }
 
-void Query::Eval(const char** inputs, char* output) {
+void Query::Eval(std::vector<const char*> inputs, char* output) {
  EvaluationContext ctx;
- Eval(ctx, inputs, output);
+ Eval(ctx, std::move(inputs), output);
 }
 
 } // namespace query

tests/jitmap_benchmark.cc

@@ -44,7 +44,7 @@ static void JitIntersection2(benchmark::State& state) {
  auto query = query::Query::Make("benchmark_query_2", "a & b", &engine);
 
  for (auto _ : state) {
- query->Eval(inputs.data(), output.data());
+ query->Eval(inputs, output.data());
  }
 
  state.SetBytesProcessed(kBytesPerContainer * 2 * state.iterations());
@@ -68,7 +68,7 @@ static void JitIntersection3(benchmark::State& state) {
  auto query = query::Query::Make("benchmark_query_3", "a & b & c", &engine);
 
  for (auto _ : state) {
- query->Eval(inputs.data(), output.data());
+ query->Eval(inputs, output.data());
  }
 
  state.SetBytesProcessed(kBytesPerContainer * 3 * state.iterations());

tests/query/compiler_test.cc

@@ -32,10 +32,13 @@ class JitTest : public QueryTest {
  auto [_, inputs] = InitInputs(input_words);
  JITMAP_UNUSED(_);
 
+ auto variables = query->variables();
+ EXPECT_EQ(inputs.size(), variables.size());
+
  std::vector<char> output(kBytesPerContainer, 0UL);
  EXPECT_THAT(output, testing::Each(0UL));
 
- query->Eval(inputs.data(), output.data());
+ query->Eval(std::move(inputs), output.data());
  EXPECT_THAT(output, testing::Each(output_word));
  }
 
@@ -46,12 +49,12 @@ class JitTest : public QueryTest {
  std::vector<char> input_words) {
  size_t n_bitmaps = input_words.size();
 
- std::vector<std::vector<char>> bitmaps;
- std::vector<const char*> inputs;
+ std::vector<std::vector<char>> bitmaps(n_bitmaps);
+ std::vector<const char*> inputs(n_bitmaps);
  for (size_t i = 0; i < n_bitmaps; i++) {
  auto repeated_word = input_words[i];
- bitmaps.emplace_back(kBytesPerContainer, repeated_word);
- inputs.emplace_back(bitmaps[i].data());
+ bitmaps[i] = std::vector<char>(kBytesPerContainer, repeated_word);
+ inputs[i] = bitmaps[i].data();
  EXPECT_THAT(bitmaps[i], testing::Each(repeated_word));
  }
 
@@ -84,7 +87,7 @@ TEST_F(JitTest, CompileAndExecuteTest) {
  AssertQueryResult("a ^ b", {a, b}, a ^ b);
 
  AssertQueryResult("full ^ b", {full, b}, full ^ b);
- AssertQueryResult("empty | !empty", {empty, empty}, full);
+ AssertQueryResult("empty | !empty", {empty}, full);
 
  AssertQueryResult("a & b & c & d & e", {a, b, c, d, e}, a & b & c & d & e);
  AssertQueryResult("a | b | c | d | e", {a, b, c, d, e}, a | b | c | d | e);

tests/query/query_test.cc

@@ -70,10 +70,11 @@ TEST_F(QueryExecTest, EvalInvalidParameters) {
  std::vector<const char*> inputs{};
 
  auto not_a = Query::Make("invalid_param", "!a", &ctx);
- EXPECT_THROW(not_a->Eval(nullptr, nullptr), Exception);
- EXPECT_THROW(not_a->Eval(nullptr, result.data()), Exception);
+ std::vector<const char*> empty;
+ EXPECT_THROW(not_a->Eval(empty, nullptr), Exception);
+ EXPECT_THROW(not_a->Eval(empty, result.data()), Exception);
  inputs = {nullptr};
- EXPECT_THROW(not_a->Eval(inputs.data(), result.data()), Exception);
+ EXPECT_THROW(not_a->Eval(inputs, result.data()), Exception);
 }
 
 TEST_F(QueryExecTest, Eval) {
@@ -85,18 +86,18 @@ TEST_F(QueryExecTest, Eval) {
  auto not_a = Query::Make("single_param", "!a", &ctx);
 
  inputs = {a.data()};
- not_a->Eval(inputs.data(), result.data());
+ not_a->Eval(inputs, result.data());
  EXPECT_THAT(result, testing::Each(0xFF));
 
  auto a_and_b = Query::Make("double_param", "a & b", &ctx);
 
  inputs = {a.data(), b.data()};
- a_and_b->Eval(inputs.data(), result.data());
+ a_and_b->Eval(inputs, result.data());
  EXPECT_THAT(result, testing::Each(0x00));
 
  // It can runs with the same input twice.
  inputs = {b.data(), b.data()};
- a_and_b->Eval(inputs.data(), result.data());
+ a_and_b->Eval(inputs, result.data());
  EXPECT_THAT(result, testing::Each(0xFF));
 }
 
@@ -109,14 +110,14 @@ TEST_F(QueryExecTest, EvalWithMissingPolicy) {
  auto q = Query::Make("another_not_a", "!a", &ctx);
 
  EvaluationContext eval_ctx;
- EXPECT_THROW(q->Eval(eval_ctx, inputs.data(), result.data()), Exception);
+ EXPECT_THROW(q->Eval(eval_ctx, inputs, result.data()), Exception);
 
  eval_ctx.set_missing_policy(MissingPolicy::REPLACE_WITH_EMPTY);
- q->Eval(eval_ctx, inputs.data(), result.data());
+ q->Eval(eval_ctx, inputs, result.data());
  EXPECT_THAT(result, testing::Each(0xFF));
 
  eval_ctx.set_missing_policy(MissingPolicy::REPLACE_WITH_FULL);
- q->Eval(eval_ctx, inputs.data(), result.data());
+ q->Eval(eval_ctx, inputs, result.data());
  EXPECT_THAT(result, testing::Each(0x00));
 }