[DS-110] Cache individual expressions instead of all expressions in projector

cpp/src/gandiva/base_cache_key.h

@@ -0,0 +1,92 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#pragma once
+
+#include <arrow/util/hash_util.h>
+#include <stddef.h>
+
+#include "gandiva/expression.h"
+#include "gandiva/filter.h"
+#include "gandiva/projector.h"
+
+namespace gandiva {
+
+class BaseCacheKey {
+ public:
+  BaseCacheKey(Expression& expr, std::string type) : type_(type) {
+    static const int32_t kSeedValue = 4;
+    std::string expr_as_string = expr.ToString();
+    size_t result_hash = kSeedValue;
+    arrow::internal::hash_combine(result_hash, type);
+    arrow::internal::hash_combine(result_hash, expr_as_string);
+    hash_code_ = result_hash;
+  }
+
+  BaseCacheKey(ProjectorCacheKey& key, std::string type) : type_(type) {
+    static const int32_t kSeedValue = 4;
+    size_t key_hash = key.Hash();
+    size_t result_hash = kSeedValue;
+    arrow::internal::hash_combine(result_hash, type);
+    arrow::internal::hash_combine(result_hash, key_hash);
+    hash_code_ = result_hash;
+    schema_ = key.schema();
+  }
+
+  BaseCacheKey(FilterCacheKey& key, std::string type) : type_(type) {
+    static const size_t kSeedValue = 4;
+    size_t key_hash = key.Hash();
+    size_t result_hash = kSeedValue;
+    arrow::internal::hash_combine(result_hash, type);
+    arrow::internal::hash_combine(result_hash, key_hash);
+    hash_code_ = result_hash;
+    schema_ = key.schema();
+  }
+
+  BaseCacheKey(std::shared_ptr<arrow::Schema> schema, std::shared_ptr<Expression> expr,
+               std::string type)
+      : type_(type) {
+    static const int32_t kSeedValue = 4;
+    size_t result_hash = kSeedValue;
+    std::string schema_string = schema->ToString();
+    std::string expr_string = expr->ToString();
+    arrow::internal::hash_combine(result_hash, type);
+    arrow::internal::hash_combine(result_hash, schema_string);
+    arrow::internal::hash_combine(result_hash, expr_string);
+    hash_code_ = result_hash;
+  }
+
+  size_t Hash() const { return hash_code_; }
+
+  std::string Type() const { return type_; }
+
+  bool operator==(const BaseCacheKey& other) const {
+    if (hash_code_ != other.hash_code_) {
+      return false;
+    }
+    return true;
+  }
+
+  bool operator!=(const BaseCacheKey& other) const { return !(*this == other); }
+
+ private:
+  uint64_t hash_code_;
+  std::string type_;
+  SchemaPtr schema_;
+};
+
+}  // namespace gandiva

cpp/src/gandiva/cache.cc

@@ -20,13 +20,14 @@
 
 namespace gandiva {
 
-static const int DEFAULT_CACHE_SIZE = 500;
+static const size_t DEFAULT_CACHE_SIZE = 128 * 1024 * 1024;  // 256 MiB
 
-int GetCapacity() {
-  int capacity;
+size_t GetCapacity() {
+  size_t capacity;
   const char* env_cache_size = std::getenv("GANDIVA_CACHE_SIZE");
   if (env_cache_size != nullptr) {
     capacity = std::atoi(env_cache_size);
+
     if (capacity <= 0) {
       ARROW_LOG(WARNING) << "Invalid cache size provided. Using default cache size: "
                          << DEFAULT_CACHE_SIZE;
@@ -35,11 +36,12 @@ int GetCapacity() {
   } else {
     capacity = DEFAULT_CACHE_SIZE;
   }
+
   return capacity;
 }
 
 void LogCacheSize(size_t capacity) {
-  ARROW_LOG(INFO) << "Creating gandiva cache with capacity: " << capacity;
+  ARROW_LOG(INFO) << "Creating gandiva cache with capacity of " << capacity << " bytes";
 }
 
 }  // namespace gandiva

cpp/src/gandiva/cache.h

@@ -27,7 +27,7 @@
 namespace gandiva {
 
 GANDIVA_EXPORT
-int GetCapacity();
+size_t GetCapacity();
 
 GANDIVA_EXPORT
 void LogCacheSize(size_t capacity);
@@ -39,6 +39,10 @@ class Cache {
 
   Cache() : Cache(GetCapacity()) {}
 
+  ::std::shared_ptr<Cache> create(size_t capacity) {
+    return ::std::make_shared<Cache>(cache_(capacity));
+  }
+
   ValueType GetModule(KeyType cache_key) {
     arrow::util::optional<ValueCacheObject<ValueType>> result;
     mtx_.lock();
@@ -47,12 +51,32 @@ class Cache {
     return result != arrow::util::nullopt ? (*result).module : nullptr;
   }
 
+  ValueType GetObjectCode(KeyType cache_key) {
+    arrow::util::optional<ValueCacheObject<ValueType>> result;
+    mtx_.lock();
+    result = cache_.GetObjectCode(cache_key);
+    mtx_.unlock();
+    return result != arrow::util::nullopt ? (*result).module : nullptr;
+  }
+
   void PutModule(KeyType cache_key, ValueCacheObject<ValueType> valueCacheObject) {
     mtx_.lock();
     cache_.insert(cache_key, valueCacheObject);
     mtx_.unlock();
   }
 
+  void PutObjectCode(KeyType& cache_key, ValueCacheObject<ValueType> object_code) {
+    mtx_.lock();
+    cache_.InsertObjectCode(cache_key, object_code);
+    mtx_.unlock();
+  }
+
+  ::std::shared_ptr<Cache> CreateSharedCachePtr() { return Cache::create(); }
+
+  std::string ToString() { return cache_.ToString(); }
+
+  size_t GetCacheSize() { return cache_.GetCacheSize(); }
+
  private:
   GreedyDualSizeCache<KeyType, ValueType> cache_;
   std::mutex mtx_;

cpp/src/gandiva/engine.cc

@@ -167,7 +167,6 @@ Status Engine::Make(const std::shared_ptr<Configuration>& conf,
     return Status::CodeGenError("Could not instantiate llvm::ExecutionEngine: ",
                                 builder_error);
   }
-
   std::unique_ptr<Engine> engine{
       new Engine(conf, std::move(ctx), std::move(exec_engine), module_ptr)};
   ARROW_RETURN_NOT_OK(engine->Init());
@@ -303,11 +302,14 @@ Status Engine::FinalizeModule() {
 
   ARROW_RETURN_IF(llvm::verifyModule(*module_, &llvm::errs()),
                   Status::CodeGenError("Module verification failed after optimizer"));
-
   // do the compilation
+  if (execution_engine_->hasError()) {
+    ARROW_LOG(WARNING) << "[ERROR]: " << execution_engine_->getErrorMessage();
+    module_finalized_ = false;
+    return Status::ExecutionError(execution_engine_->getErrorMessage());
+  }
   execution_engine_->finalizeObject();
   module_finalized_ = true;
-
   return Status::OK();
 }
 

cpp/src/gandiva/engine.h

@@ -22,10 +22,10 @@
 #include <string>
 #include <vector>
 
-#include "arrow/util/macros.h"
-
 #include "arrow/util/logging.h"
+#include "arrow/util/macros.h"
 #include "gandiva/configuration.h"
+#include "gandiva/gandiva_object_cache.h"
 #include "gandiva/llvm_includes.h"
 #include "gandiva/llvm_types.h"
 #include "gandiva/visibility.h"
@@ -54,6 +54,17 @@ class GANDIVA_EXPORT Engine {
     functions_to_compile_.push_back(fname);
   }
 
+  /// Set BaseObjectCache.
+  template <class KeyType>
+  Status SetLLVMObjectCache(GandivaObjectCache<KeyType>& object_cache) {
+    execution_engine_->setObjectCache(&object_cache);
+    if (execution_engine_->hasError()) {
+      return Status::ExecutionError(
+          "[CACHE-LOG][ERROR]: Can not set custom llvm object cache");
+    }
+    return Status::OK();
+  }
+
   /// Optimise and compile the module.
   Status FinalizeModule();
 

cpp/src/gandiva/filter.cc

@@ -24,6 +24,7 @@
 
 #include "arrow/util/hash_util.h"
 
+#include "gandiva/base_cache_key.h"
 #include "gandiva/bitmap_accumulator.h"
 #include "gandiva/cache.h"
 #include "gandiva/condition.h"
@@ -42,7 +43,7 @@ FilterCacheKey::FilterCacheKey(SchemaPtr schema,
   expression_as_string_ = expression.ToString();
   UpdateUniqifier(expression_as_string_);
   arrow::internal::hash_combine(result, expression_as_string_);
-  arrow::internal::hash_combine(result, configuration);
+  arrow::internal::hash_combine(result, configuration->Hash());
   arrow::internal::hash_combine(result, schema_->ToString());
   arrow::internal::hash_combine(result, uniqifier_);
   hash_code_ = result;
@@ -102,14 +103,31 @@ Status Filter::Make(SchemaPtr schema, ConditionPtr condition,
   ARROW_RETURN_IF(configuration == nullptr,
                   Status::Invalid("Configuration cannot be null"));
 
-  static Cache<FilterCacheKey, std::shared_ptr<Filter>> cache;
-  FilterCacheKey cache_key(schema, configuration, *(condition.get()));
-  auto cachedFilter = cache.GetModule(cache_key);
-  if (cachedFilter != nullptr) {
-    *filter = cachedFilter;
-    return Status::OK();
+  std::shared_ptr<Cache<BaseCacheKey, std::shared_ptr<llvm::MemoryBuffer>>> shared_cache =
+      LLVMGenerator::GetCache();
+
+  Condition conditionToKey = *(condition.get());
+
+  FilterCacheKey filter_key(schema, configuration, conditionToKey);
+  BaseCacheKey cache_key(filter_key, "filter");
+  std::unique_ptr<BaseCacheKey> base_cache_key =
+      std::make_unique<BaseCacheKey>(cache_key);
+  std::shared_ptr<BaseCacheKey> shared_base_cache_key = std::move(base_cache_key);
+
+  bool llvm_flag = false;
+
+  std::shared_ptr<llvm::MemoryBuffer> prev_cached_obj;
+  prev_cached_obj = shared_cache->GetObjectCode(*shared_base_cache_key);
+
+  // Verify if previous filter obj code was cached
+  if (prev_cached_obj != nullptr) {
+    ARROW_LOG(DEBUG)
+        << "[DEBUG][CACHE-LOG][INFO]: Filter object code WAS already cached!";
+    llvm_flag = true;
   }
 
+  GandivaObjectCache<BaseCacheKey> obj_cache(shared_cache, shared_base_cache_key);
+
   // Build LLVM generator, and generate code for the specified expression
   std::unique_ptr<LLVMGenerator> llvm_gen;
   ARROW_RETURN_NOT_OK(LLVMGenerator::Make(configuration, &llvm_gen));
@@ -120,17 +138,27 @@ Status Filter::Make(SchemaPtr schema, ConditionPtr condition,
   ARROW_RETURN_NOT_OK(expr_validator.Validate(condition));
 
   // Start measuring build time
-  auto begin = std::chrono::high_resolution_clock::now();
-  ARROW_RETURN_NOT_OK(llvm_gen->Build({condition}, SelectionVector::Mode::MODE_NONE));
+  //  auto begin = std::chrono::high_resolution_clock::now();
+  //  ARROW_RETURN_NOT_OK(llvm_gen->Build({condition}, SelectionVector::Mode::MODE_NONE));
   // Stop measuring time and calculate the elapsed time
-  auto end = std::chrono::high_resolution_clock::now();
-  auto elapsed =
-      std::chrono::duration_cast<std::chrono::milliseconds>(end - begin).count();
+  //  auto end = std::chrono::high_resolution_clock::now();
+  //  auto elapsed =
+  //      std::chrono::duration_cast<std::chrono::milliseconds>(end - begin).count();
+  ARROW_RETURN_NOT_OK(
+      llvm_gen->Build({condition}, SelectionVector::Mode::MODE_NONE,
+                      obj_cache));  // to use when caching only the obj code
 
   // Instantiate the filter with the completely built llvm generator
   *filter = std::make_shared<Filter>(std::move(llvm_gen), schema, configuration);
-  ValueCacheObject<std::shared_ptr<Filter>> value_cache(*filter, elapsed);
-  cache.PutModule(cache_key, value_cache);
+  //  ValueCacheObject<std::shared_ptr<Filter>> value_cache(*filter, elapsed);
+  //  cache.PutModule(cache_key, value_cache);
+  //
+  filter->get()->SetCompiledFromCache(
+      llvm_flag);  // to use when caching only the obj code
+
+  ARROW_LOG(DEBUG)
+      << "[DEBUG][CACHE-LOG][INFO]: " +
+             shared_cache->ToString();  // to use when caching only the obj code
 
   return Status::OK();
 }
@@ -168,4 +196,8 @@ Status Filter::Evaluate(const arrow::RecordBatch& batch,
 
 std::string Filter::DumpIR() { return llvm_generator_->DumpIR(); }
 
+void Filter::SetCompiledFromCache(bool flag) { compiled_from_cache_ = flag; }
+
+bool Filter::GetCompiledFromCache() { return compiled_from_cache_; }
+
 }  // namespace gandiva

cpp/src/gandiva/filter.h

@@ -103,10 +103,14 @@ class GANDIVA_EXPORT Filter {
 
   std::string DumpIR();
 
+  void SetCompiledFromCache(bool flag);
+  bool GetCompiledFromCache();
+
  private:
   std::unique_ptr<LLVMGenerator> llvm_generator_;
   SchemaPtr schema_;
   std::shared_ptr<Configuration> configuration_;
+  bool compiled_from_cache_;
 };
 
 }  // namespace gandiva