OmniSciDB  94e8789169
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
CommandLineOptions.cpp
Go to the documentation of this file.
1 /*
2  * Copyright 2020 OmniSci, Inc.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #include <fcntl.h>
18 #include <sys/stat.h>
19 #include <sys/types.h>
20 
21 #include <iostream>
22 
23 #include "CommandLineOptions.h"
24 #include "LeafHostInfo.h"
25 #include "MapDRelease.h"
27 #include "Shared/Compressor.h"
29 #include "Utils/DdlUtils.h"
30 
31 const std::string CommandLineOptions::nodeIds_token = {"node_id"};
32 
33 extern std::string cluster_command_line_arg;
34 
36 
37 extern bool g_use_table_device_offset;
39 extern bool g_cache_string_hash;
40 
41 extern int64_t g_large_ndv_threshold;
42 extern size_t g_large_ndv_multiplier;
43 extern int64_t g_bitmap_memory_limit;
44 extern bool g_enable_calcite_ddl_parser;
45 extern bool g_enable_seconds_refresh;
46 extern size_t g_approx_quantile_buffer;
47 extern size_t g_approx_quantile_centroids;
48 
49 namespace Catalog_Namespace {
50 extern bool g_log_user_id;
51 }
52 
53 unsigned connect_timeout{20000};
54 unsigned recv_timeout{300000};
55 unsigned send_timeout{300000};
56 bool with_keepalive{false};
57 
61  }
65 }
66 
68  help_desc.add_options()("help,h", "Show available options.");
69  help_desc.add_options()(
70  "allow-cpu-retry",
71  po::value<bool>(&g_allow_cpu_retry)
72  ->default_value(g_allow_cpu_retry)
73  ->implicit_value(true),
74  R"(Allow the queries which failed on GPU to retry on CPU, even when watchdog is enabled.)");
75  help_desc.add_options()("allow-loop-joins",
76  po::value<bool>(&allow_loop_joins)
77  ->default_value(allow_loop_joins)
78  ->implicit_value(true),
79  "Enable loop joins.");
80  help_desc.add_options()("bigint-count",
81  po::value<bool>(&g_bigint_count)
82  ->default_value(g_bigint_count)
83  ->implicit_value(true),
84  "Use 64-bit count.");
85  help_desc.add_options()("calcite-max-mem",
86  po::value<size_t>(&system_parameters.calcite_max_mem)
87  ->default_value(system_parameters.calcite_max_mem),
88  "Max memory available to calcite JVM.");
89  if (!dist_v5_) {
90  help_desc.add_options()("calcite-port",
91  po::value<int>(&system_parameters.calcite_port)
92  ->default_value(system_parameters.calcite_port),
93  "Calcite port number.");
94  }
95  help_desc.add_options()("config",
96  po::value<std::string>(&system_parameters.config_file),
97  "Path to server configuration file.");
98  help_desc.add_options()("cpu-buffer-mem-bytes",
99  po::value<size_t>(&system_parameters.cpu_buffer_mem_bytes)
100  ->default_value(system_parameters.cpu_buffer_mem_bytes),
101  "Size of memory reserved for CPU buffers, in bytes.");
102 
103  help_desc.add_options()(
104  "cpu-only",
105  po::value<bool>(&cpu_only)->default_value(cpu_only)->implicit_value(true),
106  "Run on CPU only, even if GPUs are available.");
107  help_desc.add_options()("cuda-block-size",
108  po::value<size_t>(&system_parameters.cuda_block_size)
109  ->default_value(system_parameters.cuda_block_size),
110  "Size of block to use on GPU.");
111  help_desc.add_options()("cuda-grid-size",
112  po::value<size_t>(&system_parameters.cuda_grid_size)
113  ->default_value(system_parameters.cuda_grid_size),
114  "Size of grid to use on GPU.");
115  if (!dist_v5_) {
116  help_desc.add_options()(
117  "data",
118  po::value<std::string>(&base_path)->required()->default_value("data"),
119  "Directory path to OmniSci data storage (catalogs, raw data, log files, etc).");
120  positional_options.add("data", 1);
121  }
122  help_desc.add_options()("db-query-list",
123  po::value<std::string>(&db_query_file),
124  "Path to file containing OmniSci warmup queries.");
125  help_desc.add_options()(
126  "exit-after-warmup",
127  po::value<bool>(&exit_after_warmup)->default_value(false)->implicit_value(true),
128  "Exit after OmniSci warmup queries.");
129  help_desc.add_options()("dynamic-watchdog-time-limit",
130  po::value<unsigned>(&dynamic_watchdog_time_limit)
131  ->default_value(dynamic_watchdog_time_limit)
132  ->implicit_value(10000),
133  "Dynamic watchdog time limit, in milliseconds.");
134  help_desc.add_options()("enable-debug-timer",
135  po::value<bool>(&g_enable_debug_timer)
136  ->default_value(g_enable_debug_timer)
137  ->implicit_value(true),
138  "Enable debug timer logging.");
139  help_desc.add_options()("enable-dynamic-watchdog",
140  po::value<bool>(&enable_dynamic_watchdog)
141  ->default_value(enable_dynamic_watchdog)
142  ->implicit_value(true),
143  "Enable dynamic watchdog.");
144  help_desc.add_options()("enable-filter-push-down",
145  po::value<bool>(&g_enable_filter_push_down)
146  ->default_value(g_enable_filter_push_down)
147  ->implicit_value(true),
148  "Enable filter push down through joins.");
149  help_desc.add_options()("enable-overlaps-hashjoin",
150  po::value<bool>(&g_enable_overlaps_hashjoin)
151  ->default_value(g_enable_overlaps_hashjoin)
152  ->implicit_value(true),
153  "Enable the overlaps hash join framework allowing for range "
154  "join (e.g. spatial overlaps) computation using a hash table.");
155  help_desc.add_options()("enable-hashjoin-many-to-many",
156  po::value<bool>(&g_enable_hashjoin_many_to_many)
157  ->default_value(g_enable_hashjoin_many_to_many)
158  ->implicit_value(true),
159  "Enable the overlaps hash join framework allowing for range "
160  "join (e.g. spatial overlaps) computation using a hash table.");
161  help_desc.add_options()("enable-runtime-query-interrupt",
162  po::value<bool>(&enable_runtime_query_interrupt)
163  ->default_value(enable_runtime_query_interrupt)
164  ->implicit_value(true),
165  "Enable runtime query interrupt.");
166  help_desc.add_options()("pending-query-interrupt-freq",
167  po::value<unsigned>(&pending_query_interrupt_freq)
168  ->default_value(pending_query_interrupt_freq)
169  ->implicit_value(1000),
170  "A frequency of checking the request of pending query "
171  "interrupt from user (in millisecond).");
172  help_desc.add_options()(
173  "running-query-interrupt-freq",
174  po::value<double>(&running_query_interrupt_freq)
175  ->default_value(running_query_interrupt_freq)
176  ->implicit_value(0.5),
177  "A frequency of checking the request of running query "
178  "interrupt from user (0.0 (less frequent) ~ (more frequent) 1.0).");
179  help_desc.add_options()("use-estimator-result-cache",
180  po::value<bool>(&use_estimator_result_cache)
181  ->default_value(use_estimator_result_cache)
182  ->implicit_value(true),
183  "Use estimator result cache.");
184  if (!dist_v5_) {
185  help_desc.add_options()(
186  "enable-string-dict-hash-cache",
187  po::value<bool>(&g_cache_string_hash)
188  ->default_value(g_cache_string_hash)
189  ->implicit_value(true),
190  "Cache string hash values in the string dictionary server during import.");
191  }
192  help_desc.add_options()(
193  "enable-thrift-logs",
194  po::value<bool>(&g_enable_thrift_logs)
195  ->default_value(g_enable_thrift_logs)
196  ->implicit_value(true),
197  "Enable writing messages directly from thrift to stdout/stderr.");
198  help_desc.add_options()("enable-watchdog",
199  po::value<bool>(&enable_watchdog)
200  ->default_value(enable_watchdog)
201  ->implicit_value(true),
202  "Enable watchdog.");
203  help_desc.add_options()(
204  "filter-push-down-low-frac",
205  po::value<float>(&g_filter_push_down_low_frac)
206  ->default_value(g_filter_push_down_low_frac)
207  ->implicit_value(g_filter_push_down_low_frac),
208  "Lower threshold for selectivity of filters that are pushed down.");
209  help_desc.add_options()(
210  "filter-push-down-high-frac",
211  po::value<float>(&g_filter_push_down_high_frac)
212  ->default_value(g_filter_push_down_high_frac)
213  ->implicit_value(g_filter_push_down_high_frac),
214  "Higher threshold for selectivity of filters that are pushed down.");
215  help_desc.add_options()("filter-push-down-passing-row-ubound",
216  po::value<size_t>(&g_filter_push_down_passing_row_ubound)
218  ->implicit_value(g_filter_push_down_passing_row_ubound),
219  "Upperbound on the number of rows that should pass the filter "
220  "if the selectivity is less than "
221  "the high fraction threshold.");
222  help_desc.add_options()("from-table-reordering",
223  po::value<bool>(&g_from_table_reordering)
224  ->default_value(g_from_table_reordering)
225  ->implicit_value(true),
226  "Enable automatic table reordering in FROM clause.");
227  help_desc.add_options()("gpu-buffer-mem-bytes",
228  po::value<size_t>(&system_parameters.gpu_buffer_mem_bytes)
229  ->default_value(system_parameters.gpu_buffer_mem_bytes),
230  "Size of memory reserved for GPU buffers, in bytes, per GPU.");
231  help_desc.add_options()("gpu-input-mem-limit",
232  po::value<double>(&system_parameters.gpu_input_mem_limit)
233  ->default_value(system_parameters.gpu_input_mem_limit),
234  "Force query to CPU when input data memory usage exceeds this "
235  "percentage of available GPU memory.");
236  help_desc.add_options()(
237  "hll-precision-bits",
238  po::value<int>(&g_hll_precision_bits)
239  ->default_value(g_hll_precision_bits)
240  ->implicit_value(g_hll_precision_bits),
241  "Number of bits used from the hash value used to specify the bucket number.");
242  if (!dist_v5_) {
243  help_desc.add_options()("http-port",
244  po::value<int>(&http_port)->default_value(http_port),
245  "HTTP port number.");
246  }
247  help_desc.add_options()(
248  "idle-session-duration",
249  po::value<int>(&idle_session_duration)->default_value(idle_session_duration),
250  "Maximum duration of idle session.");
251  help_desc.add_options()("inner-join-fragment-skipping",
252  po::value<bool>(&g_inner_join_fragment_skipping)
253  ->default_value(g_inner_join_fragment_skipping)
254  ->implicit_value(true),
255  "Enable/disable inner join fragment skipping. This feature is "
256  "considered stable and is enabled by default. This "
257  "parameter will be removed in a future release.");
258  help_desc.add_options()(
259  "max-session-duration",
260  po::value<int>(&max_session_duration)->default_value(max_session_duration),
261  "Maximum duration of active session.");
262  help_desc.add_options()(
263  "null-div-by-zero",
264  po::value<bool>(&g_null_div_by_zero)
265  ->default_value(g_null_div_by_zero)
266  ->implicit_value(true),
267  "Return null on division by zero instead of throwing an exception.");
268  help_desc.add_options()(
269  "num-reader-threads",
270  po::value<size_t>(&num_reader_threads)->default_value(num_reader_threads),
271  "Number of reader threads to use.");
272  help_desc.add_options()(
273  "max-import-threads",
274  po::value<size_t>(&g_max_import_threads)->default_value(g_max_import_threads),
275  "Max number of default import threads to use (num hardware threads will be used "
276  "instead if lower). Can be overriden with copy statement threads option).");
277  help_desc.add_options()(
278  "overlaps-max-table-size-bytes",
279  po::value<size_t>(&g_overlaps_max_table_size_bytes)
280  ->default_value(g_overlaps_max_table_size_bytes),
281  "The maximum size in bytes of the hash table for an overlaps hash join.");
282  help_desc.add_options()("overlaps-target-entries-per-bin",
283  po::value<double>(&g_overlaps_target_entries_per_bin)
284  ->default_value(g_overlaps_target_entries_per_bin),
285  "The target number of hash entries per bin for overlaps join");
286  if (!dist_v5_) {
287  help_desc.add_options()("port,p",
288  po::value<int>(&system_parameters.omnisci_server_port)
289  ->default_value(system_parameters.omnisci_server_port),
290  "TCP Port number.");
291  }
292  help_desc.add_options()("num-gpus",
293  po::value<int>(&num_gpus)->default_value(num_gpus),
294  "Number of gpus to use.");
295  help_desc.add_options()(
296  "read-only",
297  po::value<bool>(&read_only)->default_value(read_only)->implicit_value(true),
298  "Enable read-only mode.");
299 
300  help_desc.add_options()(
301  "res-gpu-mem",
302  po::value<size_t>(&reserved_gpu_mem)->default_value(reserved_gpu_mem),
303  "Reduces GPU memory available to the OmniSci allocator by this amount. Used for "
304  "compiled code cache and ancillary GPU functions and other processes that may also "
305  "be using the GPU concurrent with OmniSciDB.");
306 
307  help_desc.add_options()("start-gpu",
308  po::value<int>(&start_gpu)->default_value(start_gpu),
309  "First gpu to use.");
310  help_desc.add_options()("trivial-loop-join-threshold",
311  po::value<unsigned>(&g_trivial_loop_join_threshold)
312  ->default_value(g_trivial_loop_join_threshold)
313  ->implicit_value(1000),
314  "The maximum number of rows in the inner table of a loop join "
315  "considered to be trivially small.");
316  help_desc.add_options()("verbose",
317  po::value<bool>(&verbose_logging)
318  ->default_value(verbose_logging)
319  ->implicit_value(true),
320  "Write additional debug log messages to server logs.");
321  help_desc.add_options()(
322  "enable-runtime-udf",
323  po::value<bool>(&enable_runtime_udf)
324  ->default_value(enable_runtime_udf)
325  ->implicit_value(true),
326  "Enable runtime UDF registration by passing signatures and corresponding LLVM IR "
327  "to the `register_runtime_udf` endpoint. For use with the Python Remote Backend "
328  "Compiler server, packaged separately.");
329  help_desc.add_options()("version,v", "Print Version Number.");
330  help_desc.add_options()("enable-experimental-string-functions",
333  ->implicit_value(true),
334  "Enable experimental string functions.");
335  help_desc.add_options()(
336  "enable-fsi",
337  po::value<bool>(&g_enable_fsi)->default_value(g_enable_fsi)->implicit_value(true),
338  "Enable foreign storage interface.");
339  help_desc.add_options()("disk-cache-path",
340  po::value<std::string>(&disk_cache_config.path),
341  "Specify the path for the disk cache.");
342 
343 #ifdef ENABLE_GENERAL_DISK_CACHE
344  help_desc.add_options()(
345  "disk-cache-level",
346  po::value<std::string>(&(disk_cache_level))->default_value("foreign_tables"),
347  "Specify level of disk cache. Valid options are 'foreign_tables', "
348  "'local_tables', 'none', and 'all'.");
349 #else
350  help_desc.add_options()(
351  "disk-cache-level",
352  po::value<std::string>(&(disk_cache_level))->default_value("foreign_tables"),
353  "Specify level of disk cache. Valid options are 'foreign_tables' "
354  "and 'none'.");
355 #endif // ENABLE_GENERAL_DISK_CACHE
356 
357  help_desc.add_options()(
358  "enable-interoperability",
359  po::value<bool>(&g_enable_interop)
360  ->default_value(g_enable_interop)
361  ->implicit_value(true),
362  "Enable offloading of query portions to an external execution engine.");
363  help_desc.add_options()("enable-union",
364  po::value<bool>(&g_enable_union)
365  ->default_value(g_enable_union)
366  ->implicit_value(true),
367  "Enable UNION ALL SQL clause.");
368  help_desc.add_options()(
369  "calcite-service-timeout",
370  po::value<size_t>(&system_parameters.calcite_timeout)
371  ->default_value(system_parameters.calcite_timeout),
372  "Calcite server timeout (milliseconds). Increase this on systems with frequent "
373  "schema changes or when running large numbers of parallel queries.");
374  help_desc.add_options()("calcite-service-keepalive",
375  po::value<size_t>(&system_parameters.calcite_keepalive)
376  ->default_value(system_parameters.calcite_keepalive)
377  ->implicit_value(true),
378  "Enable keepalive on Calcite connections.");
379  help_desc.add_options()(
380  "stringdict-parallelizm",
381  po::value<bool>(&g_enable_stringdict_parallel)
382  ->default_value(g_enable_stringdict_parallel)
383  ->implicit_value(true),
384  "Allow StringDictionary to parallelize loads using multiple threads");
385  help_desc.add_options()(
386  "log-user-id",
387  po::value<bool>(&Catalog_Namespace::g_log_user_id)
388  ->default_value(Catalog_Namespace::g_log_user_id)
389  ->implicit_value(true),
390  "Log userId integer in place of the userName (when available).");
391  help_desc.add_options()("log-user-origin",
392  po::value<bool>(&log_user_origin)
393  ->default_value(log_user_origin)
394  ->implicit_value(true),
395  "Lookup the origin of inbound connections by IP address/DNS "
396  "name, and print this information as part of stdlog.");
398 }
399 
401  developer_desc.add_options()("dev-options", "Print internal developer options.");
402  developer_desc.add_options()(
403  "enable-calcite-view-optimize",
406  ->implicit_value(true),
407  "Enable additional calcite (query plan) optimizations when a view is part of the "
408  "query.");
409  developer_desc.add_options()(
410  "enable-columnar-output",
411  po::value<bool>(&g_enable_columnar_output)
412  ->default_value(g_enable_columnar_output)
413  ->implicit_value(true),
414  "Enable columnar output for intermediate/final query steps.");
415  developer_desc.add_options()("enable-legacy-syntax",
416  po::value<bool>(&enable_legacy_syntax)
417  ->default_value(enable_legacy_syntax)
418  ->implicit_value(true),
419  "Enable legacy syntax.");
420  developer_desc.add_options()(
421  "enable-multifrag",
422  po::value<bool>(&allow_multifrag)
423  ->default_value(allow_multifrag)
424  ->implicit_value(true),
425  "Enable execution over multiple fragments in a single round-trip to GPU.");
426  developer_desc.add_options()(
427  "enable-shared-mem-group-by",
428  po::value<bool>(&g_enable_smem_group_by)
429  ->default_value(g_enable_smem_group_by)
430  ->implicit_value(true),
431  "Enable using GPU shared memory for some GROUP BY queries.");
432  developer_desc.add_options()("num-executors",
433  po::value<int>(&system_parameters.num_executors)
434  ->default_value(system_parameters.num_executors),
435  "Number of executors to run in parallel.");
436  developer_desc.add_options()(
437  "gpu-shared-mem-threshold",
438  po::value<size_t>(&g_gpu_smem_threshold)->default_value(g_gpu_smem_threshold),
439  "GPU shared memory threshold (in bytes). If query requires larger buffers than "
440  "this threshold, we disable those optimizations. 0 (default) means no static cap.");
441  developer_desc.add_options()(
442  "enable-shared-mem-grouped-non-count-agg",
443  po::value<bool>(&g_enable_smem_grouped_non_count_agg)
444  ->default_value(g_enable_smem_grouped_non_count_agg)
445  ->implicit_value(true),
446  "Enable using GPU shared memory for grouped non-count aggregate queries.");
447  developer_desc.add_options()(
448  "enable-shared-mem-non-grouped-agg",
449  po::value<bool>(&g_enable_smem_non_grouped_agg)
450  ->default_value(g_enable_smem_non_grouped_agg)
451  ->implicit_value(true),
452  "Enable using GPU shared memory for non-grouped aggregate queries.");
453  developer_desc.add_options()("enable-direct-columnarization",
454  po::value<bool>(&g_enable_direct_columnarization)
455  ->default_value(g_enable_direct_columnarization)
456  ->implicit_value(true),
457  "Enables/disables a more optimized columnarization method "
458  "for intermediate steps in multi-step queries.");
459  developer_desc.add_options()(
460  "offset-device-by-table-id",
461  po::value<bool>(&g_use_table_device_offset)
462  ->default_value(g_use_table_device_offset)
463  ->implicit_value(true),
464  "Enables/disables offseting the chosen device ID by the table ID for a given "
465  "fragment. This improves balance of fragments across GPUs.");
466  developer_desc.add_options()("enable-window-functions",
467  po::value<bool>(&g_enable_window_functions)
468  ->default_value(g_enable_window_functions)
469  ->implicit_value(true),
470  "Enable experimental window function support.");
471  developer_desc.add_options()("enable-table-functions",
472  po::value<bool>(&g_enable_table_functions)
473  ->default_value(g_enable_table_functions)
474  ->implicit_value(true),
475  "Enable experimental table functions support.");
476  developer_desc.add_options()(
477  "jit-debug-ir",
478  po::value<bool>(&jit_debug)->default_value(jit_debug)->implicit_value(true),
479  "Enable runtime debugger support for the JIT. Note that this flag is "
480  "incompatible "
481  "with the `ENABLE_JIT_DEBUG` build flag. The generated code can be found at "
482  "`/tmp/mapdquery`.");
483  developer_desc.add_options()(
484  "intel-jit-profile",
485  po::value<bool>(&intel_jit_profile)
486  ->default_value(intel_jit_profile)
487  ->implicit_value(true),
488  "Enable runtime support for the JIT code profiling using Intel VTune.");
489  developer_desc.add_options()(
490  "enable-modern-thread-pool",
491  po::value<bool>(&g_use_tbb_pool)
492  ->default_value(g_use_tbb_pool)
493  ->implicit_value(true),
494  "Enable a new thread pool implementation for queuing kernels for execution.");
495  developer_desc.add_options()(
496  "skip-intermediate-count",
497  po::value<bool>(&g_skip_intermediate_count)
498  ->default_value(g_skip_intermediate_count)
499  ->implicit_value(true),
500  "Skip pre-flight counts for intermediate projections with no filters.");
501  developer_desc.add_options()(
502  "strip-join-covered-quals",
503  po::value<bool>(&g_strip_join_covered_quals)
504  ->default_value(g_strip_join_covered_quals)
505  ->implicit_value(true),
506  "Remove quals from the filtered count if they are covered by a "
507  "join condition (currently only ST_Contains).");
508 
509  developer_desc.add_options()(
510  "min-cpu-slab-size",
511  po::value<size_t>(&system_parameters.min_cpu_slab_size)
512  ->default_value(system_parameters.min_cpu_slab_size),
513  "Min slab size (size of memory allocations) for CPU buffer pool.");
514  developer_desc.add_options()(
515  "max-cpu-slab-size",
516  po::value<size_t>(&system_parameters.max_cpu_slab_size)
517  ->default_value(system_parameters.max_cpu_slab_size),
518  "Max CPU buffer pool slab size (size of memory allocations). Note if "
519  "there is not enough free memory to accomodate the target slab size, smaller "
520  "slabs will be allocated, down to the minimum size specified by "
521  "min-cpu-slab-size.");
522  developer_desc.add_options()(
523  "min-gpu-slab-size",
524  po::value<size_t>(&system_parameters.min_gpu_slab_size)
525  ->default_value(system_parameters.min_gpu_slab_size),
526  "Min slab size (size of memory allocations) for GPU buffer pools.");
527  developer_desc.add_options()(
528  "max-gpu-slab-size",
529  po::value<size_t>(&system_parameters.max_gpu_slab_size)
530  ->default_value(system_parameters.max_gpu_slab_size),
531  "Max GPU buffer pool slab size (size of memory allocations). Note if "
532  "there is not enough free memory to accomodate the target slab size, smaller "
533  "slabs will be allocated, down to the minimum size speified by "
534  "min-gpu-slab-size.");
535 
536  developer_desc.add_options()(
537  "max-output-projection-allocation-bytes",
538  po::value<size_t>(&g_max_memory_allocation_size)
539  ->default_value(g_max_memory_allocation_size),
540  "Maximum allocation size for a fixed output buffer allocation for projection "
541  "queries with no pre-flight count. Default is the maximum slab size (sizes "
542  "greater "
543  "than the maximum slab size have no affect). Requires bump allocator.");
544  developer_desc.add_options()(
545  "min-output-projection-allocation-bytes",
546  po::value<size_t>(&g_min_memory_allocation_size)
547  ->default_value(g_min_memory_allocation_size),
548  "Minimum allocation size for a fixed output buffer allocation for projection "
549  "queries with no pre-flight count. If an allocation of this size cannot be "
550  "obtained, the query will be retried with different execution parameters and/or "
551  "on "
552  "CPU (if allow-cpu-retry is enabled). Requires bump allocator.");
553  developer_desc.add_options()("enable-bump-allocator",
554  po::value<bool>(&g_enable_bump_allocator)
555  ->default_value(g_enable_bump_allocator)
556  ->implicit_value(true),
557  "Enable the bump allocator for projection queries on "
558  "GPU. The bump allocator will "
559  "allocate a fixed size buffer for each query, track the "
560  "number of rows passing the "
561  "kernel during query execution, and copy back only the "
562  "rows that passed the kernel "
563  "to CPU after execution. When disabled, pre-flight "
564  "count queries are used to size "
565  "the output buffer for projection queries.");
566  developer_desc.add_options()(
567  "code-cache-eviction-percent",
568  po::value<float>(&g_fraction_code_cache_to_evict)
569  ->default_value(g_fraction_code_cache_to_evict),
570  "Percentage of the GPU code cache to evict if an out of memory error is "
571  "encountered while attempting to place generated code on the GPU.");
572 
573  developer_desc.add_options()("ssl-cert",
574  po::value<std::string>(&system_parameters.ssl_cert_file)
575  ->default_value(std::string("")),
576  "SSL Validated public certficate.");
577 
578  developer_desc.add_options()("ssl-private-key",
579  po::value<std::string>(&system_parameters.ssl_key_file)
580  ->default_value(std::string("")),
581  "SSL private key file.");
582  // Note ssl_trust_store is passed through to Calcite via system_parameters
583  // todo(jack): add ensure ssl-trust-store exists if cert and private key in use
584  developer_desc.add_options()("ssl-trust-store",
585  po::value<std::string>(&system_parameters.ssl_trust_store)
586  ->default_value(std::string("")),
587  "SSL public CA certifcates (java trust store) to validate "
588  "TLS connections (passed through to the Calcite server).");
589 
590  developer_desc.add_options()(
591  "ssl-trust-password",
592  po::value<std::string>(&system_parameters.ssl_trust_password)
593  ->default_value(std::string("")),
594  "SSL password for java trust store provided via --ssl-trust-store parameter.");
595 
596  developer_desc.add_options()(
597  "ssl-trust-ca",
598  po::value<std::string>(&system_parameters.ssl_trust_ca_file)
599  ->default_value(std::string("")),
600  "SSL public CA certificates to validate TLS connection(as a client).");
601 
602  developer_desc.add_options()(
603  "ssl-trust-ca-server",
604  po::value<std::string>(&authMetadata.ca_file_name)->default_value(std::string("")),
605  "SSL public CA certificates to validate TLS connection(as a server).");
606 
607  developer_desc.add_options()("ssl-keystore",
608  po::value<std::string>(&system_parameters.ssl_keystore)
609  ->default_value(std::string("")),
610  "SSL server credentials as a java key store (passed "
611  "through to the Calcite server).");
612 
613  developer_desc.add_options()(
614  "ssl-keystore-password",
615  po::value<std::string>(&system_parameters.ssl_keystore_password)
616  ->default_value(std::string("")),
617  "SSL password for java keystore, provide by via --ssl-keystore.");
618 
619  developer_desc.add_options()(
620  "udf",
621  po::value<std::string>(&udf_file_name),
622  "Load user defined extension functions from this file at startup. The file is "
623  "expected to be a C/C++ file with extension .cpp.");
624 
625  developer_desc.add_options()(
626  "udf-compiler-path",
627  po::value<std::string>(&udf_compiler_path),
628  "Provide absolute path to clang++ used in udf compilation.");
629 
630  developer_desc.add_options()("udf-compiler-options",
631  po::value<std::vector<std::string>>(&udf_compiler_options),
632  "Specify compiler options to tailor udf compilation.");
633 
634 #ifdef ENABLE_GEOS
635  developer_desc.add_options()("libgeos-so-filename",
636  po::value<std::string>(&libgeos_so_filename),
637  "Specify libgeos shared object filename to be used for "
638  "geos-backed geo opertations.");
639 #endif
640  developer_desc.add_options()(
641  "large-ndv-threshold",
642  po::value<int64_t>(&g_large_ndv_threshold)->default_value(g_large_ndv_threshold));
643  developer_desc.add_options()(
644  "large-ndv-multiplier",
645  po::value<size_t>(&g_large_ndv_multiplier)->default_value(g_large_ndv_multiplier));
646  developer_desc.add_options()("approx_quantile_buffer",
647  po::value<size_t>(&g_approx_quantile_buffer)
648  ->default_value(g_approx_quantile_buffer));
649  developer_desc.add_options()("approx_quantile_centroids",
650  po::value<size_t>(&g_approx_quantile_centroids)
651  ->default_value(g_approx_quantile_centroids));
652  developer_desc.add_options()(
653  "bitmap-memory-limit",
654  po::value<int64_t>(&g_bitmap_memory_limit)->default_value(g_bitmap_memory_limit),
655  "Limit for count distinct bitmap memory use. The limit is computed by taking the "
656  "size of the group by buffer (entry count in Query Memory Descriptor) and "
657  "multiplying it by the number of count distinct expression and the size of bitmap "
658  "required for each. For approx_count_distinct this is typically 8192 bytes.");
659  developer_desc.add_options()(
660  "enable-filter-function",
661  po::value<bool>(&g_enable_filter_function)
662  ->default_value(g_enable_filter_function)
663  ->implicit_value(true),
664  "Enable the filter function protection feature for the SQL JIT compiler. "
665  "Normally should be on but techs might want to disable for troubleshooting.");
666  developer_desc.add_options()(
667  "enable-calcite-ddl",
668  po::value<bool>(&g_enable_calcite_ddl_parser)
669  ->default_value(g_enable_calcite_ddl_parser)
670  ->implicit_value(true),
671  "Enable using Calcite for supported DDL parsing when available.");
672  developer_desc.add_options()(
673  "enable-seconds-refresh-interval",
674  po::value<bool>(&g_enable_seconds_refresh)
675  ->default_value(g_enable_seconds_refresh)
676  ->implicit_value(true),
677  "Enable foreign table seconds refresh interval for testing purposes.");
678 }
679 
680 namespace {
681 
682 std::stringstream sanitize_config_file(std::ifstream& in) {
683  // Strip the web section out of the config file so boost can validate program options
684  std::stringstream ss;
685  std::string line;
686  while (std::getline(in, line)) {
687  // Skip config file only options
688  if (!boost::starts_with(line, "allowed-import-paths") &&
689  !boost::starts_with(line, "allowed-export-paths")) {
690  ss << line << "\n";
691  }
692  if (line == "[web]") {
693  break;
694  }
695  }
696  return ss;
697 }
698 
699 bool trim_and_check_file_exists(std::string& filename, const std::string desc) {
700  if (!filename.empty()) {
701  boost::algorithm::trim_if(filename, boost::is_any_of("\"'"));
702  if (!boost::filesystem::exists(filename)) {
703  std::cerr << desc << " " << filename << " does not exist." << std::endl;
704  return false;
705  }
706  }
707  return true;
708 }
709 
711  if (!filename.empty()) {
713  }
714 }
715 
716 } // namespace
717 
719  boost::algorithm::trim_if(base_path, boost::is_any_of("\"'"));
720  if (!boost::filesystem::exists(base_path)) {
721  throw std::runtime_error("OmniSci base directory does not exist at " + base_path);
722  }
723 }
724 
726  boost::algorithm::trim_if(base_path, boost::is_any_of("\"'"));
727  const auto data_path = boost::filesystem::path(base_path) / "mapd_data";
728  if (!boost::filesystem::exists(data_path)) {
729  throw std::runtime_error("OmniSci data directory does not exist at '" + base_path +
730  "'");
731  }
732 
733  {
734  const auto lock_file = boost::filesystem::path(base_path) / "omnisci_server_pid.lck";
735  auto pid = std::to_string(getpid());
736 
737  int pid_fd = open(lock_file.c_str(), O_RDWR | O_CREAT, 0644);
738  if (pid_fd == -1) {
739  auto err = std::string("Failed to open PID file ") + lock_file.c_str() + ". " +
740  strerror(errno) + ".";
741  throw std::runtime_error(err);
742  }
743  if (lockf(pid_fd, F_TLOCK, 0) == -1) {
744  close(pid_fd);
745  auto err = std::string("Another OmniSci Server is using data directory ") +
746  base_path + ".";
747  throw std::runtime_error(err);
748  }
749  if (ftruncate(pid_fd, 0) == -1) {
750  close(pid_fd);
751  auto err = std::string("Failed to truncate PID file ") + lock_file.c_str() + ". " +
752  strerror(errno) + ".";
753  throw std::runtime_error(err);
754  }
755  if (write(pid_fd, pid.c_str(), pid.length()) == -1) {
756  close(pid_fd);
757  auto err = std::string("Failed to write PID file ") + lock_file.c_str() + ". " +
758  strerror(errno) + ".";
759  throw std::runtime_error(err);
760  }
761  }
762  boost::algorithm::trim_if(db_query_file, boost::is_any_of("\"'"));
763  if (db_query_file.length() > 0 && !boost::filesystem::exists(db_query_file)) {
764  throw std::runtime_error("File containing DB queries " + db_query_file +
765  " does not exist.");
766  }
767  const auto db_file =
768  boost::filesystem::path(base_path) / "mapd_catalogs" / OMNISCI_SYSTEM_CATALOG;
769  if (!boost::filesystem::exists(db_file)) {
770  { // check old system catalog existsense
771  const auto db_file = boost::filesystem::path(base_path) / "mapd_catalogs/mapd";
772  if (!boost::filesystem::exists(db_file)) {
773  throw std::runtime_error("OmniSci system catalog " + OMNISCI_SYSTEM_CATALOG +
774  " does not exist.");
775  }
776  }
777  }
778  if (license_path.length() == 0) {
779  license_path = base_path + "/omnisci.license";
780  }
781 
782  // add all parameters to be displayed on startup
783  LOG(INFO) << "OmniSci started with data directory at '" << base_path << "'";
784  if (vm.count("license-path")) {
785  LOG(INFO) << "License key path set to '" << license_path << "'";
786  }
787  LOG(INFO) << " Watchdog is set to " << enable_watchdog;
788  LOG(INFO) << " Dynamic Watchdog is set to " << enable_dynamic_watchdog;
790  LOG(INFO) << " Dynamic Watchdog timeout is set to " << dynamic_watchdog_time_limit;
791  }
792  LOG(INFO) << " Runtime query interrupt is set to " << enable_runtime_query_interrupt;
794  LOG(INFO) << " A frequency of checking pending query interrupt request is set to "
795  << pending_query_interrupt_freq << " (in ms.)";
796  LOG(INFO) << " A frequency of checking running query interrupt request is set to "
797  << running_query_interrupt_freq << " (0.0 ~ 1.0)";
798  }
799 
800  LOG(INFO) << " Debug Timer is set to " << g_enable_debug_timer;
801  LOG(INFO) << " LogUserId is set to " << Catalog_Namespace::g_log_user_id;
802  LOG(INFO) << " Maximum Idle session duration " << idle_session_duration;
803  LOG(INFO) << " Maximum active session duration " << max_session_duration;
804 
806 
810  g_enable_s3_fsi = false;
811 
812  if (disk_cache_level == "foreign_tables") {
813  if (g_enable_fsi) {
815  LOG(INFO) << "Disk cache enabled for foreign tables only";
816  } else {
817  LOG(INFO) << "Cannot enable disk cache for fsi when fsi is disabled. Defaulted to "
818  "disk cache disabled";
819  }
820 #ifdef ENABLE_GENERAL_DISK_CACHE
821  } else if (disk_cache_level == "all") {
823  LOG(INFO) << "Disk cache enabled for all tables";
824  } else if (disk_cache_level == "local_tables") {
826  LOG(INFO) << "Disk cache enabled for non-FSI tables";
827 #endif // ENABLE_GENERAL_DISK_CACHE
828  } else if (disk_cache_level == "none") {
830  LOG(INFO) << "Disk cache disabled";
831  } else {
832 #ifdef ENABLE_GENERAL_DISK_CACHE
833  throw std::runtime_error{
834  "Unexpected \"disk-cache-level\" value: " + disk_cache_level +
835  ". Valid options are 'foreign_tables', "
836  "'local_tables', 'none', and 'all'."};
837 #else
838  throw std::runtime_error{
839  "Unexpected \"disk-cache-level\" value: " + disk_cache_level +
840  ". Valid options are 'foreign_tables' and "
841  "'none'."};
842 #endif // ENABLE_GENERAL_DISK_CACHE
843  }
844 
845  if (disk_cache_config.path.empty()) {
846  disk_cache_config.path = base_path + "/omnisci_disk_cache";
847  }
849 
852 
853  // If passed in, blacklist all security config files
862 }
863 
865  int argc,
866  char const* const* argv,
867  const bool should_init_logging) {
868  po::options_description all_desc("All options");
869  all_desc.add(help_desc).add(developer_desc);
870 
871  try {
872  po::store(po::command_line_parser(argc, argv)
873  .options(all_desc)
874  .positional(positional_options)
875  .run(),
876  vm);
877  po::notify(vm);
878 
879  if (vm.count("help")) {
880  std::cerr << "Usage: omnisci_server <data directory path> [-p <port number>] "
881  "[--http-port <http port number>] [--flush-log] [--version|-v]"
882  << std::endl
883  << std::endl;
884  std::cout << help_desc << std::endl;
885  return 0;
886  }
887  if (vm.count("dev-options")) {
888  std::cout << "Usage: omnisci_server <data directory path> [-p <port number>] "
889  "[--http-port <http port number>] [--flush-log] [--version|-v]"
890  << std::endl
891  << std::endl;
892  std::cout << developer_desc << std::endl;
893  return 0;
894  }
895  if (vm.count("version")) {
896  std::cout << "OmniSci Version: " << MAPD_RELEASE << std::endl;
897  return 0;
898  }
899 
900  if (vm.count("config")) {
901  std::ifstream settings_file(system_parameters.config_file);
902 
903  auto sanitized_settings = sanitize_config_file(settings_file);
904 
905  po::store(po::parse_config_file(sanitized_settings, all_desc, false), vm);
906  po::notify(vm);
907  settings_file.close();
908  }
909 
910  if (should_init_logging) {
911  init_logging();
912  }
913 
915  return 1;
916  }
917  if (!trim_and_check_file_exists(authMetadata.ca_file_name, "ca file name")) {
918  return 1;
919  }
921  "ssl trust store")) {
922  return 1;
923  }
925  return 1;
926  }
928  return 1;
929  }
931  return 1;
932  }
933 
941  } catch (po::error& e) {
942  std::cerr << "Usage Error: " << e.what() << std::endl;
943  return 1;
944  }
945 
946  if (g_hll_precision_bits < 1 || g_hll_precision_bits > 16) {
947  std::cerr << "hll-precision-bits must be between 1 and 16." << std::endl;
948  return 1;
949  }
950 
952  LOG(INFO) << " From clause table reordering is disabled";
953  }
954 
956  LOG(INFO) << " Filter push down for JOIN is enabled";
957  }
958 
959  if (vm.count("udf")) {
960  boost::algorithm::trim_if(udf_file_name, boost::is_any_of("\"'"));
961 
962  if (!boost::filesystem::exists(udf_file_name)) {
963  LOG(ERROR) << " User defined function file " << udf_file_name << " does not exist.";
964  return 1;
965  }
966 
967  LOG(INFO) << " User provided extension functions loaded from " << udf_file_name;
968  }
969 
970  if (vm.count("udf-compiler-path")) {
971  boost::algorithm::trim_if(udf_compiler_path, boost::is_any_of("\"'"));
972  }
973 
974  auto trim_string = [](std::string& s) {
975  boost::algorithm::trim_if(s, boost::is_any_of("\"'"));
976  };
977 
978  if (vm.count("udf-compiler-options")) {
979  std::for_each(udf_compiler_options.begin(), udf_compiler_options.end(), trim_string);
980  }
981 
982  if (enable_runtime_udf) {
983  LOG(INFO) << " Runtime user defined extension functions enabled globally.";
984  }
985 
986  boost::algorithm::trim_if(system_parameters.ha_brokers, boost::is_any_of("\"'"));
987  boost::algorithm::trim_if(system_parameters.ha_group_id, boost::is_any_of("\"'"));
988  boost::algorithm::trim_if(system_parameters.ha_shared_data, boost::is_any_of("\"'"));
989  boost::algorithm::trim_if(system_parameters.ha_unique_server_id,
990  boost::is_any_of("\"'"));
991 
992  if (!system_parameters.ha_group_id.empty()) {
993  LOG(INFO) << " HA group id " << system_parameters.ha_group_id;
995  LOG(ERROR) << "Starting server in HA mode --ha-unique-server-id must be set ";
996  return 5;
997  } else {
998  LOG(INFO) << " HA unique server id " << system_parameters.ha_unique_server_id;
999  }
1000  if (system_parameters.ha_brokers.empty()) {
1001  LOG(ERROR) << "Starting server in HA mode --ha-brokers must be set ";
1002  return 6;
1003  } else {
1004  LOG(INFO) << " HA brokers " << system_parameters.ha_brokers;
1005  }
1006  if (system_parameters.ha_shared_data.empty()) {
1007  LOG(ERROR) << "Starting server in HA mode --ha-shared-data must be set ";
1008  return 7;
1009  } else {
1010  LOG(INFO) << " HA shared data is " << system_parameters.ha_shared_data;
1011  }
1012  }
1013 
1014  if (g_max_import_threads < 1) {
1015  std::cerr << "max-import-threads must be >= 1 (was set to " << g_max_import_threads
1016  << ")." << std::endl;
1017  return 8;
1018  } else {
1019  LOG(INFO) << " Max import threads " << g_max_import_threads;
1020  }
1021 
1022  LOG(INFO) << " cuda block size " << system_parameters.cuda_block_size;
1023  LOG(INFO) << " cuda grid size " << system_parameters.cuda_grid_size;
1024  LOG(INFO) << " Min CPU buffer pool slab size " << system_parameters.min_cpu_slab_size;
1025  LOG(INFO) << " Max CPU buffer pool slab size " << system_parameters.max_cpu_slab_size;
1026  LOG(INFO) << " Min GPU buffer pool slab size " << system_parameters.min_gpu_slab_size;
1027  LOG(INFO) << " Max GPU buffer pool slab size " << system_parameters.max_gpu_slab_size;
1028  LOG(INFO) << " calcite JVM max memory " << system_parameters.calcite_max_mem;
1029  LOG(INFO) << " OmniSci Server Port " << system_parameters.omnisci_server_port;
1030  LOG(INFO) << " OmniSci Calcite Port " << system_parameters.calcite_port;
1031  LOG(INFO) << " Enable Calcite view optimize "
1033 
1034  LOG(INFO) << " Allow Local Auth Fallback: "
1035  << (authMetadata.allowLocalAuthFallback ? "enabled" : "disabled");
1036 
1037  boost::algorithm::trim_if(authMetadata.distinguishedName, boost::is_any_of("\"'"));
1038  boost::algorithm::trim_if(authMetadata.uri, boost::is_any_of("\"'"));
1039  boost::algorithm::trim_if(authMetadata.ldapQueryUrl, boost::is_any_of("\"'"));
1040  boost::algorithm::trim_if(authMetadata.ldapRoleRegex, boost::is_any_of("\"'"));
1041  boost::algorithm::trim_if(authMetadata.ldapSuperUserRole, boost::is_any_of("\"'"));
1042 
1043  return boost::none;
1044 }
std::string distinguishedName
Definition: AuthMetadata.h:25
DiskCacheLevel enabled_level
int64_t g_large_ndv_threshold
bool g_use_table_device_offset
unsigned connect_timeout
std::string filename(char const *path)
Definition: Logger.cpp:62
double g_running_query_interrupt_freq
Definition: Execute.cpp:114
bool g_enable_smem_group_by
int open(const char *path, int flags, int mode)
Definition: omnisci_fs.cpp:64
float g_filter_push_down_low_frac
Definition: Execute.cpp:90
std::string ldapQueryUrl
Definition: AuthMetadata.h:26
bool g_enable_watchdog
bool trim_and_check_file_exists(std::string &filename, const std::string desc)
logger::LogOptions log_options_
bool g_strip_join_covered_quals
Definition: Execute.cpp:98
bool g_enable_direct_columnarization
Definition: Execute.cpp:109
std::string ha_shared_data
std::string udf_compiler_path
bool g_skip_intermediate_count
unsigned g_pending_query_interrupt_freq
Definition: Execute.cpp:113
po::options_description help_desc
#define LOG(tag)
Definition: Logger.h:188
bool enable_calcite_view_optimize
bool g_enable_union
DiskCacheConfig disk_cache_config
bool g_enable_debug_timer
Definition: Logger.cpp:17
std::string ldapRoleRegex
Definition: AuthMetadata.h:27
static void initializeFromConfigFile(const std::string &server_config_path)
Definition: DdlUtils.cpp:663
const std::string OMNISCI_SYSTEM_CATALOG
Definition: SysCatalog.h:57
size_t g_filter_push_down_passing_row_ubound
Definition: Execute.cpp:92
boost::optional< int > parse_command_line(int argc, char const *const *argv, const bool should_init_logging=false)
unsigned send_timeout
void addOptionalFileToBlacklist(std::string &filename)
bool g_enable_dynamic_watchdog
Definition: Execute.cpp:77
unsigned g_trivial_loop_join_threshold
Definition: Execute.cpp:83
int g_hll_precision_bits
std::string config_file
std::string to_string(char const *&&v)
bool g_enable_overlaps_hashjoin
Definition: Execute.cpp:94
bool g_inner_join_fragment_skipping
Definition: Execute.cpp:85
boost::program_options::options_description const & get_options() const
Definition: Logger.cpp:79
bool g_enable_smem_non_grouped_agg
Definition: Execute.cpp:123
bool g_null_div_by_zero
Definition: Execute.cpp:82
bool g_enable_interop
std::string ha_brokers
std::string ssl_trust_ca_file
bool g_enable_columnar_output
Definition: Execute.cpp:93
void close(const int fd)
Definition: omnisci_fs.cpp:68
std::string ssl_trust_store
int64_t g_bitmap_memory_limit
bool g_enable_s3_fsi
bool g_from_table_reordering
Definition: Execute.cpp:84
singleton class to handle concurrancy and state for blosc library. A C++ wrapper over a pure C librar...
bool g_enable_hashjoin_many_to_many
Definition: Execute.cpp:95
void init(LogOptions const &log_opts)
Definition: Logger.cpp:280
float g_filter_push_down_high_frac
Definition: Execute.cpp:91
bool g_enable_thrift_logs
Definition: initdb.cpp:42
std::string uri
Definition: AuthMetadata.h:24
bool g_bigint_count
size_t g_max_memory_allocation_size
Definition: Execute.cpp:103
double g_overlaps_target_entries_per_bin
Definition: Execute.cpp:97
size_t g_approx_quantile_buffer
Definition: Execute.cpp:129
std::string ha_unique_server_id
size_t g_overlaps_max_table_size_bytes
Definition: Execute.cpp:96
std::string ca_file_name
Definition: AuthMetadata.h:31
std::string ssl_key_file
AuthMetadata authMetadata
bool g_enable_calcite_ddl_parser
Definition: ParserNode.cpp:72
bool g_enable_window_functions
Definition: Execute.cpp:101
size_t g_min_memory_allocation_size
Definition: Execute.cpp:104
bool with_keepalive
std::string ldapSuperUserRole
Definition: AuthMetadata.h:28
bool g_enable_seconds_refresh
unsigned pending_query_interrupt_freq
unsigned recv_timeout
std::stringstream sanitize_config_file(std::ifstream &in)
bool g_enable_smem_grouped_non_count_agg
Definition: Execute.cpp:120
bool g_enable_experimental_string_functions
std::vector< std::string > udf_compiler_options
static const std::string nodeIds_token
bool g_enable_filter_function
Definition: Execute.cpp:79
bool g_cache_string_hash
float g_fraction_code_cache_to_evict
Severity severity_
Definition: Logger.h:118
std::string ssl_keystore_password
std::string ssl_trust_password
bool g_enable_filter_push_down
Definition: Execute.cpp:89
bool g_use_estimator_result_cache
Definition: Execute.cpp:112
bool g_enable_bump_allocator
Definition: Execute.cpp:107
bool allowLocalAuthFallback
Definition: AuthMetadata.h:32
size_t write(FILE *f, const size_t offset, const size_t size, int8_t *buf)
Writes the specified number of bytes to the offset position in file f from buf.
Definition: File.cpp:126
po::positional_options_description positional_options
void set_base_path(std::string const &base_path)
Definition: Logger.cpp:93
std::string ssl_keystore
bool g_allow_cpu_retry
Definition: Execute.cpp:81
size_t g_approx_quantile_centroids
Definition: Execute.cpp:130
static void addToBlacklist(const std::string &path)
Definition: DdlUtils.cpp:726
po::options_description developer_desc
bool g_enable_stringdict_parallel
static const std::string MAPD_RELEASE
Definition: release.h:43
std::string disk_cache_level
static bool run
po::variables_map vm
size_t g_max_import_threads
Definition: Importer.cpp:76
unsigned g_dynamic_watchdog_time_limit
Definition: Execute.cpp:80
bool g_enable_fsi
Definition: Catalog.cpp:91
bool g_use_tbb_pool
Definition: Execute.cpp:78
std::string ha_group_id
bool g_enable_runtime_query_interrupt
Definition: Execute.cpp:111
size_t g_large_ndv_multiplier
bool g_enable_table_functions
Definition: Execute.cpp:102
std::string cluster_command_line_arg
unsigned dynamic_watchdog_time_limit
SystemParameters system_parameters
size_t g_gpu_smem_threshold
Definition: Execute.cpp:115
std::string ssl_cert_file