move proportion knobs to execution options

Author: akroviakov

examples/heterogeneous_demo.ipynb

@@ -76,12 +76,11 @@
     "    prop_time = {col_names[0] : [], col_names[1]: []}\n",
     "    # Walking over proportions\n",
     "    for gpu_proportion in range(0, 101, prop_step):\n",
-    "        config.gpu_prop = gpu_proportion\n",
     "        # Multiple iterations\n",
     "        for _ in range(1, n_iters + 1):\n",
     "            rel_alg_executor = pyhdk.sql.RelAlgExecutor(executor, storage, data_mgr, ra)\n",
     "            query_start = time.perf_counter()\n",
-    "            result = rel_alg_executor.execute()\n",
+    "            result = rel_alg_executor.execute(forced_gpu_proportion=gpu_proportion)\n",
     "            query_finish = time.perf_counter()\n",
     "            prop_time[col_names[0]].append(gpu_proportion)\n",
     "            prop_time[col_names[1]].append(query_finish - query_start)\n",
@@ -157,7 +156,7 @@
    "outputs": [],
    "source": [
     "# Read data\n",
-    "dataset_path = \"some/path/myFile.csv\"\n",
+    "dataset_path = \"../omniscidb/Tests/ArrowStorageDataFiles/taxi_sample_header.csv\"\n",
     "table_name = \"taxi\"\n",
     "# If the CSV does not have a header, please provide the column names.\n",
     "pyarrow_tbl = pa.csv.read_csv(dataset_path)"

omniscidb/QueryEngine/CompilationOptions.h

@@ -108,6 +108,8 @@ struct ExecutionOptions {
   bool allow_runtime_query_interrupt;
   double running_query_interrupt_freq;
   unsigned pending_query_interrupt_freq;
+  unsigned forced_gpu_proportion;
+  unsigned forced_cpu_proportion;
   ExecutorType executor_type = ExecutorType::Native;
   std::vector<size_t> outer_fragment_indices{};
   bool multifrag_result = false;
@@ -134,6 +136,8 @@ struct ExecutionOptions {
 
     eo.multifrag_result = config.exec.enable_multifrag_rs;
     eo.preserve_order = false;
+    eo.forced_gpu_proportion = config.exec.heterogeneous.forced_gpu_proportion;
+    eo.forced_cpu_proportion = config.exec.heterogeneous.forced_cpu_proportion;
 
     return eo;
   }

omniscidb/QueryEngine/Execute.cpp

@@ -1936,7 +1936,8 @@ std::pair<std::unique_ptr<policy::ExecutionPolicy>, ExecutorDeviceType>
 Executor::getExecutionPolicyForTargets(const RelAlgExecutionUnit& ra_exe_unit,
                                        const ExecutorDeviceType requested_device_type,
                                        const std::vector<InputTableInfo>& query_infos,
-                                       size_t& max_groups_buffer_entry_guess) {
+                                       size_t& max_groups_buffer_entry_guess,
+                                       const ExecutionOptions& eo) {
   if (needFallbackOnCPU(ra_exe_unit, requested_device_type)) {
     LOG(DEBUG1) << "Devices Restricted, falling back on CPU";
     return {std::make_unique<policy::FragmentIDAssignmentExecutionPolicy>(
@@ -1995,8 +1996,8 @@ Executor::getExecutionPolicyForTargets(const RelAlgExecutionUnit& ra_exe_unit,
   if (cfg.enable_heterogeneous_execution) {
     if (cfg.forced_heterogeneous_distribution) {
       std::map<ExecutorDeviceType, unsigned> distribution{
-          {ExecutorDeviceType::CPU, cfg.forced_cpu_proportion},
-          {ExecutorDeviceType::GPU, cfg.forced_gpu_proportion}};
+          {ExecutorDeviceType::CPU, eo.forced_cpu_proportion},
+          {ExecutorDeviceType::GPU, eo.forced_gpu_proportion}};
       exe_policy = std::make_unique<policy::ProportionBasedExecutionPolicy>(
           std::move(distribution));
     } else {
@@ -2110,7 +2111,7 @@ hdk::ResultSetTable Executor::executeWorkUnitImpl(
     ColumnCacheMap& column_cache) {
   INJECT_TIMER(Exec_executeWorkUnit);
   auto [exe_policy, fallback_device] = getExecutionPolicyForTargets(
-      ra_exe_unit, co.device_type, query_infos, max_groups_buffer_entry_guess);
+      ra_exe_unit, co.device_type, query_infos, max_groups_buffer_entry_guess, eo);
 
   int8_t crt_min_byte_width{MAX_BYTE_WIDTH_SUPPORTED};
   do {

omniscidb/QueryEngine/Execute.h

@@ -472,7 +472,8 @@ class Executor : public StringDictionaryProxyProvider {
   getExecutionPolicyForTargets(const RelAlgExecutionUnit& ra_exe_unit,
                                const ExecutorDeviceType requested_device_type,
                                const std::vector<InputTableInfo>& query_infos,
-                               size_t& max_groups_buffer_entry_guess);
+                               size_t& max_groups_buffer_entry_guess,
+                               const ExecutionOptions& eo);
 
   hdk::ResultSetTable collectAllDeviceResults(
       SharedKernelContext& shared_context,

python/pyhdk/_common.pyx

@@ -184,56 +184,6 @@ cdef class TypeInfo:
   def __repr__(self):
     return self.c_type_info.toString()
 
-cdef class Config:
-  @property
-  def gpu_prop(self):
-    return self.c_config.get().exec.heterogeneous.forced_gpu_proportion
-  
-  @gpu_prop.setter
-  def gpu_prop(self, gpu_prop):
-    self.c_config.get().exec.heterogeneous.forced_gpu_proportion=gpu_prop
-    self.c_config.get().exec.heterogeneous.forced_cpu_proportion=100-gpu_prop
-  
-  @property
-  def allow_cpu_retry(self):
-    return self.c_config.get().exec.heterogeneous.allow_cpu_retry
-
-  @allow_cpu_retry.setter
-  def allow_cpu_retry(self, allowed):
-    self.c_config.get().exec.heterogeneous.allow_cpu_retry=allowed
-
-  @property
-  def allow_query_step_cpu_retry(self):
-    return self.c_config.get().exec.heterogeneous.allow_query_step_cpu_retry
-
-  @allow_query_step_cpu_retry.setter
-  def allow_query_step_cpu_retry(self, allowed):
-    self.c_config.get().exec.heterogeneous.allow_query_step_cpu_retry=allowed
-  
-  @property
-  def enable_heterogeneous_execution(self):
-    return self.c_config.get().exec.heterogeneous.enable_heterogeneous_execution
-
-  @enable_heterogeneous_execution.setter
-  def enable_heterogeneous_execution(self, enabled):
-    self.c_config.get().exec.heterogeneous.enable_heterogeneous_execution=enabled
-  
-  @property
-  def forced_heterogeneous_distribution(self):
-    return self.c_config.get().exec.heterogeneous.forced_heterogeneous_distribution
-
-  @forced_heterogeneous_distribution.setter
-  def forced_heterogeneous_distribution(self, enabled):
-    self.c_config.get().exec.heterogeneous.forced_heterogeneous_distribution=enabled
- 
-  @property
-  def enable_multifrag_heterogeneous_execution(self):
-    return self.c_config.get().exec.heterogeneous.enable_multifrag_heterogeneous_execution
-
-  @enable_multifrag_heterogeneous_execution.setter
-  def enable_multifrag_heterogeneous_execution(self, enabled):
-    self.c_config.get().exec.heterogeneous.enable_multifrag_heterogeneous_execution=enabled
-
 def buildConfig(*, enable_debug_timer=None, enable_union=False, log_dir="hdk_log", **kwargs):
   global g_enable_debug_timer
   if enable_debug_timer is not None:

python/pyhdk/_execute.pxd

@@ -83,6 +83,8 @@ cdef extern from "omniscidb/QueryEngine/CompilationOptions.h":
     double gpu_input_mem_limit_percent
     bool allow_runtime_query_interrupt
     double running_query_interrupt_freq
+    unsigned forced_gpu_proportion
+    unsigned forced_cpu_proportion
     unsigned pending_query_interrupt_freq
     CExecutorType executor_type
     vector[size_t] outer_fragment_indices

python/pyhdk/_sql.pyx

@@ -204,6 +204,8 @@ cdef class RelAlgExecutor:
     c_eo.get().with_watchdog = kwargs.get("enable_watchdog", config.exec.watchdog.enable)
     c_eo.get().with_dynamic_watchdog = kwargs.get("enable_dynamic_watchdog", config.exec.watchdog.enable_dynamic)
     c_eo.get().just_explain = kwargs.get("just_explain", False)
+    c_eo.get().forced_gpu_proportion = kwargs.get("forced_gpu_proportion", config.exec.heterogeneous.forced_gpu_proportion)
+    c_eo.get().forced_cpu_proportion = 100 - c_eo.get().forced_gpu_proportion
     cdef CExecutionResult c_res = self.c_rel_alg_executor.get().executeRelAlgQuery(c_co, dereference(c_eo.get()), False)
     cdef ExecutionResult res = ExecutionResult()
     res.c_result = move(c_res)