OmniSciDB  ba1bac9284
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
CommandLineOptions Class Reference

#include <CommandLineOptions.h>

+ Collaboration diagram for CommandLineOptions:

Public Member Functions

 CommandLineOptions (char const *argv0, bool dist_v5_=false)
 
void fillOptions ()
 
void fillAdvancedOptions ()
 
std::string getNodeIds ()
 
std::vector< std::string > getNodeIdsArray ()
 
boost::optional< int > parse_command_line (int argc, char const *const *argv, const bool should_init_logging=false)
 
void validate ()
 
void validate_base_path ()
 
void init_logging ()
 

Public Attributes

int http_port = 6278
 
size_t reserved_gpu_mem = 384 * 1024 * 1024
 
std::string base_path
 
File_Namespace::DiskCacheConfig disk_cache_config
 
std::string cluster_file = {"cluster.conf"}
 
std::string cluster_topology_file = {"cluster_topology.conf"}
 
std::string license_path = {""}
 
std::string encryption_key_store_path = {}
 
bool verbose_logging = false
 
bool jit_debug = false
 
bool intel_jit_profile = false
 
bool allow_multifrag = true
 
bool read_only = false
 
bool allow_loop_joins = false
 
bool enable_legacy_syntax = true
 
bool log_user_origin = true
 
AuthMetadata authMetadata
 
SystemParameters system_parameters
 
bool enable_rendering = false
 
bool enable_auto_clear_render_mem = false
 
int render_oom_retry_threshold = 0
 
size_t render_mem_bytes = 1000000000
 
size_t max_concurrent_render_sessions = 500
 
bool render_compositor_use_last_gpu = true
 
bool renderer_use_vulkan_driver = false
 
bool enable_runtime_udf = false
 
bool enable_watchdog = true
 
bool enable_dynamic_watchdog = false
 
bool enable_runtime_query_interrupt = false
 
bool enable_non_kernel_time_query_interrupt = true
 
bool use_estimator_result_cache = true
 
double running_query_interrupt_freq = 0.5
 
unsigned pending_query_interrupt_freq = 1000
 
unsigned dynamic_watchdog_time_limit = 10000
 
std::string disk_cache_level = ""
 
size_t num_reader_threads = 0
 
std::string db_query_file = {""}
 
bool exit_after_warmup = false
 
int idle_session_duration = kMinsPerHour
 
int max_session_duration = kMinsPerMonth
 
std::string udf_file_name = {""}
 
std::string udf_compiler_path = {""}
 
std::vector< std::string > udf_compiler_options
 
std::string allowed_import_paths {}
 
std::string allowed_export_paths {}
 
std::string compressor = std::string(BLOSC_LZ4HC_COMPNAME)
 
po::options_description help_desc
 
po::options_description developer_desc
 
logger::LogOptions log_options_
 
po::positional_options_description positional_options
 
std::vector< LeafHostInfodb_leaves
 
std::vector< LeafHostInfostring_leaves
 
po::variables_map vm
 
std::string clusterIds_arg
 
const bool dist_v5_
 

Static Public Attributes

static const std::string nodeIds_token = {"node_id"}
 

Detailed Description

Definition at line 39 of file CommandLineOptions.h.

Constructor & Destructor Documentation

CommandLineOptions::CommandLineOptions ( char const argv0,
bool  dist_v5_ = false 
)
inline

Definition at line 41 of file CommandLineOptions.h.

References fillAdvancedOptions(), and fillOptions().

42  : log_options_(argv0), dist_v5_(dist_v5_) {
43  fillOptions();
45  }
logger::LogOptions log_options_

+ Here is the call graph for this function:

Member Function Documentation

void CommandLineOptions::fillAdvancedOptions ( )

Definition at line 431 of file CommandLineOptions.cpp.

References allow_multifrag, authMetadata, AuthMetadata::ca_file_name, developer_desc, SystemParameters::enable_calcite_view_optimize, enable_legacy_syntax, g_approx_quantile_buffer, g_approx_quantile_centroids, g_bitmap_memory_limit, g_enable_auto_metadata_update, g_enable_automatic_ir_metadata, g_enable_bump_allocator, g_enable_calcite_ddl_parser, g_enable_columnar_output, g_enable_direct_columnarization, g_enable_filter_function, g_enable_lazy_fetch, g_enable_left_join_filter_hoisting, g_enable_seconds_refresh, g_enable_smem_group_by, g_enable_smem_grouped_non_count_agg, g_enable_smem_non_grouped_agg, g_enable_table_functions, g_enable_window_functions, g_fraction_code_cache_to_evict, g_gpu_smem_threshold, g_large_ndv_multiplier, g_large_ndv_threshold, g_max_memory_allocation_size, g_min_memory_allocation_size, g_optimize_row_initialization, g_parallel_top_max, g_parallel_top_min, g_skip_intermediate_count, g_strip_join_covered_quals, g_use_table_device_offset, g_use_tbb_pool, g_vacuum_min_selectivity, intel_jit_profile, jit_debug, SystemParameters::max_cpu_slab_size, SystemParameters::max_gpu_slab_size, SystemParameters::min_cpu_slab_size, SystemParameters::min_gpu_slab_size, SystemParameters::num_executors, SystemParameters::ssl_cert_file, SystemParameters::ssl_key_file, SystemParameters::ssl_keystore, SystemParameters::ssl_keystore_password, SystemParameters::ssl_trust_ca_file, SystemParameters::ssl_trust_password, SystemParameters::ssl_trust_store, system_parameters, udf_compiler_options, udf_compiler_path, and udf_file_name.

Referenced by CommandLineOptions().

431  {
432  developer_desc.add_options()("dev-options", "Print internal developer options.");
433  developer_desc.add_options()(
434  "enable-calcite-view-optimize",
437  ->implicit_value(true),
438  "Enable additional calcite (query plan) optimizations when a view is part of the "
439  "query.");
440  developer_desc.add_options()(
441  "enable-columnar-output",
442  po::value<bool>(&g_enable_columnar_output)
443  ->default_value(g_enable_columnar_output)
444  ->implicit_value(true),
445  "Enable columnar output for intermediate/final query steps.");
446  developer_desc.add_options()(
447  "enable-left-join-filter-hoisting",
448  po::value<bool>(&g_enable_left_join_filter_hoisting)
449  ->default_value(g_enable_left_join_filter_hoisting)
450  ->implicit_value(true),
451  "Enable hoisting left hand side filters through left joins.");
452  developer_desc.add_options()("optimize-row-init",
453  po::value<bool>(&g_optimize_row_initialization)
454  ->default_value(g_optimize_row_initialization)
455  ->implicit_value(true),
456  "Optimize row initialization.");
457  developer_desc.add_options()("enable-legacy-syntax",
458  po::value<bool>(&enable_legacy_syntax)
459  ->default_value(enable_legacy_syntax)
460  ->implicit_value(true),
461  "Enable legacy syntax.");
462  developer_desc.add_options()(
463  "enable-multifrag",
464  po::value<bool>(&allow_multifrag)
465  ->default_value(allow_multifrag)
466  ->implicit_value(true),
467  "Enable execution over multiple fragments in a single round-trip to GPU.");
468  developer_desc.add_options()("enable-lazy-fetch",
469  po::value<bool>(&g_enable_lazy_fetch)
470  ->default_value(g_enable_lazy_fetch)
471  ->implicit_value(true),
472  "Enable lazy fetch columns in query results.");
473  developer_desc.add_options()(
474  "enable-shared-mem-group-by",
475  po::value<bool>(&g_enable_smem_group_by)
476  ->default_value(g_enable_smem_group_by)
477  ->implicit_value(true),
478  "Enable using GPU shared memory for some GROUP BY queries.");
479  developer_desc.add_options()("num-executors",
480  po::value<int>(&system_parameters.num_executors)
481  ->default_value(system_parameters.num_executors),
482  "Number of executors to run in parallel.");
483  developer_desc.add_options()(
484  "gpu-shared-mem-threshold",
485  po::value<size_t>(&g_gpu_smem_threshold)->default_value(g_gpu_smem_threshold),
486  "GPU shared memory threshold (in bytes). If query requires larger buffers than "
487  "this threshold, we disable those optimizations. 0 (default) means no static cap.");
488  developer_desc.add_options()(
489  "enable-shared-mem-grouped-non-count-agg",
490  po::value<bool>(&g_enable_smem_grouped_non_count_agg)
491  ->default_value(g_enable_smem_grouped_non_count_agg)
492  ->implicit_value(true),
493  "Enable using GPU shared memory for grouped non-count aggregate queries.");
494  developer_desc.add_options()(
495  "enable-shared-mem-non-grouped-agg",
496  po::value<bool>(&g_enable_smem_non_grouped_agg)
497  ->default_value(g_enable_smem_non_grouped_agg)
498  ->implicit_value(true),
499  "Enable using GPU shared memory for non-grouped aggregate queries.");
500  developer_desc.add_options()("enable-direct-columnarization",
501  po::value<bool>(&g_enable_direct_columnarization)
502  ->default_value(g_enable_direct_columnarization)
503  ->implicit_value(true),
504  "Enables/disables a more optimized columnarization method "
505  "for intermediate steps in multi-step queries.");
506  developer_desc.add_options()(
507  "offset-device-by-table-id",
508  po::value<bool>(&g_use_table_device_offset)
509  ->default_value(g_use_table_device_offset)
510  ->implicit_value(true),
511  "Enables/disables offseting the chosen device ID by the table ID for a given "
512  "fragment. This improves balance of fragments across GPUs.");
513  developer_desc.add_options()("enable-window-functions",
514  po::value<bool>(&g_enable_window_functions)
515  ->default_value(g_enable_window_functions)
516  ->implicit_value(true),
517  "Enable experimental window function support.");
518  developer_desc.add_options()("enable-table-functions",
519  po::value<bool>(&g_enable_table_functions)
520  ->default_value(g_enable_table_functions)
521  ->implicit_value(true),
522  "Enable experimental table functions support.");
523  developer_desc.add_options()(
524  "jit-debug-ir",
525  po::value<bool>(&jit_debug)->default_value(jit_debug)->implicit_value(true),
526  "Enable runtime debugger support for the JIT. Note that this flag is "
527  "incompatible "
528  "with the `ENABLE_JIT_DEBUG` build flag. The generated code can be found at "
529  "`/tmp/mapdquery`.");
530  developer_desc.add_options()(
531  "intel-jit-profile",
532  po::value<bool>(&intel_jit_profile)
533  ->default_value(intel_jit_profile)
534  ->implicit_value(true),
535  "Enable runtime support for the JIT code profiling using Intel VTune.");
536  developer_desc.add_options()(
537  "enable-modern-thread-pool",
538  po::value<bool>(&g_use_tbb_pool)
539  ->default_value(g_use_tbb_pool)
540  ->implicit_value(true),
541  "Enable a new thread pool implementation for queuing kernels for execution.");
542  developer_desc.add_options()(
543  "skip-intermediate-count",
544  po::value<bool>(&g_skip_intermediate_count)
545  ->default_value(g_skip_intermediate_count)
546  ->implicit_value(true),
547  "Skip pre-flight counts for intermediate projections with no filters.");
548  developer_desc.add_options()(
549  "strip-join-covered-quals",
550  po::value<bool>(&g_strip_join_covered_quals)
551  ->default_value(g_strip_join_covered_quals)
552  ->implicit_value(true),
553  "Remove quals from the filtered count if they are covered by a "
554  "join condition (currently only ST_Contains).");
555 
556  developer_desc.add_options()(
557  "min-cpu-slab-size",
558  po::value<size_t>(&system_parameters.min_cpu_slab_size)
559  ->default_value(system_parameters.min_cpu_slab_size),
560  "Min slab size (size of memory allocations) for CPU buffer pool.");
561  developer_desc.add_options()(
562  "max-cpu-slab-size",
563  po::value<size_t>(&system_parameters.max_cpu_slab_size)
564  ->default_value(system_parameters.max_cpu_slab_size),
565  "Max CPU buffer pool slab size (size of memory allocations). Note if "
566  "there is not enough free memory to accomodate the target slab size, smaller "
567  "slabs will be allocated, down to the minimum size specified by "
568  "min-cpu-slab-size.");
569  developer_desc.add_options()(
570  "min-gpu-slab-size",
571  po::value<size_t>(&system_parameters.min_gpu_slab_size)
572  ->default_value(system_parameters.min_gpu_slab_size),
573  "Min slab size (size of memory allocations) for GPU buffer pools.");
574  developer_desc.add_options()(
575  "max-gpu-slab-size",
576  po::value<size_t>(&system_parameters.max_gpu_slab_size)
577  ->default_value(system_parameters.max_gpu_slab_size),
578  "Max GPU buffer pool slab size (size of memory allocations). Note if "
579  "there is not enough free memory to accomodate the target slab size, smaller "
580  "slabs will be allocated, down to the minimum size speified by "
581  "min-gpu-slab-size.");
582 
583  developer_desc.add_options()(
584  "max-output-projection-allocation-bytes",
585  po::value<size_t>(&g_max_memory_allocation_size)
586  ->default_value(g_max_memory_allocation_size),
587  "Maximum allocation size for a fixed output buffer allocation for projection "
588  "queries with no pre-flight count. Default is the maximum slab size (sizes "
589  "greater "
590  "than the maximum slab size have no affect). Requires bump allocator.");
591  developer_desc.add_options()(
592  "min-output-projection-allocation-bytes",
593  po::value<size_t>(&g_min_memory_allocation_size)
594  ->default_value(g_min_memory_allocation_size),
595  "Minimum allocation size for a fixed output buffer allocation for projection "
596  "queries with no pre-flight count. If an allocation of this size cannot be "
597  "obtained, the query will be retried with different execution parameters and/or "
598  "on "
599  "CPU (if allow-cpu-retry is enabled). Requires bump allocator.");
600  developer_desc.add_options()("enable-bump-allocator",
601  po::value<bool>(&g_enable_bump_allocator)
602  ->default_value(g_enable_bump_allocator)
603  ->implicit_value(true),
604  "Enable the bump allocator for projection queries on "
605  "GPU. The bump allocator will "
606  "allocate a fixed size buffer for each query, track the "
607  "number of rows passing the "
608  "kernel during query execution, and copy back only the "
609  "rows that passed the kernel "
610  "to CPU after execution. When disabled, pre-flight "
611  "count queries are used to size "
612  "the output buffer for projection queries.");
613  developer_desc.add_options()(
614  "code-cache-eviction-percent",
615  po::value<float>(&g_fraction_code_cache_to_evict)
616  ->default_value(g_fraction_code_cache_to_evict),
617  "Percentage of the GPU code cache to evict if an out of memory error is "
618  "encountered while attempting to place generated code on the GPU.");
619 
620  developer_desc.add_options()("ssl-cert",
621  po::value<std::string>(&system_parameters.ssl_cert_file)
622  ->default_value(std::string("")),
623  "SSL Validated public certficate.");
624 
625  developer_desc.add_options()("ssl-private-key",
626  po::value<std::string>(&system_parameters.ssl_key_file)
627  ->default_value(std::string("")),
628  "SSL private key file.");
629  // Note ssl_trust_store is passed through to Calcite via system_parameters
630  // todo(jack): add ensure ssl-trust-store exists if cert and private key in use
631  developer_desc.add_options()("ssl-trust-store",
632  po::value<std::string>(&system_parameters.ssl_trust_store)
633  ->default_value(std::string("")),
634  "SSL public CA certifcates (java trust store) to validate "
635  "TLS connections (passed through to the Calcite server).");
636 
637  developer_desc.add_options()(
638  "ssl-trust-password",
639  po::value<std::string>(&system_parameters.ssl_trust_password)
640  ->default_value(std::string("")),
641  "SSL password for java trust store provided via --ssl-trust-store parameter.");
642 
643  developer_desc.add_options()(
644  "ssl-trust-ca",
645  po::value<std::string>(&system_parameters.ssl_trust_ca_file)
646  ->default_value(std::string("")),
647  "SSL public CA certificates to validate TLS connection(as a client).");
648 
649  developer_desc.add_options()(
650  "ssl-trust-ca-server",
651  po::value<std::string>(&authMetadata.ca_file_name)->default_value(std::string("")),
652  "SSL public CA certificates to validate TLS connection(as a server).");
653 
654  developer_desc.add_options()("ssl-keystore",
655  po::value<std::string>(&system_parameters.ssl_keystore)
656  ->default_value(std::string("")),
657  "SSL server credentials as a java key store (passed "
658  "through to the Calcite server).");
659 
660  developer_desc.add_options()(
661  "ssl-keystore-password",
662  po::value<std::string>(&system_parameters.ssl_keystore_password)
663  ->default_value(std::string("")),
664  "SSL password for java keystore, provide by via --ssl-keystore.");
665 
666  developer_desc.add_options()(
667  "udf",
668  po::value<std::string>(&udf_file_name),
669  "Load user defined extension functions from this file at startup. The file is "
670  "expected to be a C/C++ file with extension .cpp.");
671 
672  developer_desc.add_options()(
673  "udf-compiler-path",
674  po::value<std::string>(&udf_compiler_path),
675  "Provide absolute path to clang++ used in udf compilation.");
676 
677  developer_desc.add_options()("udf-compiler-options",
678  po::value<std::vector<std::string>>(&udf_compiler_options),
679  "Specify compiler options to tailor udf compilation.");
680 
681 #ifdef ENABLE_GEOS
682  developer_desc.add_options()("libgeos-so-filename",
683  po::value<std::string>(&libgeos_so_filename),
684  "Specify libgeos shared object filename to be used for "
685  "geos-backed geo opertations.");
686 #endif
687  developer_desc.add_options()(
688  "large-ndv-threshold",
689  po::value<int64_t>(&g_large_ndv_threshold)->default_value(g_large_ndv_threshold));
690  developer_desc.add_options()(
691  "large-ndv-multiplier",
692  po::value<size_t>(&g_large_ndv_multiplier)->default_value(g_large_ndv_multiplier));
693  developer_desc.add_options()("approx_quantile_buffer",
694  po::value<size_t>(&g_approx_quantile_buffer)
695  ->default_value(g_approx_quantile_buffer));
696  developer_desc.add_options()("approx_quantile_centroids",
697  po::value<size_t>(&g_approx_quantile_centroids)
698  ->default_value(g_approx_quantile_centroids));
699  developer_desc.add_options()(
700  "bitmap-memory-limit",
701  po::value<int64_t>(&g_bitmap_memory_limit)->default_value(g_bitmap_memory_limit),
702  "Limit for count distinct bitmap memory use. The limit is computed by taking the "
703  "size of the group by buffer (entry count in Query Memory Descriptor) and "
704  "multiplying it by the number of count distinct expression and the size of bitmap "
705  "required for each. For approx_count_distinct this is typically 8192 bytes.");
706  developer_desc.add_options()(
707  "enable-filter-function",
708  po::value<bool>(&g_enable_filter_function)
709  ->default_value(g_enable_filter_function)
710  ->implicit_value(true),
711  "Enable the filter function protection feature for the SQL JIT compiler. "
712  "Normally should be on but techs might want to disable for troubleshooting.");
713  developer_desc.add_options()(
714  "enable-calcite-ddl",
715  po::value<bool>(&g_enable_calcite_ddl_parser)
716  ->default_value(g_enable_calcite_ddl_parser)
717  ->implicit_value(true),
718  "Enable using Calcite for supported DDL parsing when available.");
719  developer_desc.add_options()(
720  "enable-seconds-refresh-interval",
721  po::value<bool>(&g_enable_seconds_refresh)
722  ->default_value(g_enable_seconds_refresh)
723  ->implicit_value(true),
724  "Enable foreign table seconds refresh interval for testing purposes.");
725  developer_desc.add_options()("enable-auto-metadata-update",
726  po::value<bool>(&g_enable_auto_metadata_update)
727  ->default_value(g_enable_auto_metadata_update)
728  ->implicit_value(true),
729  "Enable automatic metadata update.");
730  developer_desc.add_options()(
731  "parallel-top-min",
732  po::value<size_t>(&g_parallel_top_min)->default_value(g_parallel_top_min),
733  "For ResultSets requiring a heap sort, the number of rows necessary to trigger "
734  "parallelTop() to sort.");
735  developer_desc.add_options()(
736  "parallel-top-max",
737  po::value<size_t>(&g_parallel_top_max)->default_value(g_parallel_top_max),
738  "For ResultSets requiring a heap sort, the maximum number of rows allowed by "
739  "watchdog.");
740  developer_desc.add_options()("vacuum-min-selectivity",
741  po::value<float>(&g_vacuum_min_selectivity)
742  ->default_value(g_vacuum_min_selectivity),
743  "Minimum selectivity for automatic vacuuming. "
744  "This specifies the percentage (with a value of 0 "
745  "implying 0% and a value of 1 implying 100%) of "
746  "deleted rows in a fragment at which to perform "
747  "automatic vacuuming. A number greater than 1 can "
748  "be used to disable automatic vacuuming.");
749  developer_desc.add_options()("enable-automatic-ir-metadata",
750  po::value<bool>(&g_enable_automatic_ir_metadata)
751  ->default_value(g_enable_automatic_ir_metadata)
752  ->implicit_value(true),
753  "Enable automatic IR metadata (debug builds only).");
754 }
int64_t g_large_ndv_threshold
bool g_use_table_device_offset
bool g_enable_left_join_filter_hoisting
Definition: Execute.cpp:94
bool g_enable_smem_group_by
size_t g_parallel_top_max
Definition: ResultSet.cpp:48
bool g_strip_join_covered_quals
Definition: Execute.cpp:100
bool g_enable_direct_columnarization
Definition: Execute.cpp:112
bool g_enable_lazy_fetch
Definition: Execute.cpp:114
std::string udf_compiler_path
bool g_skip_intermediate_count
bool enable_calcite_view_optimize
bool g_enable_auto_metadata_update
bool g_enable_smem_non_grouped_agg
Definition: Execute.cpp:128
size_t g_parallel_top_min
Definition: ResultSet.cpp:47
std::string ssl_trust_ca_file
bool g_enable_columnar_output
Definition: Execute.cpp:93
std::string ssl_trust_store
int64_t g_bitmap_memory_limit
size_t g_max_memory_allocation_size
Definition: Execute.cpp:106
size_t g_approx_quantile_buffer
Definition: Execute.cpp:136
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:74
bool g_enable_window_functions
Definition: Execute.cpp:104
size_t g_min_memory_allocation_size
Definition: Execute.cpp:107
bool g_enable_seconds_refresh
bool g_enable_smem_grouped_non_count_agg
Definition: Execute.cpp:125
bool g_enable_automatic_ir_metadata
Definition: Execute.cpp:139
std::vector< std::string > udf_compiler_options
float g_vacuum_min_selectivity
bool g_enable_filter_function
Definition: Execute.cpp:79
float g_fraction_code_cache_to_evict
std::string ssl_keystore_password
std::string ssl_trust_password
bool g_enable_bump_allocator
Definition: Execute.cpp:110
std::string ssl_keystore
size_t g_approx_quantile_centroids
Definition: Execute.cpp:137
po::options_description developer_desc
bool g_optimize_row_initialization
Definition: Execute.cpp:95
bool g_use_tbb_pool
Definition: Execute.cpp:78
size_t g_large_ndv_multiplier
bool g_enable_table_functions
Definition: Execute.cpp:105
SystemParameters system_parameters
size_t g_gpu_smem_threshold
Definition: Execute.cpp:120
std::string ssl_cert_file

+ Here is the caller graph for this function:

void CommandLineOptions::fillOptions ( )

Definition at line 70 of file CommandLineOptions.cpp.

References allow_loop_joins, allowed_export_paths, allowed_import_paths, base_path, SystemParameters::calcite_keepalive, SystemParameters::calcite_max_mem, SystemParameters::calcite_port, SystemParameters::calcite_timeout, SystemParameters::config_file, SystemParameters::cpu_buffer_mem_bytes, SystemParameters::cpu_only, SystemParameters::cuda_block_size, SystemParameters::cuda_grid_size, db_query_file, disk_cache_config, disk_cache_level, dist_v5_, dynamic_watchdog_time_limit, enable_dynamic_watchdog, enable_non_kernel_time_query_interrupt, enable_runtime_query_interrupt, enable_runtime_udf, enable_watchdog, exit_after_warmup, g_allow_cpu_retry, g_allow_s3_server_privileges, g_bigint_count, g_cache_string_hash, g_enable_debug_timer, g_enable_experimental_string_functions, g_enable_filter_push_down, g_enable_fsi, g_enable_hashjoin_many_to_many, g_enable_interop, g_enable_overlaps_hashjoin, g_enable_stringdict_parallel, g_enable_thrift_logs, g_enable_union, g_filter_push_down_high_frac, g_filter_push_down_low_frac, g_filter_push_down_passing_row_ubound, g_from_table_reordering, g_hll_precision_bits, g_inner_join_fragment_skipping, Catalog_Namespace::g_log_user_id, g_max_import_threads, g_null_div_by_zero, g_overlaps_max_table_size_bytes, g_overlaps_target_entries_per_bin, g_trivial_loop_join_threshold, logger::LogOptions::get_options(), SystemParameters::gpu_buffer_mem_bytes, SystemParameters::gpu_input_mem_limit, help_desc, http_port, idle_session_duration, log_options_, log_user_origin, max_session_duration, SystemParameters::num_gpus, num_reader_threads, SystemParameters::num_sessions, SystemParameters::omnisci_server_port, File_Namespace::DiskCacheConfig::path, pending_query_interrupt_freq, positional_options, read_only, run_benchmark_import::required, reserved_gpu_mem, running_query_interrupt_freq, File_Namespace::DiskCacheConfig::size_limit, SystemParameters::start_gpu, system_parameters, use_estimator_result_cache, and verbose_logging.

Referenced by CommandLineOptions().

70  {
71  help_desc.add_options()("help,h", "Show available options.");
72  help_desc.add_options()(
73  "allow-cpu-retry",
74  po::value<bool>(&g_allow_cpu_retry)
75  ->default_value(g_allow_cpu_retry)
76  ->implicit_value(true),
77  R"(Allow the queries which failed on GPU to retry on CPU, even when watchdog is enabled.)");
78  help_desc.add_options()("allow-loop-joins",
79  po::value<bool>(&allow_loop_joins)
80  ->default_value(allow_loop_joins)
81  ->implicit_value(true),
82  "Enable loop joins.");
83  help_desc.add_options()("bigint-count",
84  po::value<bool>(&g_bigint_count)
85  ->default_value(g_bigint_count)
86  ->implicit_value(true),
87  "Use 64-bit count.");
88  help_desc.add_options()("calcite-max-mem",
89  po::value<size_t>(&system_parameters.calcite_max_mem)
90  ->default_value(system_parameters.calcite_max_mem),
91  "Max memory available to calcite JVM.");
92  if (!dist_v5_) {
93  help_desc.add_options()("calcite-port",
94  po::value<int>(&system_parameters.calcite_port)
95  ->default_value(system_parameters.calcite_port),
96  "Calcite port number.");
97  }
98  help_desc.add_options()("config",
99  po::value<std::string>(&system_parameters.config_file),
100  "Path to server configuration file.");
101  help_desc.add_options()("cpu-buffer-mem-bytes",
102  po::value<size_t>(&system_parameters.cpu_buffer_mem_bytes)
103  ->default_value(system_parameters.cpu_buffer_mem_bytes),
104  "Size of memory reserved for CPU buffers, in bytes.");
105 
106  help_desc.add_options()("cpu-only",
107  po::value<bool>(&system_parameters.cpu_only)
108  ->default_value(system_parameters.cpu_only)
109  ->implicit_value(true),
110  "Run on CPU only, even if GPUs are available.");
111  help_desc.add_options()("cuda-block-size",
112  po::value<size_t>(&system_parameters.cuda_block_size)
113  ->default_value(system_parameters.cuda_block_size),
114  "Size of block to use on GPU.");
115  help_desc.add_options()("cuda-grid-size",
116  po::value<size_t>(&system_parameters.cuda_grid_size)
117  ->default_value(system_parameters.cuda_grid_size),
118  "Size of grid to use on GPU.");
119  if (!dist_v5_) {
120  help_desc.add_options()(
121  "data",
122  po::value<std::string>(&base_path)->required()->default_value("data"),
123  "Directory path to OmniSci data storage (catalogs, raw data, log files, etc).");
124  positional_options.add("data", 1);
125  }
126  help_desc.add_options()("db-query-list",
127  po::value<std::string>(&db_query_file),
128  "Path to file containing OmniSci warmup queries.");
129  help_desc.add_options()(
130  "exit-after-warmup",
131  po::value<bool>(&exit_after_warmup)->default_value(false)->implicit_value(true),
132  "Exit after OmniSci warmup queries.");
133  help_desc.add_options()("dynamic-watchdog-time-limit",
134  po::value<unsigned>(&dynamic_watchdog_time_limit)
135  ->default_value(dynamic_watchdog_time_limit)
136  ->implicit_value(10000),
137  "Dynamic watchdog time limit, in milliseconds.");
138  help_desc.add_options()("enable-debug-timer",
139  po::value<bool>(&g_enable_debug_timer)
140  ->default_value(g_enable_debug_timer)
141  ->implicit_value(true),
142  "Enable debug timer logging.");
143  help_desc.add_options()("enable-dynamic-watchdog",
144  po::value<bool>(&enable_dynamic_watchdog)
145  ->default_value(enable_dynamic_watchdog)
146  ->implicit_value(true),
147  "Enable dynamic watchdog.");
148  help_desc.add_options()("enable-filter-push-down",
149  po::value<bool>(&g_enable_filter_push_down)
150  ->default_value(g_enable_filter_push_down)
151  ->implicit_value(true),
152  "Enable filter push down through joins.");
153  help_desc.add_options()("enable-overlaps-hashjoin",
154  po::value<bool>(&g_enable_overlaps_hashjoin)
155  ->default_value(g_enable_overlaps_hashjoin)
156  ->implicit_value(true),
157  "Enable the overlaps hash join framework allowing for range "
158  "join (e.g. spatial overlaps) computation using a hash table.");
159  help_desc.add_options()("enable-hashjoin-many-to-many",
160  po::value<bool>(&g_enable_hashjoin_many_to_many)
161  ->default_value(g_enable_hashjoin_many_to_many)
162  ->implicit_value(true),
163  "Enable the overlaps hash join framework allowing for range "
164  "join (e.g. spatial overlaps) computation using a hash table.");
165  help_desc.add_options()("enable-runtime-query-interrupt",
166  po::value<bool>(&enable_runtime_query_interrupt)
167  ->default_value(enable_runtime_query_interrupt)
168  ->implicit_value(true),
169  "Enable runtime query interrupt.");
170  help_desc.add_options()("enable-non-kernel-time-query-interrupt",
173  ->implicit_value(true),
174  "Enable non-kernel time query interrupt.");
175  help_desc.add_options()("pending-query-interrupt-freq",
176  po::value<unsigned>(&pending_query_interrupt_freq)
177  ->default_value(pending_query_interrupt_freq)
178  ->implicit_value(1000),
179  "A frequency of checking the request of pending query "
180  "interrupt from user (in millisecond).");
181  help_desc.add_options()(
182  "running-query-interrupt-freq",
183  po::value<double>(&running_query_interrupt_freq)
184  ->default_value(running_query_interrupt_freq)
185  ->implicit_value(0.5),
186  "A frequency of checking the request of running query "
187  "interrupt from user (0.0 (less frequent) ~ (more frequent) 1.0).");
188  help_desc.add_options()("use-estimator-result-cache",
189  po::value<bool>(&use_estimator_result_cache)
190  ->default_value(use_estimator_result_cache)
191  ->implicit_value(true),
192  "Use estimator result cache.");
193  if (!dist_v5_) {
194  help_desc.add_options()(
195  "enable-string-dict-hash-cache",
196  po::value<bool>(&g_cache_string_hash)
197  ->default_value(g_cache_string_hash)
198  ->implicit_value(true),
199  "Cache string hash values in the string dictionary server during import.");
200  }
201  help_desc.add_options()(
202  "enable-thrift-logs",
203  po::value<bool>(&g_enable_thrift_logs)
204  ->default_value(g_enable_thrift_logs)
205  ->implicit_value(true),
206  "Enable writing messages directly from thrift to stdout/stderr.");
207  help_desc.add_options()("enable-watchdog",
208  po::value<bool>(&enable_watchdog)
209  ->default_value(enable_watchdog)
210  ->implicit_value(true),
211  "Enable watchdog.");
212  help_desc.add_options()(
213  "filter-push-down-low-frac",
214  po::value<float>(&g_filter_push_down_low_frac)
215  ->default_value(g_filter_push_down_low_frac)
216  ->implicit_value(g_filter_push_down_low_frac),
217  "Lower threshold for selectivity of filters that are pushed down.");
218  help_desc.add_options()(
219  "filter-push-down-high-frac",
220  po::value<float>(&g_filter_push_down_high_frac)
221  ->default_value(g_filter_push_down_high_frac)
222  ->implicit_value(g_filter_push_down_high_frac),
223  "Higher threshold for selectivity of filters that are pushed down.");
224  help_desc.add_options()("filter-push-down-passing-row-ubound",
225  po::value<size_t>(&g_filter_push_down_passing_row_ubound)
227  ->implicit_value(g_filter_push_down_passing_row_ubound),
228  "Upperbound on the number of rows that should pass the filter "
229  "if the selectivity is less than "
230  "the high fraction threshold.");
231  help_desc.add_options()("from-table-reordering",
232  po::value<bool>(&g_from_table_reordering)
233  ->default_value(g_from_table_reordering)
234  ->implicit_value(true),
235  "Enable automatic table reordering in FROM clause.");
236  help_desc.add_options()("gpu-buffer-mem-bytes",
237  po::value<size_t>(&system_parameters.gpu_buffer_mem_bytes)
238  ->default_value(system_parameters.gpu_buffer_mem_bytes),
239  "Size of memory reserved for GPU buffers, in bytes, per GPU.");
240  help_desc.add_options()("gpu-input-mem-limit",
241  po::value<double>(&system_parameters.gpu_input_mem_limit)
242  ->default_value(system_parameters.gpu_input_mem_limit),
243  "Force query to CPU when input data memory usage exceeds this "
244  "percentage of available GPU memory.");
245  help_desc.add_options()(
246  "hll-precision-bits",
247  po::value<int>(&g_hll_precision_bits)
248  ->default_value(g_hll_precision_bits)
249  ->implicit_value(g_hll_precision_bits),
250  "Number of bits used from the hash value used to specify the bucket number.");
251  if (!dist_v5_) {
252  help_desc.add_options()("http-port",
253  po::value<int>(&http_port)->default_value(http_port),
254  "HTTP port number.");
255  }
256  help_desc.add_options()(
257  "idle-session-duration",
258  po::value<int>(&idle_session_duration)->default_value(idle_session_duration),
259  "Maximum duration of idle session.");
260  help_desc.add_options()("inner-join-fragment-skipping",
261  po::value<bool>(&g_inner_join_fragment_skipping)
262  ->default_value(g_inner_join_fragment_skipping)
263  ->implicit_value(true),
264  "Enable/disable inner join fragment skipping. This feature is "
265  "considered stable and is enabled by default. This "
266  "parameter will be removed in a future release.");
267  help_desc.add_options()(
268  "max-session-duration",
269  po::value<int>(&max_session_duration)->default_value(max_session_duration),
270  "Maximum duration of active session.");
271  help_desc.add_options()("num-sessions",
272  po::value<int>(&system_parameters.num_sessions)
273  ->default_value(system_parameters.num_sessions),
274  "Maximum number of active session.");
275  help_desc.add_options()(
276  "null-div-by-zero",
277  po::value<bool>(&g_null_div_by_zero)
278  ->default_value(g_null_div_by_zero)
279  ->implicit_value(true),
280  "Return null on division by zero instead of throwing an exception.");
281  help_desc.add_options()(
282  "num-reader-threads",
283  po::value<size_t>(&num_reader_threads)->default_value(num_reader_threads),
284  "Number of reader threads to use.");
285  help_desc.add_options()(
286  "max-import-threads",
287  po::value<size_t>(&g_max_import_threads)->default_value(g_max_import_threads),
288  "Max number of default import threads to use (num hardware threads will be used "
289  "instead if lower). Can be overriden with copy statement threads option).");
290  help_desc.add_options()(
291  "overlaps-max-table-size-bytes",
292  po::value<size_t>(&g_overlaps_max_table_size_bytes)
293  ->default_value(g_overlaps_max_table_size_bytes),
294  "The maximum size in bytes of the hash table for an overlaps hash join.");
295  help_desc.add_options()("overlaps-target-entries-per-bin",
296  po::value<double>(&g_overlaps_target_entries_per_bin)
297  ->default_value(g_overlaps_target_entries_per_bin),
298  "The target number of hash entries per bin for overlaps join");
299  if (!dist_v5_) {
300  help_desc.add_options()("port,p",
301  po::value<int>(&system_parameters.omnisci_server_port)
302  ->default_value(system_parameters.omnisci_server_port),
303  "TCP Port number.");
304  }
305  help_desc.add_options()("num-gpus",
306  po::value<int>(&system_parameters.num_gpus)
307  ->default_value(system_parameters.num_gpus),
308  "Number of gpus to use.");
309  help_desc.add_options()(
310  "read-only",
311  po::value<bool>(&read_only)->default_value(read_only)->implicit_value(true),
312  "Enable read-only mode.");
313 
314  help_desc.add_options()(
315  "res-gpu-mem",
316  po::value<size_t>(&reserved_gpu_mem)->default_value(reserved_gpu_mem),
317  "Reduces GPU memory available to the OmniSci allocator by this amount. Used for "
318  "compiled code cache and ancillary GPU functions and other processes that may also "
319  "be using the GPU concurrent with OmniSciDB.");
320 
321  help_desc.add_options()("start-gpu",
322  po::value<int>(&system_parameters.start_gpu)
323  ->default_value(system_parameters.start_gpu),
324  "First gpu to use.");
325  help_desc.add_options()("trivial-loop-join-threshold",
326  po::value<unsigned>(&g_trivial_loop_join_threshold)
327  ->default_value(g_trivial_loop_join_threshold)
328  ->implicit_value(1000),
329  "The maximum number of rows in the inner table of a loop join "
330  "considered to be trivially small.");
331  help_desc.add_options()("verbose",
332  po::value<bool>(&verbose_logging)
333  ->default_value(verbose_logging)
334  ->implicit_value(true),
335  "Write additional debug log messages to server logs.");
336  help_desc.add_options()(
337  "enable-runtime-udf",
338  po::value<bool>(&enable_runtime_udf)
339  ->default_value(enable_runtime_udf)
340  ->implicit_value(true),
341  "Enable runtime UDF registration by passing signatures and corresponding LLVM IR "
342  "to the `register_runtime_udf` endpoint. For use with the Python Remote Backend "
343  "Compiler server, packaged separately.");
344  help_desc.add_options()("version,v", "Print Version Number.");
345  help_desc.add_options()("enable-experimental-string-functions",
348  ->implicit_value(true),
349  "Enable experimental string functions.");
350  help_desc.add_options()(
351  "enable-fsi",
352  po::value<bool>(&g_enable_fsi)->default_value(g_enable_fsi)->implicit_value(true),
353  "Enable foreign storage interface.");
354  help_desc.add_options()("disk-cache-path",
355  po::value<std::string>(&disk_cache_config.path),
356  "Specify the path for the disk cache.");
357 
358  help_desc.add_options()(
359  "disk-cache-level",
360  po::value<std::string>(&(disk_cache_level))->default_value("foreign_tables"),
361  "Specify level of disk cache. Valid options are 'foreign_tables', "
362  "'local_tables', 'none', and 'all'.");
363 
364  help_desc.add_options()("disk-cache-size",
365  po::value<std::uint64_t>(&(disk_cache_config.size_limit)),
366  "Specify a maximum size for the disk cache in bytes.");
367 
368 #ifdef HAVE_AWS_S3
369  help_desc.add_options()(
370  "allow-s3-server-privileges",
371  po::value<bool>(&g_allow_s3_server_privileges)
372  ->default_value(g_allow_s3_server_privileges)
373  ->implicit_value(true),
374  "Allow S3 server privileges, if IAM user credentials are not provided. Credentials "
375  "may be specified with "
376  "environment variables (such as AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, etc), "
377  "an AWS credentials file, or when running on an EC2 instance, with an IAM role "
378  "that is attached to the instance.");
379 #endif // defined(HAVE_AWS_S3)
380  help_desc.add_options()(
381  "enable-interoperability",
382  po::value<bool>(&g_enable_interop)
383  ->default_value(g_enable_interop)
384  ->implicit_value(true),
385  "Enable offloading of query portions to an external execution engine.");
386  help_desc.add_options()("enable-union",
387  po::value<bool>(&g_enable_union)
388  ->default_value(g_enable_union)
389  ->implicit_value(true),
390  "Enable UNION ALL SQL clause.");
391  help_desc.add_options()(
392  "calcite-service-timeout",
393  po::value<size_t>(&system_parameters.calcite_timeout)
394  ->default_value(system_parameters.calcite_timeout),
395  "Calcite server timeout (milliseconds). Increase this on systems with frequent "
396  "schema changes or when running large numbers of parallel queries.");
397  help_desc.add_options()("calcite-service-keepalive",
398  po::value<size_t>(&system_parameters.calcite_keepalive)
399  ->default_value(system_parameters.calcite_keepalive)
400  ->implicit_value(true),
401  "Enable keepalive on Calcite connections.");
402  help_desc.add_options()(
403  "stringdict-parallelizm",
404  po::value<bool>(&g_enable_stringdict_parallel)
405  ->default_value(g_enable_stringdict_parallel)
406  ->implicit_value(true),
407  "Allow StringDictionary to parallelize loads using multiple threads");
408  help_desc.add_options()(
409  "log-user-id",
410  po::value<bool>(&Catalog_Namespace::g_log_user_id)
411  ->default_value(Catalog_Namespace::g_log_user_id)
412  ->implicit_value(true),
413  "Log userId integer in place of the userName (when available).");
414  help_desc.add_options()("log-user-origin",
415  po::value<bool>(&log_user_origin)
416  ->default_value(log_user_origin)
417  ->implicit_value(true),
418  "Lookup the origin of inbound connections by IP address/DNS "
419  "name, and print this information as part of stdlog.");
420  help_desc.add_options()(
421  "allowed-import-paths",
422  po::value<std::string>(&allowed_import_paths),
423  "List of allowed root paths that can be used in import operations.");
424  help_desc.add_options()(
425  "allowed-export-paths",
426  po::value<std::string>(&allowed_export_paths),
427  "List of allowed root paths that can be used in export operations.");
429 }
float g_filter_push_down_low_frac
Definition: Execute.cpp:90
logger::LogOptions log_options_
po::options_description help_desc
bool g_enable_debug_timer
Definition: Logger.cpp:17
size_t g_filter_push_down_passing_row_ubound
Definition: Execute.cpp:92
unsigned g_trivial_loop_join_threshold
Definition: Execute.cpp:83
bool enable_non_kernel_time_query_interrupt
int g_hll_precision_bits
std::string config_file
bool g_enable_overlaps_hashjoin
Definition: Execute.cpp:96
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_null_div_by_zero
Definition: Execute.cpp:82
bool g_enable_interop
bool g_from_table_reordering
Definition: Execute.cpp:84
bool g_enable_hashjoin_many_to_many
Definition: Execute.cpp:97
float g_filter_push_down_high_frac
Definition: Execute.cpp:91
bool g_enable_thrift_logs
Definition: initdb.cpp:42
bool g_bigint_count
double g_overlaps_target_entries_per_bin
Definition: Execute.cpp:99
std::string allowed_export_paths
size_t g_overlaps_max_table_size_bytes
Definition: Execute.cpp:98
unsigned pending_query_interrupt_freq
bool g_enable_experimental_string_functions
bool g_cache_string_hash
bool g_enable_filter_push_down
Definition: Execute.cpp:89
po::positional_options_description positional_options
bool g_enable_union
bool g_allow_cpu_retry
Definition: Execute.cpp:81
File_Namespace::DiskCacheConfig disk_cache_config
std::string allowed_import_paths
bool g_enable_stringdict_parallel
std::string disk_cache_level
bool g_enable_fsi
Definition: Catalog.cpp:92
bool g_allow_s3_server_privileges
Definition: S3Archive.cpp:33
size_t g_max_import_threads
Definition: Importer.cpp:85
unsigned dynamic_watchdog_time_limit
SystemParameters system_parameters

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

std::string CommandLineOptions::getNodeIds ( )
std::vector<std::string> CommandLineOptions::getNodeIdsArray ( )
void CommandLineOptions::init_logging ( )

Definition at line 61 of file CommandLineOptions.cpp.

References base_path, logger::DEBUG1, logger::init(), log_options_, logger::LogOptions::set_base_path(), logger::LogOptions::severity_, validate_base_path(), and verbose_logging.

Referenced by EmbeddedDatabase::DBEngineImpl::init(), and parse_command_line().

61  {
64  }
68 }
logger::LogOptions log_options_
void init(LogOptions const &log_opts)
Definition: Logger.cpp:280
Severity severity_
Definition: Logger.h:124
void set_base_path(std::string const &base_path)
Definition: Logger.cpp:93

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

boost::optional< int > CommandLineOptions::parse_command_line ( int  argc,
char const *const argv,
const bool  should_init_logging = false 
)

Definition at line 953 of file CommandLineOptions.cpp.

References AuthMetadata::allowLocalAuthFallback, authMetadata, AuthMetadata::ca_file_name, SystemParameters::calcite_max_mem, SystemParameters::calcite_port, SystemParameters::config_file, SystemParameters::cuda_block_size, SystemParameters::cuda_grid_size, developer_desc, AuthMetadata::distinguishedName, dynamic_watchdog_time_limit, SystemParameters::enable_calcite_view_optimize, enable_dynamic_watchdog, enable_non_kernel_time_query_interrupt, enable_runtime_query_interrupt, enable_runtime_udf, enable_watchdog, logger::ERROR, g_dynamic_watchdog_time_limit, g_enable_dynamic_watchdog, g_enable_filter_push_down, g_enable_non_kernel_time_query_interrupt, g_enable_runtime_query_interrupt, g_enable_watchdog, g_from_table_reordering, g_max_import_threads, g_parallel_top_max, g_parallel_top_min, g_pending_query_interrupt_freq, g_running_query_interrupt_freq, g_use_estimator_result_cache, SystemParameters::ha_brokers, SystemParameters::ha_group_id, SystemParameters::ha_shared_data, SystemParameters::ha_unique_server_id, help_desc, logger::INFO, init_logging(), AuthMetadata::ldapQueryUrl, AuthMetadata::ldapRoleRegex, AuthMetadata::ldapSuperUserRole, LOG, MAPD_RELEASE, SystemParameters::master_address, SystemParameters::master_port, SystemParameters::max_cpu_slab_size, SystemParameters::max_gpu_slab_size, SystemParameters::min_cpu_slab_size, SystemParameters::min_gpu_slab_size, SystemParameters::omnisci_server_port, pending_query_interrupt_freq, positional_options, read_only, run, running_query_interrupt_freq, anonymous_namespace{CommandLineOptions.cpp}::sanitize_config_file(), SystemParameters::ssl_cert_file, SystemParameters::ssl_key_file, SystemParameters::ssl_keystore, SystemParameters::ssl_trust_ca_file, SystemParameters::ssl_trust_store, system_parameters, anonymous_namespace{CommandLineOptions.cpp}::trim_and_check_file_exists(), udf_compiler_options, udf_compiler_path, udf_file_name, AuthMetadata::uri, use_estimator_result_cache, and vm.

Referenced by EmbeddedDatabase::DBEngineImpl::init(), and main().

956  {
957  po::options_description all_desc("All options");
958  all_desc.add(help_desc).add(developer_desc);
959 
960  try {
961  po::store(po::command_line_parser(argc, argv)
962  .options(all_desc)
963  .positional(positional_options)
964  .run(),
965  vm);
966  po::notify(vm);
967 
968  if (vm.count("help")) {
969  std::cerr << "Usage: omnisci_server <data directory path> [-p <port number>] "
970  "[--http-port <http port number>] [--flush-log] [--version|-v]"
971  << std::endl
972  << std::endl;
973  std::cout << help_desc << std::endl;
974  return 0;
975  }
976  if (vm.count("dev-options")) {
977  std::cout << "Usage: omnisci_server <data directory path> [-p <port number>] "
978  "[--http-port <http port number>] [--flush-log] [--version|-v]"
979  << std::endl
980  << std::endl;
981  std::cout << developer_desc << std::endl;
982  return 0;
983  }
984  if (vm.count("version")) {
985  std::cout << "OmniSci Version: " << MAPD_RELEASE << std::endl;
986  return 0;
987  }
988 
989  if (vm.count("config")) {
990  std::ifstream settings_file(system_parameters.config_file);
991 
992  auto sanitized_settings = sanitize_config_file(settings_file);
993 
994  po::store(po::parse_config_file(sanitized_settings, all_desc, false), vm);
995  po::notify(vm);
996  settings_file.close();
997  }
998 
999  if (should_init_logging) {
1000  init_logging();
1001  }
1002 
1004  return 1;
1005  }
1006  if (!trim_and_check_file_exists(authMetadata.ca_file_name, "ca file name")) {
1007  return 1;
1008  }
1010  "ssl trust store")) {
1011  return 1;
1012  }
1014  return 1;
1015  }
1017  return 1;
1018  }
1020  return 1;
1021  }
1022 
1031  } catch (po::error& e) {
1032  std::cerr << "Usage Error: " << e.what() << std::endl;
1033  return 1;
1034  }
1035 
1036  if (g_hll_precision_bits < 1 || g_hll_precision_bits > 16) {
1037  std::cerr << "hll-precision-bits must be between 1 and 16." << std::endl;
1038  return 1;
1039  }
1040 
1041  if (!g_from_table_reordering) {
1042  LOG(INFO) << " From clause table reordering is disabled";
1043  }
1044 
1046  LOG(INFO) << " Filter push down for JOIN is enabled";
1047  }
1048 
1049  if (vm.count("udf")) {
1050  boost::algorithm::trim_if(udf_file_name, boost::is_any_of("\"'"));
1051 
1052  if (!boost::filesystem::exists(udf_file_name)) {
1053  LOG(ERROR) << " User defined function file " << udf_file_name << " does not exist.";
1054  return 1;
1055  }
1056 
1057  LOG(INFO) << " User provided extension functions loaded from " << udf_file_name;
1058  }
1059 
1060  if (vm.count("udf-compiler-path")) {
1061  boost::algorithm::trim_if(udf_compiler_path, boost::is_any_of("\"'"));
1062  }
1063 
1064  auto trim_string = [](std::string& s) {
1065  boost::algorithm::trim_if(s, boost::is_any_of("\"'"));
1066  };
1067 
1068  if (vm.count("udf-compiler-options")) {
1069  std::for_each(udf_compiler_options.begin(), udf_compiler_options.end(), trim_string);
1070  }
1071 
1072  if (enable_runtime_udf) {
1073  LOG(INFO) << " Runtime user defined extension functions enabled globally.";
1074  }
1075 
1076  boost::algorithm::trim_if(system_parameters.ha_brokers, boost::is_any_of("\"'"));
1077  boost::algorithm::trim_if(system_parameters.ha_group_id, boost::is_any_of("\"'"));
1078  boost::algorithm::trim_if(system_parameters.ha_shared_data, boost::is_any_of("\"'"));
1079  boost::algorithm::trim_if(system_parameters.ha_unique_server_id,
1080  boost::is_any_of("\"'"));
1081 
1082  if (!system_parameters.ha_group_id.empty()) {
1083  LOG(INFO) << " HA group id " << system_parameters.ha_group_id;
1084  if (system_parameters.ha_unique_server_id.empty()) {
1085  LOG(ERROR) << "Starting server in HA mode --ha-unique-server-id must be set ";
1086  return 5;
1087  } else {
1088  LOG(INFO) << " HA unique server id " << system_parameters.ha_unique_server_id;
1089  }
1090  if (system_parameters.ha_brokers.empty()) {
1091  LOG(ERROR) << "Starting server in HA mode --ha-brokers must be set ";
1092  return 6;
1093  } else {
1094  LOG(INFO) << " HA brokers " << system_parameters.ha_brokers;
1095  }
1096  if (system_parameters.ha_shared_data.empty()) {
1097  LOG(ERROR) << "Starting server in HA mode --ha-shared-data must be set ";
1098  return 7;
1099  } else {
1100  LOG(INFO) << " HA shared data is " << system_parameters.ha_shared_data;
1101  }
1102  }
1103 
1104  boost::algorithm::trim_if(system_parameters.master_address, boost::is_any_of("\"'"));
1105  if (!system_parameters.master_address.empty()) {
1106  if (!read_only) {
1107  LOG(ERROR) << "The master-address setting is only allowed in read-only mode";
1108  return 9;
1109  }
1110  LOG(INFO) << " Master Address is " << system_parameters.master_address;
1111  LOG(INFO) << " Master Port is " << system_parameters.master_port;
1112  }
1113 
1114  if (g_max_import_threads < 1) {
1115  std::cerr << "max-import-threads must be >= 1 (was set to " << g_max_import_threads
1116  << ")." << std::endl;
1117  return 8;
1118  } else {
1119  LOG(INFO) << " Max import threads " << g_max_import_threads;
1120  }
1121 
1122  LOG(INFO) << " cuda block size " << system_parameters.cuda_block_size;
1123  LOG(INFO) << " cuda grid size " << system_parameters.cuda_grid_size;
1124  LOG(INFO) << " Min CPU buffer pool slab size " << system_parameters.min_cpu_slab_size;
1125  LOG(INFO) << " Max CPU buffer pool slab size " << system_parameters.max_cpu_slab_size;
1126  LOG(INFO) << " Min GPU buffer pool slab size " << system_parameters.min_gpu_slab_size;
1127  LOG(INFO) << " Max GPU buffer pool slab size " << system_parameters.max_gpu_slab_size;
1128  LOG(INFO) << " calcite JVM max memory " << system_parameters.calcite_max_mem;
1129  LOG(INFO) << " OmniSci Server Port " << system_parameters.omnisci_server_port;
1130  LOG(INFO) << " OmniSci Calcite Port " << system_parameters.calcite_port;
1131  LOG(INFO) << " Enable Calcite view optimize "
1133  LOG(INFO) << " Allow Local Auth Fallback: "
1134  << (authMetadata.allowLocalAuthFallback ? "enabled" : "disabled");
1135  LOG(INFO) << " ParallelTop min threshold: " << g_parallel_top_min;
1136  LOG(INFO) << " ParallelTop watchdog max: " << g_parallel_top_max;
1137 
1138  boost::algorithm::trim_if(authMetadata.distinguishedName, boost::is_any_of("\"'"));
1139  boost::algorithm::trim_if(authMetadata.uri, boost::is_any_of("\"'"));
1140  boost::algorithm::trim_if(authMetadata.ldapQueryUrl, boost::is_any_of("\"'"));
1141  boost::algorithm::trim_if(authMetadata.ldapRoleRegex, boost::is_any_of("\"'"));
1142  boost::algorithm::trim_if(authMetadata.ldapSuperUserRole, boost::is_any_of("\"'"));
1143 
1144  return boost::none;
1145 }
std::string distinguishedName
Definition: AuthMetadata.h:25
double g_running_query_interrupt_freq
Definition: Execute.cpp:119
size_t g_parallel_top_max
Definition: ResultSet.cpp:48
std::string ldapQueryUrl
Definition: AuthMetadata.h:26
bool g_enable_watchdog
bool trim_and_check_file_exists(std::string &filename, const std::string desc)
std::string ha_shared_data
std::string udf_compiler_path
unsigned g_pending_query_interrupt_freq
Definition: Execute.cpp:118
po::options_description help_desc
#define LOG(tag)
Definition: Logger.h:200
bool enable_calcite_view_optimize
std::string ldapRoleRegex
Definition: AuthMetadata.h:27
bool g_enable_dynamic_watchdog
Definition: Execute.cpp:77
bool g_enable_non_kernel_time_query_interrupt
Definition: Execute.cpp:116
bool enable_non_kernel_time_query_interrupt
std::string config_file
std::string ha_brokers
size_t g_parallel_top_min
Definition: ResultSet.cpp:47
std::string ssl_trust_ca_file
std::string ssl_trust_store
bool g_from_table_reordering
Definition: Execute.cpp:84
std::string uri
Definition: AuthMetadata.h:24
std::string ha_unique_server_id
std::string ca_file_name
Definition: AuthMetadata.h:31
std::string ssl_key_file
AuthMetadata authMetadata
std::string ldapSuperUserRole
Definition: AuthMetadata.h:28
unsigned pending_query_interrupt_freq
std::stringstream sanitize_config_file(std::ifstream &in)
std::vector< std::string > udf_compiler_options
bool g_enable_filter_push_down
Definition: Execute.cpp:89
bool g_use_estimator_result_cache
Definition: Execute.cpp:117
bool allowLocalAuthFallback
Definition: AuthMetadata.h:32
po::positional_options_description positional_options
std::string ssl_keystore
po::options_description developer_desc
static const std::string MAPD_RELEASE
Definition: release.h:43
static bool run
po::variables_map vm
unsigned g_dynamic_watchdog_time_limit
Definition: Execute.cpp:80
std::string ha_group_id
bool g_enable_runtime_query_interrupt
Definition: Execute.cpp:115
size_t g_max_import_threads
Definition: Importer.cpp:85
std::string master_address
unsigned dynamic_watchdog_time_limit
SystemParameters system_parameters
std::string ssl_cert_file

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

void CommandLineOptions::validate ( )

Definition at line 797 of file CommandLineOptions.cpp.

References anonymous_namespace{CommandLineOptions.cpp}::addOptionalFileToBlacklist(), ddl_utils::FilePathBlacklist::addToBlacklist(), File_Namespace::all, allowed_export_paths, allowed_import_paths, authMetadata, base_path, AuthMetadata::ca_file_name, omnisci::close(), cluster_file, test_exceptions::data_path, db_query_file, disk_cache_config, disk_cache_level, dynamic_watchdog_time_limit, enable_dynamic_watchdog, enable_non_kernel_time_query_interrupt, enable_runtime_query_interrupt, enable_watchdog, File_Namespace::DiskCacheConfig::enabled_level, File_Namespace::fsi, g_enable_debug_timer, g_enable_fsi, g_enable_s3_fsi, Catalog_Namespace::g_log_user_id, g_read_only, g_vacuum_min_selectivity, File_Namespace::CachingFileMgr::getMinimumSize(), idle_session_duration, logger::INFO, ddl_utils::FilePathWhitelist::initialize(), license_path, LOG, max_session_duration, File_Namespace::non_fsi, File_Namespace::none, SystemParameters::num_sessions, OMNISCI_SYSTEM_CATALOG, omnisci::open(), File_Namespace::DiskCacheConfig::path, pending_query_interrupt_freq, read_only, running_query_interrupt_freq, File_Namespace::DiskCacheConfig::size_limit, SystemParameters::ssl_cert_file, SystemParameters::ssl_key_file, SystemParameters::ssl_keystore, SystemParameters::ssl_trust_ca_file, SystemParameters::ssl_trust_store, system_parameters, to_string(), vm, and File_Namespace::write().

Referenced by main().

797  {
798  boost::algorithm::trim_if(base_path, boost::is_any_of("\"'"));
799  const auto data_path = boost::filesystem::path(base_path) / "mapd_data";
800  if (!boost::filesystem::exists(data_path)) {
801  throw std::runtime_error("OmniSci data directory does not exist at '" + base_path +
802  "'");
803  }
804 
805  {
806  const auto lock_file = boost::filesystem::path(base_path) / "omnisci_server_pid.lck";
807  auto pid = std::to_string(getpid());
808 
809 #ifdef _WIN32
810  int pid_fd = _open(lock_file.string().c_str(), O_RDWR | O_CREAT, 0644);
811 #else
812  int pid_fd = open(lock_file.string().c_str(), O_RDWR | O_CREAT, 0644);
813 #endif
814  if (pid_fd == -1) {
815  auto err = std::string("Failed to open PID file ") + lock_file.string().c_str() +
816  ". " + strerror(errno) + ".";
817  throw std::runtime_error(err);
818  }
819 // TODO: support lock on Windows
820 #ifndef _WIN32
821  if (lockf(pid_fd, F_TLOCK, 0) == -1) {
822  ::close(pid_fd);
823  auto err = std::string("Another OmniSci Server is using data directory ") +
824  base_path + ".";
825  throw std::runtime_error(err);
826  }
827 #endif
828  if (ftruncate(pid_fd, 0) == -1) {
829  ::close(pid_fd);
830  auto err = std::string("Failed to truncate PID file ") +
831  lock_file.string().c_str() + ". " + strerror(errno) + ".";
832  throw std::runtime_error(err);
833  }
834  if (write(pid_fd, pid.c_str(), pid.length()) == -1) {
835  ::close(pid_fd);
836  auto err = std::string("Failed to write PID file ") + lock_file.string().c_str() +
837  ". " + strerror(errno) + ".";
838  throw std::runtime_error(err);
839  }
840  }
841  boost::algorithm::trim_if(db_query_file, boost::is_any_of("\"'"));
842  if (db_query_file.length() > 0 && !boost::filesystem::exists(db_query_file)) {
843  throw std::runtime_error("File containing DB queries " + db_query_file +
844  " does not exist.");
845  }
846  const auto db_file =
847  boost::filesystem::path(base_path) / "mapd_catalogs" / OMNISCI_SYSTEM_CATALOG;
848  if (!boost::filesystem::exists(db_file)) {
849  { // check old system catalog existsense
850  const auto db_file = boost::filesystem::path(base_path) / "mapd_catalogs/mapd";
851  if (!boost::filesystem::exists(db_file)) {
852  throw std::runtime_error("OmniSci system catalog " + OMNISCI_SYSTEM_CATALOG +
853  " does not exist.");
854  }
855  }
856  }
857  if (license_path.length() == 0) {
858  license_path = base_path + "/omnisci.license";
859  }
860 
861  // add all parameters to be displayed on startup
862  LOG(INFO) << "OmniSci started with data directory at '" << base_path << "'";
863  if (vm.count("license-path")) {
864  LOG(INFO) << "License key path set to '" << license_path << "'";
865  }
867  LOG(INFO) << " Server read-only mode is " << read_only;
868  LOG(INFO) << " Watchdog is set to " << enable_watchdog;
869  LOG(INFO) << " Dynamic Watchdog is set to " << enable_dynamic_watchdog;
871  LOG(INFO) << " Dynamic Watchdog timeout is set to " << dynamic_watchdog_time_limit;
872  }
873  LOG(INFO) << " Runtime query interrupt is set to " << enable_runtime_query_interrupt;
875  LOG(INFO) << " A frequency of checking pending query interrupt request is set to "
876  << pending_query_interrupt_freq << " (in ms.)";
877  LOG(INFO) << " A frequency of checking running query interrupt request is set to "
878  << running_query_interrupt_freq << " (0.0 ~ 1.0)";
879  }
880  LOG(INFO) << " Non-kernel time query interrupt is set to "
882 
883  LOG(INFO) << " Debug Timer is set to " << g_enable_debug_timer;
884  LOG(INFO) << " LogUserId is set to " << Catalog_Namespace::g_log_user_id;
885  LOG(INFO) << " Maximum idle session duration " << idle_session_duration;
886  LOG(INFO) << " Maximum active session duration " << max_session_duration;
887  LOG(INFO) << " Maximum number of sessions " << system_parameters.num_sessions;
888 
889  LOG(INFO) << "Allowed import paths is set to " << allowed_import_paths;
890  LOG(INFO) << "Allowed export paths is set to " << allowed_export_paths;
893 
895  ddl_utils::FilePathBlacklist::addToBlacklist(base_path + "/temporary/mapd_catalogs");
898  g_enable_s3_fsi = false;
899 
900  if (disk_cache_level == "foreign_tables") {
901  if (g_enable_fsi) {
903  LOG(INFO) << "Disk cache enabled for foreign tables only";
904  } else {
905  LOG(INFO) << "Cannot enable disk cache for fsi when fsi is disabled. Defaulted to "
906  "disk cache disabled";
907  }
908  } else if (disk_cache_level == "all") {
910  LOG(INFO) << "Disk cache enabled for all tables";
911  } else if (disk_cache_level == "local_tables") {
913  LOG(INFO) << "Disk cache enabled for non-FSI tables";
914  } else if (disk_cache_level == "none") {
916  LOG(INFO) << "Disk cache disabled";
917  } else {
918  throw std::runtime_error{
919  "Unexpected \"disk-cache-level\" value: " + disk_cache_level +
920  ". Valid options are 'foreign_tables', "
921  "'local_tables', 'none', and 'all'."};
922  }
923 
925  throw std::runtime_error{"disk-cache-size must be at least " +
927  }
928 
929  if (disk_cache_config.path.empty()) {
930  disk_cache_config.path = base_path + "/omnisci_disk_cache";
931  }
933 
936 
937  // If passed in, blacklist all security config files
946 
947  if (g_vacuum_min_selectivity < 0) {
948  throw std::runtime_error{"vacuum-min-selectivity cannot be less than 0."};
949  }
950  LOG(INFO) << "Vacuum Min Selectivity: " << g_vacuum_min_selectivity;
951 }
int open(const char *path, int flags, int mode)
Definition: omnisci_fs.cpp:64
static void initialize(const std::string &data_dir, const std::string &allowed_import_paths, const std::string &allowed_export_paths)
Definition: DdlUtils.cpp:690
#define LOG(tag)
Definition: Logger.h:200
bool g_enable_debug_timer
Definition: Logger.cpp:17
const std::string OMNISCI_SYSTEM_CATALOG
Definition: SysCatalog.h:58
void addOptionalFileToBlacklist(std::string &filename)
bool enable_non_kernel_time_query_interrupt
std::string to_string(char const *&&v)
size_t write(FILE *f, const size_t offset, const size_t size, const int8_t *buf)
Writes the specified number of bytes to the offset position in file f from buf.
Definition: File.cpp:141
std::string ssl_trust_ca_file
void close(const int fd)
Definition: omnisci_fs.cpp:68
std::string ssl_trust_store
bool g_enable_s3_fsi
Definition: Catalog.cpp:93
std::string allowed_export_paths
std::string ca_file_name
Definition: AuthMetadata.h:31
std::string ssl_key_file
AuthMetadata authMetadata
bool g_read_only
Definition: File.cpp:38
unsigned pending_query_interrupt_freq
float g_vacuum_min_selectivity
std::string ssl_keystore
File_Namespace::DiskCacheConfig disk_cache_config
static void addToBlacklist(const std::string &path)
Definition: DdlUtils.cpp:735
std::string allowed_import_paths
std::string disk_cache_level
po::variables_map vm
bool g_enable_fsi
Definition: Catalog.cpp:92
unsigned dynamic_watchdog_time_limit
SystemParameters system_parameters
std::string ssl_cert_file

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

void CommandLineOptions::validate_base_path ( )

Definition at line 790 of file CommandLineOptions.cpp.

References base_path.

Referenced by init_logging(), and main().

790  {
791  boost::algorithm::trim_if(base_path, boost::is_any_of("\"'"));
792  if (!boost::filesystem::exists(base_path)) {
793  throw std::runtime_error("OmniSci base directory does not exist at " + base_path);
794  }
795 }

+ Here is the caller graph for this function:

Member Data Documentation

bool CommandLineOptions::allow_loop_joins = false
bool CommandLineOptions::allow_multifrag = true
std::string CommandLineOptions::allowed_export_paths {}

Definition at line 111 of file CommandLineOptions.h.

Referenced by fillOptions(), and validate().

std::string CommandLineOptions::allowed_import_paths {}

Definition at line 110 of file CommandLineOptions.h.

Referenced by fillOptions(), and validate().

std::string CommandLineOptions::base_path
std::string CommandLineOptions::cluster_file = {"cluster.conf"}

Definition at line 50 of file CommandLineOptions.h.

Referenced by validate().

std::string CommandLineOptions::cluster_topology_file = {"cluster_topology.conf"}

Definition at line 51 of file CommandLineOptions.h.

std::string CommandLineOptions::clusterIds_arg

Definition at line 131 of file CommandLineOptions.h.

std::string CommandLineOptions::compressor = std::string(BLOSC_LZ4HC_COMPNAME)

Definition at line 120 of file CommandLineOptions.h.

std::vector<LeafHostInfo> CommandLineOptions::db_leaves

Definition at line 128 of file CommandLineOptions.h.

Referenced by EmbeddedDatabase::DBEngineImpl::init(), and startMapdServer().

std::string CommandLineOptions::db_query_file = {""}

path to file containing warmup queries list

Definition at line 92 of file CommandLineOptions.h.

Referenced by fillOptions(), startMapdServer(), and validate().

po::options_description CommandLineOptions::developer_desc

Definition at line 123 of file CommandLineOptions.h.

Referenced by fillAdvancedOptions(), and parse_command_line().

File_Namespace::DiskCacheConfig CommandLineOptions::disk_cache_config
std::string CommandLineOptions::disk_cache_level = ""

Definition at line 83 of file CommandLineOptions.h.

Referenced by fillOptions(), and validate().

const bool CommandLineOptions::dist_v5_

Definition at line 143 of file CommandLineOptions.h.

Referenced by fillOptions().

unsigned CommandLineOptions::dynamic_watchdog_time_limit = 10000

Definition at line 82 of file CommandLineOptions.h.

Referenced by fillOptions(), parse_command_line(), and validate().

bool CommandLineOptions::enable_auto_clear_render_mem = false

Definition at line 66 of file CommandLineOptions.h.

Referenced by EmbeddedDatabase::DBEngineImpl::init(), and startMapdServer().

bool CommandLineOptions::enable_dynamic_watchdog = false

Definition at line 76 of file CommandLineOptions.h.

Referenced by fillOptions(), parse_command_line(), and validate().

bool CommandLineOptions::enable_legacy_syntax = true
bool CommandLineOptions::enable_non_kernel_time_query_interrupt = true

Definition at line 78 of file CommandLineOptions.h.

Referenced by fillOptions(), parse_command_line(), and validate().

bool CommandLineOptions::enable_rendering = false

Definition at line 65 of file CommandLineOptions.h.

Referenced by EmbeddedDatabase::DBEngineImpl::init(), and startMapdServer().

bool CommandLineOptions::enable_runtime_query_interrupt = false

Definition at line 77 of file CommandLineOptions.h.

Referenced by fillOptions(), parse_command_line(), and validate().

bool CommandLineOptions::enable_runtime_udf = false
bool CommandLineOptions::enable_watchdog = true

Definition at line 75 of file CommandLineOptions.h.

Referenced by fillOptions(), parse_command_line(), and validate().

std::string CommandLineOptions::encryption_key_store_path = {}

Definition at line 53 of file CommandLineOptions.h.

bool CommandLineOptions::exit_after_warmup = false

exit after warmup

Definition at line 96 of file CommandLineOptions.h.

Referenced by fillOptions(), and startMapdServer().

po::options_description CommandLineOptions::help_desc

Definition at line 122 of file CommandLineOptions.h.

Referenced by fillOptions(), and parse_command_line().

int CommandLineOptions::http_port = 6278

Definition at line 46 of file CommandLineOptions.h.

Referenced by fillOptions(), and startMapdServer().

int CommandLineOptions::idle_session_duration = kMinsPerHour

Inactive session tolerance in mins (60 mins)

Definition at line 100 of file CommandLineOptions.h.

Referenced by fillOptions(), EmbeddedDatabase::DBEngineImpl::init(), startMapdServer(), and validate().

bool CommandLineOptions::intel_jit_profile = false
bool CommandLineOptions::jit_debug = false
std::string CommandLineOptions::license_path = {""}

Definition at line 52 of file CommandLineOptions.h.

Referenced by validate().

logger::LogOptions CommandLineOptions::log_options_

Definition at line 124 of file CommandLineOptions.h.

Referenced by fillOptions(), and init_logging().

bool CommandLineOptions::log_user_origin = true

Definition at line 61 of file CommandLineOptions.h.

Referenced by fillOptions(), and startMapdServer().

size_t CommandLineOptions::max_concurrent_render_sessions = 500

Definition at line 69 of file CommandLineOptions.h.

Referenced by EmbeddedDatabase::DBEngineImpl::init(), and startMapdServer().

int CommandLineOptions::max_session_duration = kMinsPerMonth

Maximum session life in mins (43,200 mins == 30 Days) (https://pages.nist.gov/800-63-3/sp800-63b.html#aal3reauth)

Definition at line 105 of file CommandLineOptions.h.

Referenced by fillOptions(), EmbeddedDatabase::DBEngineImpl::init(), startMapdServer(), and validate().

const std::string CommandLineOptions::nodeIds_token = {"node_id"}
static

Definition at line 135 of file CommandLineOptions.h.

size_t CommandLineOptions::num_reader_threads = 0

Number of threads used when loading data

Definition at line 88 of file CommandLineOptions.h.

Referenced by fillOptions(), EmbeddedDatabase::DBEngineImpl::init(), and startMapdServer().

unsigned CommandLineOptions::pending_query_interrupt_freq = 1000

Definition at line 81 of file CommandLineOptions.h.

Referenced by fillOptions(), parse_command_line(), and validate().

po::positional_options_description CommandLineOptions::positional_options

Definition at line 125 of file CommandLineOptions.h.

Referenced by fillOptions(), and parse_command_line().

bool CommandLineOptions::read_only = false
bool CommandLineOptions::render_compositor_use_last_gpu = true

Definition at line 70 of file CommandLineOptions.h.

Referenced by EmbeddedDatabase::DBEngineImpl::init(), and startMapdServer().

size_t CommandLineOptions::render_mem_bytes = 1000000000

Definition at line 68 of file CommandLineOptions.h.

Referenced by EmbeddedDatabase::DBEngineImpl::init(), and startMapdServer().

int CommandLineOptions::render_oom_retry_threshold = 0

Definition at line 67 of file CommandLineOptions.h.

Referenced by EmbeddedDatabase::DBEngineImpl::init(), and startMapdServer().

bool CommandLineOptions::renderer_use_vulkan_driver = false

Definition at line 71 of file CommandLineOptions.h.

Referenced by EmbeddedDatabase::DBEngineImpl::init(), and startMapdServer().

size_t CommandLineOptions::reserved_gpu_mem = 384 * 1024 * 1024
double CommandLineOptions::running_query_interrupt_freq = 0.5

Definition at line 80 of file CommandLineOptions.h.

Referenced by fillOptions(), parse_command_line(), and validate().

std::vector<LeafHostInfo> CommandLineOptions::string_leaves

Definition at line 129 of file CommandLineOptions.h.

Referenced by EmbeddedDatabase::DBEngineImpl::init(), and startMapdServer().

std::vector<std::string> CommandLineOptions::udf_compiler_options
std::string CommandLineOptions::udf_compiler_path = {""}
std::string CommandLineOptions::udf_file_name = {""}
bool CommandLineOptions::use_estimator_result_cache = true

Definition at line 79 of file CommandLineOptions.h.

Referenced by fillOptions(), and parse_command_line().

bool CommandLineOptions::verbose_logging = false

Definition at line 54 of file CommandLineOptions.h.

Referenced by fillOptions(), and init_logging().

po::variables_map CommandLineOptions::vm

Definition at line 130 of file CommandLineOptions.h.

Referenced by parse_command_line(), and validate().


The documentation for this class was generated from the following files: