OmniSciDB  0fdbebe030
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
MapDProgramOptions Class Reference

#include <MapDProgramOptions.h>

+ Inheritance diagram for MapDProgramOptions:
+ Collaboration diagram for MapDProgramOptions:

Public Member Functions

 MapDProgramOptions (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)
 
void validate ()
 
void validate_base_path ()
 
void init_logging ()
 
 MapDProgramOptions ()
 
bool parse_command_line (int argc, char **argv, int &return_code)
 

Public Attributes

int http_port = 6278
 
size_t reserved_gpu_mem = 384 * 1024 * 1024
 
std::string base_path
 
std::string cluster_file = {"cluster.conf"}
 
std::string cluster_topology_file = {"cluster_topology.conf"}
 
std::string license_path = {""}
 
bool cpu_only = false
 
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
 
AuthMetadata authMetadata
 
MapDParameters mapd_parameters
 
bool enable_rendering = false
 
bool enable_auto_clear_render_mem = false
 
int render_oom_retry_threshold = 0
 
size_t render_mem_bytes = 500000000
 
size_t render_poly_cache_bytes = 300000000
 
size_t max_concurrent_render_sessions = 500
 
bool enable_runtime_udf = false
 
bool enable_watchdog = true
 
bool enable_dynamic_watchdog = false
 
bool enable_runtime_query_interrupt = false
 
unsigned runtime_query_interrupt_frequency = 1000
 
unsigned dynamic_watchdog_time_limit = 10000
 
int num_gpus = -1
 
int start_gpu = 0
 
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
 
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_
 
std::string config_file = {"mapd.conf"}
 
bool flush_log = true
 

Static Public Attributes

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

Private Member Functions

void fillOptions (boost::program_options::options_description &desc)
 
void fillAdvancedOptions (boost::program_options::options_description &desc_adv)
 

Private Attributes

boost::program_options::variables_map vm
 

Detailed Description

Definition at line 249 of file MapDServer.cpp.

Constructor & Destructor Documentation

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

Definition at line 251 of file MapDServer.cpp.

References fillAdvancedOptions(), and fillOptions().

252  : log_options_(argv0), dist_v5_(dist_v5_) {
253  fillOptions();
255  }
const bool dist_v5_
Definition: MapDServer.cpp:341
void fillAdvancedOptions()
Definition: MapDServer.cpp:617
logger::LogOptions log_options_
Definition: MapDServer.cpp:324

+ Here is the call graph for this function:

MapDProgramOptions::MapDProgramOptions ( )

Member Function Documentation

void MapDProgramOptions::fillAdvancedOptions ( boost::program_options::options_description &  desc_adv)
private
void MapDProgramOptions::fillAdvancedOptions ( )

Definition at line 617 of file MapDServer.cpp.

References allow_multifrag, authMetadata, AuthMetadata::ca_file_name, developer_desc, MapDParameters::enable_calcite_view_optimize, enable_legacy_syntax, g_enable_bump_allocator, g_enable_columnar_output, g_enable_direct_columnarization, g_enable_smem_group_by, g_enable_table_functions, g_enable_window_functions, g_max_memory_allocation_size, g_min_memory_allocation_size, g_skip_intermediate_count, g_strip_join_covered_quals, g_use_tbb_pool, intel_jit_profile, jit_debug, mapd_parameters, AuthMetadata::pki_db_client_auth, MapDParameters::ssl_cert_file, MapDParameters::ssl_key_file, MapDParameters::ssl_keystore, MapDParameters::ssl_keystore_password, MapDParameters::ssl_transport_client_auth, MapDParameters::ssl_trust_ca_file, MapDParameters::ssl_trust_password, MapDParameters::ssl_trust_store, udf_compiler_options, udf_compiler_path, and udf_file_name.

Referenced by MapDProgramOptions().

617  {
618  developer_desc.add_options()("dev-options", "Print internal developer options.");
619  developer_desc.add_options()(
620  "enable-calcite-view-optimize",
623  ->implicit_value(true),
624  "Enable additional calcite (query plan) optimizations when a view is part of the "
625  "query.");
626  developer_desc.add_options()(
627  "enable-columnar-output",
628  po::value<bool>(&g_enable_columnar_output)
629  ->default_value(g_enable_columnar_output)
630  ->implicit_value(true),
631  "Enable columnar output for intermediate/final query steps.");
632  developer_desc.add_options()("enable-legacy-syntax",
633  po::value<bool>(&enable_legacy_syntax)
634  ->default_value(enable_legacy_syntax)
635  ->implicit_value(true),
636  "Enable legacy syntax.");
637  developer_desc.add_options()(
638  "enable-multifrag",
639  po::value<bool>(&allow_multifrag)
640  ->default_value(allow_multifrag)
641  ->implicit_value(true),
642  "Enable execution over multiple fragments in a single round-trip to GPU.");
643  developer_desc.add_options()(
644  "enable-shared-mem-group-by",
645  po::value<bool>(&g_enable_smem_group_by)
646  ->default_value(g_enable_smem_group_by)
647  ->implicit_value(true),
648  "Enable using GPU shared memory for some GROUP BY queries.");
649  developer_desc.add_options()("enable-direct-columnarization",
650  po::value<bool>(&g_enable_direct_columnarization)
651  ->default_value(g_enable_direct_columnarization)
652  ->implicit_value(true),
653  "Enables/disables a more optimized columnarization method "
654  "for intermediate steps in multi-step queries.");
655  developer_desc.add_options()("enable-window-functions",
656  po::value<bool>(&g_enable_window_functions)
657  ->default_value(g_enable_window_functions)
658  ->implicit_value(true),
659  "Enable experimental window function support.");
660  developer_desc.add_options()("enable-table-functions",
661  po::value<bool>(&g_enable_table_functions)
662  ->default_value(g_enable_table_functions)
663  ->implicit_value(true),
664  "Enable experimental table functions support.");
665  developer_desc.add_options()(
666  "jit-debug-ir",
667  po::value<bool>(&jit_debug)->default_value(jit_debug)->implicit_value(true),
668  "Enable runtime debugger support for the JIT. Note that this flag is "
669  "incompatible "
670  "with the `ENABLE_JIT_DEBUG` build flag. The generated code can be found at "
671  "`/tmp/mapdquery`.");
672  developer_desc.add_options()(
673  "intel-jit-profile",
674  po::value<bool>(&intel_jit_profile)
675  ->default_value(intel_jit_profile)
676  ->implicit_value(true),
677  "Enable runtime support for the JIT code profiling using Intel VTune.");
678  developer_desc.add_options()(
679  "enable-modern-thread-pool",
680  po::value<bool>(&g_use_tbb_pool)
681  ->default_value(g_use_tbb_pool)
682  ->implicit_value(true),
683  "Enable a new thread pool implementation for queuing kernels for execution.");
684  developer_desc.add_options()(
685  "skip-intermediate-count",
686  po::value<bool>(&g_skip_intermediate_count)
687  ->default_value(g_skip_intermediate_count)
688  ->implicit_value(true),
689  "Skip pre-flight counts for intermediate projections with no filters.");
690  developer_desc.add_options()(
691  "strip-join-covered-quals",
692  po::value<bool>(&g_strip_join_covered_quals)
693  ->default_value(g_strip_join_covered_quals)
694  ->implicit_value(true),
695  "Remove quals from the filtered count if they are covered by a "
696  "join condition (currently only ST_Contains).");
697  developer_desc.add_options()(
698  "max-output-projection-allocation-bytes",
699  po::value<size_t>(&g_max_memory_allocation_size)
700  ->default_value(g_max_memory_allocation_size),
701  "Maximum allocation size for a fixed output buffer allocation for projection "
702  "queries with no pre-flight count. Default is the maximum slab size (sizes "
703  "greater "
704  "than the maximum slab size have no affect). Requires bump allocator.");
705  developer_desc.add_options()(
706  "min-output-projection-allocation-bytes",
707  po::value<size_t>(&g_min_memory_allocation_size)
708  ->default_value(g_min_memory_allocation_size),
709  "Minimum allocation size for a fixed output buffer allocation for projection "
710  "queries with no pre-flight count. If an allocation of this size cannot be "
711  "obtained, the query will be retried with different execution parameters and/or "
712  "on "
713  "CPU (if allow-cpu-retry is enabled). Requires bump allocator.");
714  developer_desc.add_options()("enable-bump-allocator",
715  po::value<bool>(&g_enable_bump_allocator)
716  ->default_value(g_enable_bump_allocator)
717  ->implicit_value(true),
718  "Enable the bump allocator for projection queries on "
719  "GPU. The bump allocator will "
720  "allocate a fixed size buffer for each query, track the "
721  "number of rows passing the "
722  "kernel during query execution, and copy back only the "
723  "rows that passed the kernel "
724  "to CPU after execution. When disabled, pre-flight "
725  "count queries are used to size "
726  "the output buffer for projection queries.");
727 
728  developer_desc.add_options()("ssl-cert",
729  po::value<std::string>(&mapd_parameters.ssl_cert_file)
730  ->default_value(std::string("")),
731  "SSL Validated public certficate.");
732 
733  developer_desc.add_options()(
734  "pki-db-client-auth",
735  po::value<bool>(&authMetadata.pki_db_client_auth)->default_value(false),
736  "Use client PKI authentication to the database.");
737 
738  developer_desc.add_options()(
739  "ssl-transport-client-auth",
740  po::value<bool>(&mapd_parameters.ssl_transport_client_auth)->default_value(false),
741  "SSL Use client PKI authentication at the transport layer.");
742 
743  developer_desc.add_options()("ssl-private-key",
744  po::value<std::string>(&mapd_parameters.ssl_key_file)
745  ->default_value(std::string("")),
746  "SSL private key file.");
747  // Note ssl_trust_store is passed through to Calcite via mapd_parameters
748  // todo(jack): add ensure ssl-trust-store exists if cert and private key in use
749  developer_desc.add_options()("ssl-trust-store",
750  po::value<std::string>(&mapd_parameters.ssl_trust_store)
751  ->default_value(std::string("")),
752  "SSL public CA certifcates (java trust store) to validate "
753  "TLS connections (passed through to the Calcite server).");
754 
755  developer_desc.add_options()(
756  "ssl-trust-password",
757  po::value<std::string>(&mapd_parameters.ssl_trust_password)
758  ->default_value(std::string("")),
759  "SSL password for java trust store provided via --ssl-trust-store parameter.");
760 
761  developer_desc.add_options()(
762  "ssl-trust-ca",
763  po::value<std::string>(&mapd_parameters.ssl_trust_ca_file)
764  ->default_value(std::string("")),
765  "SSL public CA certificates to validate TLS connection(as a client).");
766 
767  developer_desc.add_options()(
768  "ssl-trust-ca-server",
769  po::value<std::string>(&authMetadata.ca_file_name)->default_value(std::string("")),
770  "SSL public CA certificates to validate TLS connection(as a server).");
771 
772  developer_desc.add_options()("ssl-keystore",
773  po::value<std::string>(&mapd_parameters.ssl_keystore)
774  ->default_value(std::string("")),
775  "SSL server credentials as a java key store (passed "
776  "through to the Calcite server).");
777 
778  developer_desc.add_options()(
779  "ssl-keystore-password",
780  po::value<std::string>(&mapd_parameters.ssl_keystore_password)
781  ->default_value(std::string("")),
782  "SSL password for java keystore, provide by via --ssl-keystore.");
783 
784  developer_desc.add_options()(
785  "udf",
786  po::value<std::string>(&udf_file_name),
787  "Load user defined extension functions from this file at startup. The file is "
788  "expected to be a C/C++ file with extension .cpp.");
789 
790  developer_desc.add_options()(
791  "udf-compiler-path",
792  po::value<std::string>(&udf_compiler_path),
793  "Provide absolute path to clang++ used in udf compilation.");
794 
795  developer_desc.add_options()("udf-compiler-options",
796  po::value<std::vector<std::string>>(&udf_compiler_options),
797  "Specify compiler options to tailor udf compilation.");
798 }
bool g_enable_smem_group_by
bool enable_calcite_view_optimize
bool g_enable_bump_allocator
Definition: Execute.cpp:100
bool g_strip_join_covered_quals
Definition: Execute.cpp:91
std::string ssl_key_file
bool g_enable_direct_columnarization
Definition: Execute.cpp:102
std::string ssl_trust_store
std::string udf_file_name
Definition: MapDServer.cpp:315
bool ssl_transport_client_auth
std::string ssl_trust_ca_file
size_t g_max_memory_allocation_size
Definition: Execute.cpp:96
bool g_use_tbb_pool
Definition: Execute.cpp:73
bool g_enable_columnar_output
Definition: Execute.cpp:87
MapDParameters mapd_parameters
Definition: MapDServer.cpp:272
po::options_description developer_desc
Definition: MapDServer.cpp:323
std::string udf_compiler_path
Definition: MapDServer.cpp:316
size_t g_min_memory_allocation_size
Definition: Execute.cpp:97
std::string ssl_keystore
std::string ssl_keystore_password
std::vector< std::string > udf_compiler_options
Definition: MapDServer.cpp:317
std::string ssl_trust_password
std::string ca_file_name
Definition: AuthMetadata.h:33
std::string ssl_cert_file
bool g_enable_window_functions
Definition: Execute.cpp:94
AuthMetadata authMetadata
Definition: MapDServer.cpp:270
bool g_enable_table_functions
Definition: Execute.cpp:95
bool g_skip_intermediate_count
bool pki_db_client_auth
Definition: AuthMetadata.h:32

+ Here is the caller graph for this function:

void MapDProgramOptions::fillOptions ( boost::program_options::options_description &  desc)
private
void MapDProgramOptions::fillOptions ( )

Definition at line 352 of file MapDServer.cpp.

References allow_loop_joins, base_path, MapDParameters::calcite_max_mem, MapDParameters::calcite_port, MapDParameters::calcite_timeout, MapDParameters::config_file, MapDParameters::cpu_buffer_mem_bytes, cpu_only, MapDParameters::cuda_block_size, MapDParameters::cuda_grid_size, db_query_file, dist_v5_, dynamic_watchdog_time_limit, enable_dynamic_watchdog, enable_runtime_query_interrupt, enable_runtime_udf, enable_watchdog, exit_after_warmup, g_allow_cpu_retry, 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_interop, g_enable_overlaps_hashjoin, g_enable_stringdict_parallel, g_enable_thrift_logs, 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, g_null_div_by_zero, g_overlaps_max_table_size_bytes, g_trivial_loop_join_threshold, logger::LogOptions::get_options(), MapDParameters::gpu_buffer_mem_bytes, MapDParameters::gpu_input_mem_limit, help_desc, http_port, idle_session_duration, log_options_, mapd_parameters, max_session_duration, num_gpus, num_reader_threads, MapDParameters::omnisci_server_port, positional_options, read_only, run_benchmark_import::required, reserved_gpu_mem, runtime_query_interrupt_frequency, start_gpu, and verbose_logging.

Referenced by MapDProgramOptions().

352  {
353  help_desc.add_options()("help,h", "Show available options.");
354  help_desc.add_options()(
355  "allow-cpu-retry",
356  po::value<bool>(&g_allow_cpu_retry)
357  ->default_value(g_allow_cpu_retry)
358  ->implicit_value(true),
359  R"(Allow the queries which failed on GPU to retry on CPU, even when watchdog is enabled.)");
360  help_desc.add_options()("allow-loop-joins",
361  po::value<bool>(&allow_loop_joins)
362  ->default_value(allow_loop_joins)
363  ->implicit_value(true),
364  "Enable loop joins.");
365  help_desc.add_options()("bigint-count",
366  po::value<bool>(&g_bigint_count)
367  ->default_value(g_bigint_count)
368  ->implicit_value(false),
369  "Use 64-bit count.");
370  help_desc.add_options()("calcite-max-mem",
371  po::value<size_t>(&mapd_parameters.calcite_max_mem)
372  ->default_value(mapd_parameters.calcite_max_mem),
373  "Max memory available to calcite JVM.");
374  if (!dist_v5_) {
375  help_desc.add_options()("calcite-port",
376  po::value<int>(&mapd_parameters.calcite_port)
377  ->default_value(mapd_parameters.calcite_port),
378  "Calcite port number.");
379  }
380  help_desc.add_options()("config",
381  po::value<std::string>(&mapd_parameters.config_file),
382  "Path to server configuration file.");
383  help_desc.add_options()("cpu-buffer-mem-bytes",
384  po::value<size_t>(&mapd_parameters.cpu_buffer_mem_bytes)
385  ->default_value(mapd_parameters.cpu_buffer_mem_bytes),
386  "Size of memory reserved for CPU buffers, in bytes.");
387  help_desc.add_options()(
388  "cpu-only",
389  po::value<bool>(&cpu_only)->default_value(cpu_only)->implicit_value(true),
390  "Run on CPU only, even if GPUs are available.");
391  help_desc.add_options()("cuda-block-size",
392  po::value<size_t>(&mapd_parameters.cuda_block_size)
393  ->default_value(mapd_parameters.cuda_block_size),
394  "Size of block to use on GPU.");
395  help_desc.add_options()("cuda-grid-size",
396  po::value<size_t>(&mapd_parameters.cuda_grid_size)
397  ->default_value(mapd_parameters.cuda_grid_size),
398  "Size of grid to use on GPU.");
399  if (!dist_v5_) {
400  help_desc.add_options()(
401  "data",
402  po::value<std::string>(&base_path)->required()->default_value("data"),
403  "Directory path to OmniSci data storage (catalogs, raw data, log files, etc).");
404  positional_options.add("data", 1);
405  }
406  help_desc.add_options()("db-query-list",
407  po::value<std::string>(&db_query_file),
408  "Path to file containing OmniSci warmup queries.");
409  help_desc.add_options()(
410  "exit-after-warmup",
411  po::value<bool>(&exit_after_warmup)->default_value(false)->implicit_value(true),
412  "Exit after OmniSci warmup queries.");
413  help_desc.add_options()("dynamic-watchdog-time-limit",
414  po::value<unsigned>(&dynamic_watchdog_time_limit)
415  ->default_value(dynamic_watchdog_time_limit)
416  ->implicit_value(10000),
417  "Dynamic watchdog time limit, in milliseconds.");
418  help_desc.add_options()("enable-debug-timer",
419  po::value<bool>(&g_enable_debug_timer)
420  ->default_value(g_enable_debug_timer)
421  ->implicit_value(true),
422  "Enable debug timer logging.");
423  help_desc.add_options()("enable-dynamic-watchdog",
424  po::value<bool>(&enable_dynamic_watchdog)
425  ->default_value(enable_dynamic_watchdog)
426  ->implicit_value(true),
427  "Enable dynamic watchdog.");
428  help_desc.add_options()("enable-filter-push-down",
429  po::value<bool>(&g_enable_filter_push_down)
430  ->default_value(g_enable_filter_push_down)
431  ->implicit_value(true),
432  "Enable filter push down through joins.");
433  help_desc.add_options()("enable-overlaps-hashjoin",
434  po::value<bool>(&g_enable_overlaps_hashjoin)
435  ->default_value(g_enable_overlaps_hashjoin)
436  ->implicit_value(true),
437  "Enable the overlaps hash join framework allowing for range "
438  "join (e.g. spatial overlaps) computation using a hash table.");
439  help_desc.add_options()("enable-runtime-query-interrupt",
440  po::value<bool>(&enable_runtime_query_interrupt)
441  ->default_value(enable_runtime_query_interrupt)
442  ->implicit_value(true),
443  "Enable runtime query interrupt.");
444  help_desc.add_options()("runtime-query-interrupt-frequency",
445  po::value<unsigned>(&runtime_query_interrupt_frequency)
446  ->default_value(runtime_query_interrupt_frequency)
447  ->implicit_value(1000),
448  "A frequency of checking the request of runtime query "
449  "interrupt from user (in millisecond).");
450  if (!dist_v5_) {
451  help_desc.add_options()(
452  "enable-string-dict-hash-cache",
453  po::value<bool>(&g_cache_string_hash)
454  ->default_value(g_cache_string_hash)
455  ->implicit_value(true),
456  "Cache string hash values in the string dictionary server during import.");
457  }
458  help_desc.add_options()(
459  "enable-thrift-logs",
460  po::value<bool>(&g_enable_thrift_logs)
461  ->default_value(g_enable_thrift_logs)
462  ->implicit_value(true),
463  "Enable writing messages directly from thrift to stdout/stderr.");
464  help_desc.add_options()("enable-watchdog",
465  po::value<bool>(&enable_watchdog)
466  ->default_value(enable_watchdog)
467  ->implicit_value(true),
468  "Enable watchdog.");
469  help_desc.add_options()(
470  "filter-push-down-low-frac",
471  po::value<float>(&g_filter_push_down_low_frac)
472  ->default_value(g_filter_push_down_low_frac)
473  ->implicit_value(g_filter_push_down_low_frac),
474  "Lower threshold for selectivity of filters that are pushed down.");
475  help_desc.add_options()(
476  "filter-push-down-high-frac",
477  po::value<float>(&g_filter_push_down_high_frac)
478  ->default_value(g_filter_push_down_high_frac)
479  ->implicit_value(g_filter_push_down_high_frac),
480  "Higher threshold for selectivity of filters that are pushed down.");
481  help_desc.add_options()("filter-push-down-passing-row-ubound",
482  po::value<size_t>(&g_filter_push_down_passing_row_ubound)
484  ->implicit_value(g_filter_push_down_passing_row_ubound),
485  "Upperbound on the number of rows that should pass the filter "
486  "if the selectivity is less than "
487  "the high fraction threshold.");
488  help_desc.add_options()("from-table-reordering",
489  po::value<bool>(&g_from_table_reordering)
490  ->default_value(g_from_table_reordering)
491  ->implicit_value(true),
492  "Enable automatic table reordering in FROM clause.");
493  help_desc.add_options()("gpu-buffer-mem-bytes",
494  po::value<size_t>(&mapd_parameters.gpu_buffer_mem_bytes)
495  ->default_value(mapd_parameters.gpu_buffer_mem_bytes),
496  "Size of memory reserved for GPU buffers, in bytes, per GPU.");
497  help_desc.add_options()("gpu-input-mem-limit",
498  po::value<double>(&mapd_parameters.gpu_input_mem_limit)
499  ->default_value(mapd_parameters.gpu_input_mem_limit),
500  "Force query to CPU when input data memory usage exceeds this "
501  "percentage of available GPU memory.");
502  help_desc.add_options()(
503  "hll-precision-bits",
504  po::value<int>(&g_hll_precision_bits)
505  ->default_value(g_hll_precision_bits)
506  ->implicit_value(g_hll_precision_bits),
507  "Number of bits used from the hash value used to specify the bucket number.");
508  if (!dist_v5_) {
509  help_desc.add_options()("http-port",
510  po::value<int>(&http_port)->default_value(http_port),
511  "HTTP port number.");
512  }
513  help_desc.add_options()(
514  "idle-session-duration",
515  po::value<int>(&idle_session_duration)->default_value(idle_session_duration),
516  "Maximum duration of idle session.");
517  help_desc.add_options()("inner-join-fragment-skipping",
518  po::value<bool>(&g_inner_join_fragment_skipping)
519  ->default_value(g_inner_join_fragment_skipping)
520  ->implicit_value(true),
521  "Enable/disable inner join fragment skipping. This feature is "
522  "considered stable and is enabled by default. This "
523  "parameter will be removed in a future release.");
524  help_desc.add_options()(
525  "max-session-duration",
526  po::value<int>(&max_session_duration)->default_value(max_session_duration),
527  "Maximum duration of active session.");
528  help_desc.add_options()(
529  "null-div-by-zero",
530  po::value<bool>(&g_null_div_by_zero)
531  ->default_value(g_null_div_by_zero)
532  ->implicit_value(true),
533  "Return null on division by zero instead of throwing an exception.");
534  help_desc.add_options()(
535  "num-reader-threads",
536  po::value<size_t>(&num_reader_threads)->default_value(num_reader_threads),
537  "Number of reader threads to use.");
538  help_desc.add_options()(
539  "overlaps-max-table-size-bytes",
540  po::value<size_t>(&g_overlaps_max_table_size_bytes)
541  ->default_value(g_overlaps_max_table_size_bytes),
542  "The maximum size in bytes of the hash table for an overlaps hash join.");
543  if (!dist_v5_) {
544  help_desc.add_options()("port,p",
545  po::value<int>(&mapd_parameters.omnisci_server_port)
546  ->default_value(mapd_parameters.omnisci_server_port),
547  "TCP Port number.");
548  }
549  help_desc.add_options()("num-gpus",
550  po::value<int>(&num_gpus)->default_value(num_gpus),
551  "Number of gpus to use.");
552  help_desc.add_options()(
553  "read-only",
554  po::value<bool>(&read_only)->default_value(read_only)->implicit_value(true),
555  "Enable read-only mode.");
556  help_desc.add_options()(
557  "res-gpu-mem",
558  po::value<size_t>(&reserved_gpu_mem)->default_value(reserved_gpu_mem),
559  "Reduces GPU memory available to the OmniSci allocator by this amount. Used for "
560  "compiled code cache and ancillary GPU functions and other processes that may also "
561  "be using the GPU concurrent with OmniSciDB.");
562  help_desc.add_options()("start-gpu",
563  po::value<int>(&start_gpu)->default_value(start_gpu),
564  "First gpu to use.");
565  help_desc.add_options()("trivial-loop-join-threshold",
566  po::value<unsigned>(&g_trivial_loop_join_threshold)
567  ->default_value(g_trivial_loop_join_threshold)
568  ->implicit_value(1000),
569  "The maximum number of rows in the inner table of a loop join "
570  "considered to be trivially small.");
571  help_desc.add_options()("verbose",
572  po::value<bool>(&verbose_logging)
573  ->default_value(verbose_logging)
574  ->implicit_value(true),
575  "Write additional debug log messages to server logs.");
576  help_desc.add_options()(
577  "enable-runtime-udf",
578  po::value<bool>(&enable_runtime_udf)
579  ->default_value(enable_runtime_udf)
580  ->implicit_value(true),
581  "Enable runtime UDF registration by passing signatures and corresponding LLVM IR "
582  "to the `register_runtime_udf` endpoint. For use with the Python Remote Backend "
583  "Compiler server, packaged separately.");
584  help_desc.add_options()("version,v", "Print Version Number.");
585  help_desc.add_options()("enable-experimental-string-functions",
588  ->implicit_value(true),
589  "Enable experimental string functions.");
590 #ifdef ENABLE_FSI
591  help_desc.add_options()(
592  "enable-fsi",
593  po::value<bool>(&g_enable_fsi)->default_value(g_enable_fsi)->implicit_value(true),
594  "Enable foreign storage interface.");
595 #endif // ENABLE_FSI
596  help_desc.add_options()(
597  "enable-interoperability",
598  po::value<bool>(&g_enable_interop)
599  ->default_value(g_enable_interop)
600  ->implicit_value(true),
601  "Enable offloading of query portions to an external execution engine.");
602  help_desc.add_options()(
603  "calcite-service-timeout",
604  po::value<size_t>(&mapd_parameters.calcite_timeout)
605  ->default_value(mapd_parameters.calcite_timeout),
606  "Calcite server timeout (milliseconds). Increase this on systems with frequent "
607  "schema changes or when running large numbers of parallel queries.");
608  help_desc.add_options()(
609  "stringdict-parallelizm",
610  po::value<bool>(&g_enable_stringdict_parallel)
611  ->default_value(g_enable_stringdict_parallel)
612  ->implicit_value(false),
613  "Allow StringDictionary to parallelize loads using multiple threads");
615 }
float g_filter_push_down_low_frac
Definition: Execute.cpp:84
size_t gpu_buffer_mem_bytes
bool g_enable_debug_timer
Definition: Logger.cpp:17
size_t g_filter_push_down_passing_row_ubound
Definition: Execute.cpp:86
unsigned g_trivial_loop_join_threshold
Definition: Execute.cpp:77
int g_hll_precision_bits
size_t cuda_block_size
po::options_description help_desc
Definition: MapDServer.cpp:322
bool g_enable_overlaps_hashjoin
Definition: Execute.cpp:88
bool g_inner_join_fragment_skipping
Definition: Execute.cpp:79
boost::program_options::options_description const & get_options() const
Definition: Logger.cpp:79
const bool dist_v5_
Definition: MapDServer.cpp:341
bool g_null_div_by_zero
Definition: Execute.cpp:76
MapDParameters mapd_parameters
Definition: MapDServer.cpp:272
bool g_from_table_reordering
Definition: Execute.cpp:78
std::string config_file
unsigned dynamic_watchdog_time_limit
Definition: MapDServer.cpp:286
size_t cuda_grid_size
float g_filter_push_down_high_frac
Definition: Execute.cpp:85
bool g_enable_thrift_logs
Definition: initdb.cpp:41
unsigned runtime_query_interrupt_frequency
Definition: MapDServer.cpp:285
bool g_bigint_count
std::string base_path
Definition: MapDServer.cpp:258
size_t g_overlaps_max_table_size_bytes
Definition: Execute.cpp:90
size_t calcite_timeout
bool g_enable_interop
size_t calcite_max_mem
std::string db_query_file
Definition: MapDServer.cpp:301
double gpu_input_mem_limit
bool g_enable_experimental_string_functions
size_t cpu_buffer_mem_bytes
bool g_cache_string_hash
Definition: Execute.cpp:89
bool g_enable_filter_push_down
Definition: Execute.cpp:83
po::positional_options_description positional_options
Definition: MapDServer.cpp:325
bool enable_runtime_query_interrupt
Definition: MapDServer.cpp:284
bool g_allow_cpu_retry
Definition: Execute.cpp:75
bool g_enable_stringdict_parallel
bool g_enable_fsi
Definition: Catalog.cpp:89
logger::LogOptions log_options_
Definition: MapDServer.cpp:324

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

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

Definition at line 344 of file MapDServer.cpp.

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

Referenced by main().

344  {
347  }
350 }
void init(LogOptions const &log_opts)
Definition: Logger.cpp:276
std::string base_path
Definition: MapDServer.cpp:258
Severity severity_
Definition: Logger.h:118
void set_base_path(std::string const &base_path)
Definition: Logger.cpp:93
logger::LogOptions log_options_
Definition: MapDServer.cpp:324

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

bool MapDProgramOptions::parse_command_line ( int  argc,
char **  argv,
int &  return_code 
)
boost::optional< int > MapDProgramOptions::parse_command_line ( int  argc,
char const *const *  argv 
)

Definition at line 909 of file MapDServer.cpp.

References AuthMetadata::allowLocalAuthFallback, authMetadata, AuthMetadata::ca_file_name, MapDParameters::calcite_max_mem, MapDParameters::calcite_port, MapDParameters::config_file, MapDParameters::cuda_block_size, MapDParameters::cuda_grid_size, developer_desc, AuthMetadata::distinguishedName, dynamic_watchdog_time_limit, MapDParameters::enable_calcite_view_optimize, enable_dynamic_watchdog, 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_runtime_query_interrupt, g_enable_watchdog, g_from_table_reordering, g_runtime_query_interrupt_frequency, MapDParameters::ha_brokers, MapDParameters::ha_group_id, MapDParameters::ha_shared_data, MapDParameters::ha_unique_server_id, help_desc, logger::INFO, AuthMetadata::ldapQueryUrl, AuthMetadata::ldapRoleRegex, AuthMetadata::ldapSuperUserRole, LOG, mapd_parameters, MAPD_RELEASE, MapDParameters::omnisci_server_port, positional_options, AuthMetadata::restToken, AuthMetadata::restUrl, run, runtime_query_interrupt_frequency, anonymous_namespace{MapDServer.cpp}::sanitize_config_file(), MapDParameters::ssl_cert_file, MapDParameters::ssl_key_file, MapDParameters::ssl_keystore, MapDParameters::ssl_trust_ca_file, MapDParameters::ssl_trust_store, anonymous_namespace{MapDServer.cpp}::trim_and_check_file_exists(), udf_compiler_options, udf_compiler_path, udf_file_name, AuthMetadata::uri, and vm.

Referenced by main().

910  {
911  po::options_description all_desc("All options");
912  all_desc.add(help_desc).add(developer_desc);
913 
914  try {
915  po::store(po::command_line_parser(argc, argv)
916  .options(all_desc)
917  .positional(positional_options)
918  .run(),
919  vm);
920  po::notify(vm);
921 
922  if (vm.count("config")) {
923  std::ifstream settings_file(mapd_parameters.config_file);
924 
925  auto sanitized_settings = sanitize_config_file(settings_file);
926 
927  po::store(po::parse_config_file(sanitized_settings, all_desc, false), vm);
928  po::notify(vm);
929  settings_file.close();
930  }
931 
933  return 1;
934  }
935  if (!trim_and_check_file_exists(authMetadata.ca_file_name, "ca file name")) {
936  return 1;
937  }
939  return 1;
940  }
942  return 1;
943  }
945  return 1;
946  }
948  return 1;
949  }
950 
951  if (vm.count("help")) {
952  std::cerr << "Usage: omnisci_server <data directory path> [-p <port number>] "
953  "[--http-port <http port number>] [--flush-log] [--version|-v]"
954  << std::endl
955  << std::endl;
956  std::cout << help_desc << std::endl;
957  return 0;
958  }
959  if (vm.count("dev-options")) {
960  std::cout << "Usage: omnisci_server <data directory path> [-p <port number>] "
961  "[--http-port <http port number>] [--flush-log] [--version|-v]"
962  << std::endl
963  << std::endl;
964  std::cout << developer_desc << std::endl;
965  return 0;
966  }
967  if (vm.count("version")) {
968  std::cout << "OmniSci Version: " << MAPD_RELEASE << std::endl;
969  return 0;
970  }
971 
977  } catch (po::error& e) {
978  std::cerr << "Usage Error: " << e.what() << std::endl;
979  return 1;
980  }
981 
982  if (g_hll_precision_bits < 1 || g_hll_precision_bits > 16) {
983  std::cerr << "hll-precision-bits must be between 1 and 16." << std::endl;
984  return 1;
985  }
986 
988  LOG(INFO) << " From clause table reordering is disabled";
989  }
990 
992  LOG(INFO) << " Filter push down for JOIN is enabled";
993  }
994 
995  if (vm.count("udf")) {
996  boost::algorithm::trim_if(udf_file_name, boost::is_any_of("\"'"));
997 
998  if (!boost::filesystem::exists(udf_file_name)) {
999  LOG(ERROR) << " User defined function file " << udf_file_name << " does not exist.";
1000  return 1;
1001  }
1002 
1003  LOG(INFO) << " User provided extension functions loaded from " << udf_file_name;
1004  }
1005 
1006  if (vm.count("udf-compiler-path")) {
1007  boost::algorithm::trim_if(udf_compiler_path, boost::is_any_of("\"'"));
1008  }
1009 
1010  auto trim_string = [](std::string& s) {
1011  boost::algorithm::trim_if(s, boost::is_any_of("\"'"));
1012  };
1013 
1014  if (vm.count("udf-compiler-options")) {
1015  std::for_each(udf_compiler_options.begin(), udf_compiler_options.end(), trim_string);
1016  }
1017 
1018  if (enable_runtime_udf) {
1019  LOG(INFO) << " Runtime user defined extension functions enabled globally.";
1020  }
1021 
1022  boost::algorithm::trim_if(mapd_parameters.ha_brokers, boost::is_any_of("\"'"));
1023  boost::algorithm::trim_if(mapd_parameters.ha_group_id, boost::is_any_of("\"'"));
1024  boost::algorithm::trim_if(mapd_parameters.ha_shared_data, boost::is_any_of("\"'"));
1025  boost::algorithm::trim_if(mapd_parameters.ha_unique_server_id, boost::is_any_of("\"'"));
1026 
1027  if (!mapd_parameters.ha_group_id.empty()) {
1028  LOG(INFO) << " HA group id " << mapd_parameters.ha_group_id;
1029  if (mapd_parameters.ha_unique_server_id.empty()) {
1030  LOG(ERROR) << "Starting server in HA mode --ha-unique-server-id must be set ";
1031  return 5;
1032  } else {
1033  LOG(INFO) << " HA unique server id " << mapd_parameters.ha_unique_server_id;
1034  }
1035  if (mapd_parameters.ha_brokers.empty()) {
1036  LOG(ERROR) << "Starting server in HA mode --ha-brokers must be set ";
1037  return 6;
1038  } else {
1039  LOG(INFO) << " HA brokers " << mapd_parameters.ha_brokers;
1040  }
1041  if (mapd_parameters.ha_shared_data.empty()) {
1042  LOG(ERROR) << "Starting server in HA mode --ha-shared-data must be set ";
1043  return 7;
1044  } else {
1045  LOG(INFO) << " HA shared data is " << mapd_parameters.ha_shared_data;
1046  }
1047  }
1048  LOG(INFO) << " cuda block size " << mapd_parameters.cuda_block_size;
1049  LOG(INFO) << " cuda grid size " << mapd_parameters.cuda_grid_size;
1050  LOG(INFO) << " calcite JVM max memory " << mapd_parameters.calcite_max_mem;
1051  LOG(INFO) << " OmniSci Server Port " << mapd_parameters.omnisci_server_port;
1052  LOG(INFO) << " OmniSci Calcite Port " << mapd_parameters.calcite_port;
1053  LOG(INFO) << " Enable Calcite view optimize "
1055 
1056  LOG(INFO) << " Allow Local Auth Fallback: "
1057  << (authMetadata.allowLocalAuthFallback ? "enabled" : "disabled");
1058 
1059  boost::algorithm::trim_if(authMetadata.distinguishedName, boost::is_any_of("\"'"));
1060  boost::algorithm::trim_if(authMetadata.uri, boost::is_any_of("\"'"));
1061  boost::algorithm::trim_if(authMetadata.ldapQueryUrl, boost::is_any_of("\"'"));
1062  boost::algorithm::trim_if(authMetadata.ldapRoleRegex, boost::is_any_of("\"'"));
1063  boost::algorithm::trim_if(authMetadata.ldapSuperUserRole, boost::is_any_of("\"'"));
1064  boost::algorithm::trim_if(authMetadata.restToken, boost::is_any_of("\"'"));
1065  boost::algorithm::trim_if(authMetadata.restUrl, boost::is_any_of("\"'"));
1066 
1067  return boost::none;
1068 }
std::string distinguishedName
Definition: AuthMetadata.h:25
std::string ldapQueryUrl
Definition: AuthMetadata.h:26
bool enable_calcite_view_optimize
std::string ssl_key_file
#define LOG(tag)
Definition: Logger.h:188
std::string ldapRoleRegex
Definition: AuthMetadata.h:27
std::string ssl_trust_store
std::string udf_file_name
Definition: MapDServer.cpp:315
std::string ssl_trust_ca_file
bool g_enable_dynamic_watchdog
Definition: Execute.cpp:72
size_t cuda_block_size
po::options_description help_desc
Definition: MapDServer.cpp:322
bool g_enable_watchdog
std::string ha_shared_data
std::string restToken
Definition: AuthMetadata.h:31
MapDParameters mapd_parameters
Definition: MapDServer.cpp:272
po::options_description developer_desc
Definition: MapDServer.cpp:323
bool g_from_table_reordering
Definition: Execute.cpp:78
std::string udf_compiler_path
Definition: MapDServer.cpp:316
std::string ssl_keystore
std::string restUrl
Definition: AuthMetadata.h:30
std::string config_file
std::vector< std::string > udf_compiler_options
Definition: MapDServer.cpp:317
unsigned dynamic_watchdog_time_limit
Definition: MapDServer.cpp:286
size_t cuda_grid_size
std::string uri
Definition: AuthMetadata.h:24
unsigned runtime_query_interrupt_frequency
Definition: MapDServer.cpp:285
std::string ca_file_name
Definition: AuthMetadata.h:33
std::string ssl_cert_file
po::variables_map vm
Definition: MapDServer.cpp:330
size_t calcite_max_mem
unsigned g_runtime_query_interrupt_frequency
Definition: Execute.cpp:105
std::string ldapSuperUserRole
Definition: AuthMetadata.h:28
bool trim_and_check_file_exists(std::string &filename, const std::string desc)
Definition: MapDServer.cpp:815
std::string ha_brokers
AuthMetadata authMetadata
Definition: MapDServer.cpp:270
std::stringstream sanitize_config_file(std::ifstream &in)
Definition: MapDServer.cpp:802
bool g_enable_filter_push_down
Definition: Execute.cpp:83
bool allowLocalAuthFallback
Definition: AuthMetadata.h:34
po::positional_options_description positional_options
Definition: MapDServer.cpp:325
bool enable_runtime_query_interrupt
Definition: MapDServer.cpp:284
std::string ha_group_id
static const std::string MAPD_RELEASE
Definition: release.h:43
static bool run
unsigned g_dynamic_watchdog_time_limit
Definition: Execute.cpp:74
bool g_enable_runtime_query_interrupt
Definition: Execute.cpp:104
std::string ha_unique_server_id

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

void MapDProgramOptions::validate ( )

Definition at line 835 of file MapDServer.cpp.

References base_path, File_Namespace::close(), db_query_file, dynamic_watchdog_time_limit, enable_dynamic_watchdog, enable_runtime_query_interrupt, enable_watchdog, g_enable_debug_timer, idle_session_duration, logger::INFO, LOG, max_session_duration, OMNISCI_SYSTEM_CATALOG, File_Namespace::open(), runtime_query_interrupt_frequency, to_string(), and File_Namespace::write().

Referenced by main().

835  {
836  boost::algorithm::trim_if(base_path, boost::is_any_of("\"'"));
837  const auto data_path = boost::filesystem::path(base_path) / "mapd_data";
838  if (!boost::filesystem::exists(data_path)) {
839  throw std::runtime_error("OmniSci data directory does not exist at '" + base_path +
840  "'");
841  }
842 
843  {
844  const auto lock_file = boost::filesystem::path(base_path) / "omnisci_server_pid.lck";
845  auto pid = std::to_string(getpid());
846 
847  int pid_fd = open(lock_file.c_str(), O_RDWR | O_CREAT, 0644);
848  if (pid_fd == -1) {
849  auto err = std::string("Failed to open PID file ") + lock_file.c_str() + ". " +
850  strerror(errno) + ".";
851  throw std::runtime_error(err);
852  }
853  if (lockf(pid_fd, F_TLOCK, 0) == -1) {
854  close(pid_fd);
855  auto err = std::string("Another OmniSci Server is using data directory ") +
856  base_path + ".";
857  throw std::runtime_error(err);
858  }
859  if (ftruncate(pid_fd, 0) == -1) {
860  close(pid_fd);
861  auto err = std::string("Failed to truncate PID file ") + lock_file.c_str() + ". " +
862  strerror(errno) + ".";
863  throw std::runtime_error(err);
864  }
865  if (write(pid_fd, pid.c_str(), pid.length()) == -1) {
866  close(pid_fd);
867  auto err = std::string("Failed to write PID file ") + lock_file.c_str() + ". " +
868  strerror(errno) + ".";
869  throw std::runtime_error(err);
870  }
871  }
872  boost::algorithm::trim_if(db_query_file, boost::is_any_of("\"'"));
873  if (db_query_file.length() > 0 && !boost::filesystem::exists(db_query_file)) {
874  throw std::runtime_error("File containing DB queries " + db_query_file +
875  " does not exist.");
876  }
877  const auto db_file =
878  boost::filesystem::path(base_path) / "mapd_catalogs" / OMNISCI_SYSTEM_CATALOG;
879  if (!boost::filesystem::exists(db_file)) {
880  { // check old system catalog existsense
881  const auto db_file = boost::filesystem::path(base_path) / "mapd_catalogs/mapd";
882  if (!boost::filesystem::exists(db_file)) {
883  throw std::runtime_error("OmniSci system catalog " + OMNISCI_SYSTEM_CATALOG +
884  " does not exist.");
885  }
886  }
887  }
888 
889  // add all parameters to be displayed on startup
890  LOG(INFO) << "OmniSci started with data directory at '" << base_path << "'";
891  LOG(INFO) << " Watchdog is set to " << enable_watchdog;
892  LOG(INFO) << " Dynamic Watchdog is set to " << enable_dynamic_watchdog;
894  LOG(INFO) << " Dynamic Watchdog timeout is set to " << dynamic_watchdog_time_limit;
895  }
896  LOG(INFO) << " Runtime query interrupt is set to " << enable_runtime_query_interrupt;
898  LOG(INFO) << " A frequency of checking runtime query interrupt request is set to "
899  << runtime_query_interrupt_frequency << " (in ms.)";
900  }
901 
902  LOG(INFO) << " Debug Timer is set to " << g_enable_debug_timer;
903 
904  LOG(INFO) << " Maximum Idle session duration " << idle_session_duration;
905 
906  LOG(INFO) << " Maximum active session duration " << max_session_duration;
907 }
#define LOG(tag)
Definition: Logger.h:188
bool g_enable_debug_timer
Definition: Logger.cpp:17
const std::string OMNISCI_SYSTEM_CATALOG
Definition: SysCatalog.h:57
std::string to_string(char const *&&v)
unsigned dynamic_watchdog_time_limit
Definition: MapDServer.cpp:286
unsigned runtime_query_interrupt_frequency
Definition: MapDServer.cpp:285
std::string base_path
Definition: MapDServer.cpp:258
std::string db_query_file
Definition: MapDServer.cpp:301
FILE * open(int fileId)
Opens/creates the file with the given id; returns NULL on error.
Definition: File.cpp:82
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:120
bool enable_runtime_query_interrupt
Definition: MapDServer.cpp:284
void close(FILE *f)
Closes the file pointed to by the FILE pointer.
Definition: File.cpp:101

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

void MapDProgramOptions::validate_base_path ( )

Definition at line 828 of file MapDServer.cpp.

References base_path.

Referenced by main().

828  {
829  boost::algorithm::trim_if(base_path, boost::is_any_of("\"'"));
830  if (!boost::filesystem::exists(base_path)) {
831  throw std::runtime_error("OmniSci base directory does not exist at " + base_path);
832  }
833 }
std::string base_path
Definition: MapDServer.cpp:258

+ Here is the caller graph for this function:

Member Data Documentation

bool MapDProgramOptions::allow_loop_joins = false

Definition at line 268 of file MapDServer.cpp.

Referenced by fillOptions(), and startMapdServer().

bool MapDProgramOptions::allow_multifrag = true

Definition at line 266 of file MapDServer.cpp.

Referenced by fillAdvancedOptions(), and startMapdServer().

AuthMetadata MapDProgramOptions::authMetadata

Definition at line 270 of file MapDServer.cpp.

Referenced by fillAdvancedOptions(), parse_command_line(), and startMapdServer().

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

Definition at line 259 of file MapDServer.cpp.

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

Definition at line 260 of file MapDServer.cpp.

std::string MapDProgramOptions::clusterIds_arg

Definition at line 331 of file MapDServer.cpp.

std::string MapDProgramOptions::config_file = {"mapd.conf"}

Definition at line 37 of file MapDProgramOptions.h.

bool MapDProgramOptions::cpu_only = false

Definition at line 262 of file MapDServer.cpp.

Referenced by fillOptions(), and startMapdServer().

std::vector< LeafHostInfo > MapDProgramOptions::db_leaves

Definition at line 328 of file MapDServer.cpp.

Referenced by startMapdServer().

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

path to file containing warmup queries list

Definition at line 301 of file MapDServer.cpp.

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

po::options_description MapDProgramOptions::developer_desc

Definition at line 323 of file MapDServer.cpp.

Referenced by fillAdvancedOptions(), and parse_command_line().

const bool MapDProgramOptions::dist_v5_

Definition at line 341 of file MapDServer.cpp.

Referenced by fillOptions().

unsigned MapDProgramOptions::dynamic_watchdog_time_limit = 10000

Definition at line 286 of file MapDServer.cpp.

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

bool MapDProgramOptions::enable_auto_clear_render_mem = false

Definition at line 274 of file MapDServer.cpp.

Referenced by startMapdServer().

bool MapDProgramOptions::enable_dynamic_watchdog = false

Definition at line 283 of file MapDServer.cpp.

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

bool MapDProgramOptions::enable_legacy_syntax = true

Definition at line 269 of file MapDServer.cpp.

Referenced by fillAdvancedOptions(), and startMapdServer().

bool MapDProgramOptions::enable_rendering = false

Definition at line 273 of file MapDServer.cpp.

Referenced by startMapdServer().

bool MapDProgramOptions::enable_runtime_query_interrupt = false

Definition at line 284 of file MapDServer.cpp.

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

bool MapDProgramOptions::enable_runtime_udf = false

Definition at line 280 of file MapDServer.cpp.

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

bool MapDProgramOptions::enable_watchdog = true

Definition at line 282 of file MapDServer.cpp.

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

bool MapDProgramOptions::exit_after_warmup = false

exit after warmup

Definition at line 305 of file MapDServer.cpp.

Referenced by fillOptions(), and startMapdServer().

bool MapDProgramOptions::flush_log = true

Definition at line 40 of file MapDProgramOptions.h.

po::options_description MapDProgramOptions::help_desc

Definition at line 322 of file MapDServer.cpp.

Referenced by fillOptions(), and parse_command_line().

int MapDProgramOptions::http_port = 6278

Definition at line 256 of file MapDServer.cpp.

Referenced by fillOptions(), and startMapdServer().

int MapDProgramOptions::idle_session_duration = kMinsPerHour

Inactive session tolerance in mins (60 mins)

Definition at line 309 of file MapDServer.cpp.

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

bool MapDProgramOptions::intel_jit_profile = false

Definition at line 265 of file MapDServer.cpp.

Referenced by fillAdvancedOptions(), and startMapdServer().

bool MapDProgramOptions::jit_debug = false

Definition at line 264 of file MapDServer.cpp.

Referenced by fillAdvancedOptions(), and startMapdServer().

std::string MapDProgramOptions::license_path = {""}

Definition at line 261 of file MapDServer.cpp.

logger::LogOptions MapDProgramOptions::log_options_

Definition at line 324 of file MapDServer.cpp.

Referenced by fillOptions(), and init_logging().

MapDParameters MapDProgramOptions::mapd_parameters
size_t MapDProgramOptions::max_concurrent_render_sessions = 500

Definition at line 278 of file MapDServer.cpp.

Referenced by startMapdServer().

int MapDProgramOptions::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 314 of file MapDServer.cpp.

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

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

Definition at line 335 of file MapDServer.cpp.

int MapDProgramOptions::num_gpus = -1

Can be used to override the number of gpus detected on the system -1 means do not override

Definition at line 292 of file MapDServer.cpp.

Referenced by fillOptions(), and startMapdServer().

size_t MapDProgramOptions::num_reader_threads = 0

Number of threads used when loading data

Definition at line 297 of file MapDServer.cpp.

Referenced by fillOptions(), and startMapdServer().

po::positional_options_description MapDProgramOptions::positional_options

Definition at line 325 of file MapDServer.cpp.

Referenced by fillOptions(), and parse_command_line().

bool MapDProgramOptions::read_only = false

Definition at line 267 of file MapDServer.cpp.

Referenced by fillOptions(), and startMapdServer().

size_t MapDProgramOptions::render_mem_bytes = 500000000

Definition at line 276 of file MapDServer.cpp.

Referenced by startMapdServer().

int MapDProgramOptions::render_oom_retry_threshold = 0

Definition at line 275 of file MapDServer.cpp.

Referenced by startMapdServer().

size_t MapDProgramOptions::render_poly_cache_bytes = 300000000

Definition at line 277 of file MapDServer.cpp.

size_t MapDProgramOptions::reserved_gpu_mem = 384 * 1024 * 1024

Definition at line 257 of file MapDServer.cpp.

Referenced by fillOptions(), and startMapdServer().

unsigned MapDProgramOptions::runtime_query_interrupt_frequency = 1000

Definition at line 285 of file MapDServer.cpp.

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

int MapDProgramOptions::start_gpu = 0

Definition at line 293 of file MapDServer.cpp.

Referenced by fillOptions(), and startMapdServer().

std::vector< LeafHostInfo > MapDProgramOptions::string_leaves

Definition at line 329 of file MapDServer.cpp.

Referenced by startMapdServer().

std::vector<std::string> MapDProgramOptions::udf_compiler_options

Definition at line 317 of file MapDServer.cpp.

Referenced by fillAdvancedOptions(), parse_command_line(), and startMapdServer().

std::string MapDProgramOptions::udf_compiler_path = {""}

Definition at line 316 of file MapDServer.cpp.

Referenced by fillAdvancedOptions(), parse_command_line(), and startMapdServer().

std::string MapDProgramOptions::udf_file_name = {""}

Definition at line 315 of file MapDServer.cpp.

Referenced by fillAdvancedOptions(), parse_command_line(), and startMapdServer().

bool MapDProgramOptions::verbose_logging = false

Definition at line 263 of file MapDServer.cpp.

Referenced by fillOptions(), and init_logging().

boost::program_options::variables_map MapDProgramOptions::vm
private

Definition at line 73 of file MapDProgramOptions.h.

po::variables_map MapDProgramOptions::vm

Definition at line 330 of file MapDServer.cpp.

Referenced by parse_command_line().


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