OmniSciDB  04ee39c94c
/home/jenkins-slave/workspace/core-os-doxygen/MapDServer.cpp File Reference
#include "MapDServer.h"
#include "ThriftHandler/MapDHandler.h"
#include <thrift/concurrency/PlatformThreadFactory.h>
#include <thrift/concurrency/ThreadManager.h>
#include <thrift/protocol/TBinaryProtocol.h>
#include <thrift/protocol/TJSONProtocol.h>
#include <thrift/server/TThreadedServer.h>
#include <thrift/transport/TBufferTransports.h>
#include <thrift/transport/THttpServer.h>
#include <thrift/transport/TSSLServerSocket.h>
#include <thrift/transport/TSSLSocket.h>
#include <thrift/transport/TServerSocket.h>
#include "MapDRelease.h"
#include "Archive/S3Archive.h"
#include "Shared/Logger.h"
#include "Shared/MapDParameters.h"
#include "Shared/file_delete.h"
#include "Shared/mapd_shared_mutex.h"
#include "Shared/mapd_shared_ptr.h"
#include "Shared/scope.h"
#include <boost/algorithm/string.hpp>
#include <boost/filesystem.hpp>
#include <boost/make_shared.hpp>
#include <boost/program_options.hpp>
#include <csignal>
#include <sstream>
#include <thread>
#include <vector>
+ Include dependency graph for MapDServer.cpp:

Go to the source code of this file.

Classes

class  MapDProgramOptions
 

Namespaces

 anonymous_namespace{MapDServer.cpp}
 

Functions

TableGenerations table_generations_from_thrift (const std::vector< TTableGeneration > &thrift_table_generations)
 
void shutdown_handler ()
 
void register_signal_handler (int signum, void(*handler)(int))
 
void omnisci_signal_handler (int signum)
 
void register_signal_handlers ()
 
void start_server (TThreadedServer &server, const int port)
 
void releaseWarmupSession (TSessionId &sessionId, std::ifstream &query_file)
 
void run_warmup_queries (mapd::shared_ptr< MapDHandler > handler, std::string base_path, std::string query_file_path)
 
std::stringstream anonymous_namespace{MapDServer.cpp}::sanitize_config_file (std::ifstream &in)
 
bool anonymous_namespace{MapDServer.cpp}::trim_and_check_file_exists (std::string &filename, const std::string desc)
 
void heartbeat ()
 
int main (int argc, char **argv)
 

Variables

unsigned connect_timeout {20000}
 
unsigned recv_timeout {300000}
 
unsigned send_timeout {300000}
 
bool g_cache_string_hash
 
size_t g_leaf_count
 
bool g_skip_intermediate_count
 
bool g_enable_bump_allocator
 
size_t g_max_memory_allocation_size
 
size_t g_min_memory_allocation_size
 
bool g_enable_thrift_logs {false}
 
std::atomic< bool > g_running {true}
 
std::atomic< int > g_saw_signal {-1}
 
mapd_shared_mutex g_thrift_mutex
 
TThreadedServer * g_thrift_http_server {nullptr}
 
TThreadedServer * g_thrift_buf_server {nullptr}
 
mapd::shared_ptr< MapDHandlerg_warmup_handler
 
mapd::shared_ptr< MapDHandlerg_mapd_handler = 0
 
std::once_flag g_shutdown_once_flag
 

Function Documentation

◆ heartbeat()

void heartbeat ( )

Definition at line 923 of file MapDServer.cpp.

References g_mapd_handler, g_running, g_saw_signal, g_shutdown_once_flag, g_thrift_buf_server, g_thrift_http_server, g_thrift_mutex, logger::INFO, LOG, run-benchmark-import::result, logger::shutdown(), and VLOG.

Referenced by main().

923  {
924  // Block all signals for this heartbeat thread, only.
925  sigset_t set;
926  sigfillset(&set);
927  int result = pthread_sigmask(SIG_BLOCK, &set, NULL);
928  if (result != 0) {
929  throw std::runtime_error("heartbeat() thread startup failed");
930  }
931 
932  // Sleep until omnisci_signal_handler or anything clears the g_running flag.
933  VLOG(1) << "heartbeat thread starting";
934  while (::g_running) {
935  using namespace std::chrono;
936  std::this_thread::sleep_for(1s);
937  }
938  VLOG(1) << "heartbeat thread exiting";
939 
940  // Get the signal number if there was a signal.
941  int signum = g_saw_signal;
942  if (signum >= 1 && signum != SIGTERM) {
943  LOG(INFO) << "Interrupt signal (" << signum << ") received.";
944  }
945 
946  // if dumping core, try to do some quick stuff
947  if (signum == SIGQUIT || signum == SIGABRT || signum == SIGSEGV || signum == SIGFPE) {
948  if (g_mapd_handler) {
949  std::call_once(g_shutdown_once_flag,
950  []() { g_mapd_handler->emergency_shutdown(); });
951  }
953  return;
954  // core dump should begin soon after this, see omnisci_signal_handler()
955  }
956 
957  // trigger an orderly shutdown by telling Thrift to stop serving
958  {
959  mapd_shared_lock<mapd_shared_mutex> read_lock(g_thrift_mutex);
960  auto httpserv = g_thrift_http_server;
961  if (httpserv) {
962  httpserv->stop();
963  }
964  auto bufserv = g_thrift_buf_server;
965  if (bufserv) {
966  bufserv->stop();
967  }
968  // main() should return soon after this
969  }
970 }
mapd_shared_mutex g_thrift_mutex
Definition: MapDServer.cpp:72
TThreadedServer * g_thrift_buf_server
Definition: MapDServer.cpp:74
mapd::shared_ptr< MapDHandler > g_mapd_handler
Definition: MapDServer.cpp:91
std::once_flag g_shutdown_once_flag
Definition: MapDServer.cpp:92
#define LOG(tag)
Definition: Logger.h:182
TThreadedServer * g_thrift_http_server
Definition: MapDServer.cpp:73
std::atomic< int > g_saw_signal
Definition: MapDServer.cpp:70
void shutdown()
Definition: Logger.cpp:294
std::atomic< bool > g_running
Definition: MapDServer.cpp:69
#define VLOG(n)
Definition: Logger.h:277
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ main()

int main ( int  argc,
char **  argv 
)

Definition at line 972 of file MapDServer.cpp.

References MapDProgramOptions::allow_loop_joins, MapDProgramOptions::allow_multifrag, MapDProgramOptions::authMetadata, MapDProgramOptions::base_path, MapDProgramOptions::cpu_only, MapDProgramOptions::db_leaves, MapDProgramOptions::db_query_file, MapDProgramOptions::enable_auto_clear_render_mem, MapDProgramOptions::enable_legacy_syntax, MapDProgramOptions::enable_rendering, MapDProgramOptions::enable_runtime_udf, MapDProgramOptions::enable_spirv, logger::FATAL, file_delete(), g_enable_thrift_logs, g_mapd_handler, g_running, g_saw_signal, g_thrift_buf_server, g_thrift_http_server, g_thrift_mutex, MapDParameters::ha_group_id, heartbeat(), MapDProgramOptions::http_port, MapDProgramOptions::idle_session_duration, logger::INFO, MapDProgramOptions::intel_jit_profile, MapDProgramOptions::jit_debug, LOG, MapDProgramOptions::mapd_parameters, MapDProgramOptions::max_session_duration, MapDProgramOptions::num_gpus, MapDProgramOptions::num_reader_threads, MapDParameters::omnisci_server_port, MapDProgramOptions::parse_command_line(), MapDProgramOptions::read_only, register_signal_handlers(), MapDProgramOptions::render_mem_bytes, MapDProgramOptions::render_oom_retry_threshold, MapDProgramOptions::reserved_gpu_mem, run_warmup_queries(), logger::shutdown(), shutdown_handler(), MapDParameters::ssl_cert_file, MapDParameters::ssl_key_file, MapDProgramOptions::start_gpu, start_server(), MapDProgramOptions::string_leaves, and MapDProgramOptions::udf_file_name.

972  {
973  MapDProgramOptions prog_config_opts(argv[0]);
974 
975  if (auto return_code = prog_config_opts.parse_command_line(argc, argv)) {
976  return *return_code;
977  }
978 
979  // try to enforce an orderly shutdown even after a signal
981 
982  // register shutdown procedures for when a normal shutdown happens
983  // be aware that atexit() functions run in reverse order
984  atexit(&logger::shutdown);
985  atexit(&shutdown_handler);
986 
987 #ifdef HAVE_AWS_S3
988  // hold a s3 archive here to survive from a segfault that happens on centos
989  // when s3 transactions and others openssl-ed sessions are interleaved...
990  auto s3_survivor = std::make_unique<S3Archive>("s3://omnisci/s3_survivor.txt", true);
991 #endif
992 
993  // start background thread to clean up _DELETE_ME files
994  const unsigned int wait_interval =
995  3; // wait time in secs after looking for deleted file before looking again
996  std::thread file_delete_thread(file_delete,
997  std::ref(g_running),
998  wait_interval,
999  prog_config_opts.base_path + "/mapd_data");
1000  std::thread heartbeat_thread(heartbeat);
1001 
1002  if (!g_enable_thrift_logs) {
1003  apache::thrift::GlobalOutput.setOutputFunction([](const char* msg) {});
1004  }
1005 
1006  g_mapd_handler =
1007  mapd::make_shared<MapDHandler>(prog_config_opts.db_leaves,
1008  prog_config_opts.string_leaves,
1009  prog_config_opts.base_path,
1010  prog_config_opts.cpu_only,
1011  prog_config_opts.allow_multifrag,
1012  prog_config_opts.jit_debug,
1013  prog_config_opts.intel_jit_profile,
1014  prog_config_opts.read_only,
1015  prog_config_opts.allow_loop_joins,
1016  prog_config_opts.enable_rendering,
1017  prog_config_opts.enable_spirv,
1018  prog_config_opts.enable_auto_clear_render_mem,
1019  prog_config_opts.render_oom_retry_threshold,
1020  prog_config_opts.render_mem_bytes,
1021  prog_config_opts.num_gpus,
1022  prog_config_opts.start_gpu,
1023  prog_config_opts.reserved_gpu_mem,
1024  prog_config_opts.num_reader_threads,
1025  prog_config_opts.authMetadata,
1026  prog_config_opts.mapd_parameters,
1027  prog_config_opts.enable_legacy_syntax,
1028  prog_config_opts.idle_session_duration,
1029  prog_config_opts.max_session_duration,
1030  prog_config_opts.enable_runtime_udf,
1031  prog_config_opts.udf_file_name);
1032 
1033  mapd::shared_ptr<TServerSocket> serverSocket;
1034  mapd::shared_ptr<TServerSocket> httpServerSocket;
1035  if (!prog_config_opts.mapd_parameters.ssl_cert_file.empty() &&
1036  !prog_config_opts.mapd_parameters.ssl_key_file.empty()) {
1037  mapd::shared_ptr<TSSLSocketFactory> sslSocketFactory;
1038  sslSocketFactory =
1039  mapd::shared_ptr<TSSLSocketFactory>(new TSSLSocketFactory(SSLProtocol::SSLTLS));
1040  sslSocketFactory->loadCertificate(
1041  prog_config_opts.mapd_parameters.ssl_cert_file.c_str());
1042  sslSocketFactory->loadPrivateKey(
1043  prog_config_opts.mapd_parameters.ssl_key_file.c_str());
1044  sslSocketFactory->authenticate(false);
1045  sslSocketFactory->ciphers("ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH");
1046  serverSocket = mapd::shared_ptr<TServerSocket>(new TSSLServerSocket(
1047  prog_config_opts.mapd_parameters.omnisci_server_port, sslSocketFactory));
1048  httpServerSocket = mapd::shared_ptr<TServerSocket>(
1049  new TSSLServerSocket(prog_config_opts.http_port, sslSocketFactory));
1050  LOG(INFO) << " OmniSci server using encrypted connection. Cert file ["
1051  << prog_config_opts.mapd_parameters.ssl_cert_file << "], key file ["
1052  << prog_config_opts.mapd_parameters.ssl_key_file << "]";
1053  } else {
1054  LOG(INFO) << " OmniSci server using unencrypted connection";
1055  serverSocket = mapd::shared_ptr<TServerSocket>(
1056  new TServerSocket(prog_config_opts.mapd_parameters.omnisci_server_port));
1057  httpServerSocket =
1058  mapd::shared_ptr<TServerSocket>(new TServerSocket(prog_config_opts.http_port));
1059  }
1060 
1061  ScopeGuard pointer_to_thrift_guard = [] {
1062  mapd_lock_guard<mapd_shared_mutex> write_lock(g_thrift_mutex);
1064  };
1065 
1066  if (prog_config_opts.mapd_parameters.ha_group_id.empty()) {
1067  mapd::shared_ptr<TProcessor> processor(new MapDProcessor(g_mapd_handler));
1068 
1069  mapd::shared_ptr<TTransportFactory> bufTransportFactory(
1070  new TBufferedTransportFactory());
1071  mapd::shared_ptr<TProtocolFactory> bufProtocolFactory(new TBinaryProtocolFactory());
1072 
1073  mapd::shared_ptr<TServerTransport> bufServerTransport(serverSocket);
1074  TThreadedServer bufServer(
1075  processor, bufServerTransport, bufTransportFactory, bufProtocolFactory);
1076  {
1077  mapd_lock_guard<mapd_shared_mutex> write_lock(g_thrift_mutex);
1078  g_thrift_buf_server = &bufServer;
1079  }
1080 
1081  mapd::shared_ptr<TServerTransport> httpServerTransport(httpServerSocket);
1082  mapd::shared_ptr<TTransportFactory> httpTransportFactory(
1083  new THttpServerTransportFactory());
1084  mapd::shared_ptr<TProtocolFactory> httpProtocolFactory(new TJSONProtocolFactory());
1085  TThreadedServer httpServer(
1086  processor, httpServerTransport, httpTransportFactory, httpProtocolFactory);
1087  {
1088  mapd_lock_guard<mapd_shared_mutex> write_lock(g_thrift_mutex);
1089  g_thrift_http_server = &httpServer;
1090  }
1091 
1092  std::thread bufThread(start_server,
1093  std::ref(bufServer),
1094  prog_config_opts.mapd_parameters.omnisci_server_port);
1095  std::thread httpThread(
1096  start_server, std::ref(httpServer), prog_config_opts.http_port);
1097 
1098  // run warm up queries if any exists
1100  g_mapd_handler, prog_config_opts.base_path, prog_config_opts.db_query_file);
1101 
1102  bufThread.join();
1103  httpThread.join();
1104  } else { // running ha server
1105  LOG(FATAL) << "No High Availability module available, please contact OmniSci support";
1106  }
1107 
1108  g_running = false;
1109  file_delete_thread.join();
1110  heartbeat_thread.join();
1111 
1112  int signum = g_saw_signal;
1113  if (signum <= 0 || signum == SIGTERM) {
1114  return 0;
1115  } else {
1116  return signum;
1117  }
1118 };
mapd_shared_mutex g_thrift_mutex
Definition: MapDServer.cpp:72
TThreadedServer * g_thrift_buf_server
Definition: MapDServer.cpp:74
mapd::shared_ptr< MapDHandler > g_mapd_handler
Definition: MapDServer.cpp:91
#define LOG(tag)
Definition: Logger.h:182
void run_warmup_queries(mapd::shared_ptr< MapDHandler > handler, std::string base_path, std::string query_file_path)
Definition: MapDServer.cpp:176
void heartbeat()
Definition: MapDServer.cpp:923
TThreadedServer * g_thrift_http_server
Definition: MapDServer.cpp:73
void start_server(TThreadedServer &server, const int port)
Definition: MapDServer.cpp:161
void shutdown_handler()
Definition: MapDServer.cpp:94
std::atomic< int > g_saw_signal
Definition: MapDServer.cpp:70
void register_signal_handlers()
Definition: MapDServer.cpp:150
void shutdown()
Definition: Logger.cpp:294
std::atomic< bool > g_running
Definition: MapDServer.cpp:69
bool g_enable_thrift_logs
Definition: MapDServer.cpp:67
void file_delete(std::atomic< bool > &program_is_running, const unsigned int wait_interval_seconds, const std::string base_path)
Definition: File.cpp:228
+ Here is the call graph for this function:

◆ omnisci_signal_handler()

void omnisci_signal_handler ( int  signum)

Definition at line 117 of file MapDServer.cpp.

References g_running, g_saw_signal, and register_signal_handler().

Referenced by register_signal_handlers().

117  {
118  // Record the signal number for logging during shutdown.
119  // Only records the first signal if called more than once.
120  int expected_signal{-1};
121  if (!g_saw_signal.compare_exchange_strong(expected_signal, signum)) {
122  return; // this wasn't the first signal
123  }
124 
125  // This point should never be reached more than once.
126 
127  // Tell heartbeat() to shutdown by unsetting the 'g_running' flag.
128  // If 'g_running' is already false, this has no effect and the
129  // shutdown is already in progress.
130  g_running = false;
131 
132  // Handle core dumps specially by pausing inside this signal handler
133  // because on some systems, some signals will execute their default
134  // action immediately when and if the signal handler returns.
135  // We would like to do some emergency cleanup before core dump.
136  if (signum == SIGQUIT || signum == SIGABRT || signum == SIGSEGV || signum == SIGFPE) {
137  // Wait briefly to give heartbeat() a chance to flush the logs and
138  // do any other emergency shutdown tasks.
139  sleep(2);
140 
141  // Explicitly trigger whatever default action this signal would
142  // have done, such as terminate the process or dump core.
143  // Signals are currently blocked so this new signal will be queued
144  // until this signal handler returns.
145  register_signal_handler(signum, SIG_DFL);
146  kill(getpid(), signum);
147  }
148 }
std::atomic< int > g_saw_signal
Definition: MapDServer.cpp:70
std::atomic< bool > g_running
Definition: MapDServer.cpp:69
void register_signal_handler(int signum, void(*handler)(int))
Definition: MapDServer.cpp:100
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ register_signal_handler()

void register_signal_handler ( int  signum,
void(*)(int)  handler 
)

Definition at line 100 of file MapDServer.cpp.

Referenced by main(), omnisci_signal_handler(), QueryRunner::QueryRunner::QueryRunner(), and register_signal_handlers().

100  {
101  struct sigaction act;
102  memset(&act, 0, sizeof(act));
103  if (handler != SIG_DFL && handler != SIG_IGN) {
104  // block all signal deliveries while inside the signal handler
105  sigfillset(&act.sa_mask);
106  }
107  act.sa_handler = handler;
108  sigaction(signum, &act, NULL);
109 }
+ Here is the caller graph for this function:

◆ register_signal_handlers()

void register_signal_handlers ( )

Definition at line 150 of file MapDServer.cpp.

References omnisci_signal_handler(), and register_signal_handler().

Referenced by main().

150  {
157  // Thrift secure socket can cause problems with SIGPIPE
158  register_signal_handler(SIGPIPE, SIG_IGN);
159 }
void register_signal_handler(int signum, void(*handler)(int))
Definition: MapDServer.cpp:100
void omnisci_signal_handler(int signum)
Definition: MapDServer.cpp:117
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ releaseWarmupSession()

void releaseWarmupSession ( TSessionId &  sessionId,
std::ifstream &  query_file 
)

Definition at line 169 of file MapDServer.cpp.

References g_warmup_handler.

Referenced by run_warmup_queries().

169  {
170  query_file.close();
171  if (sessionId != g_warmup_handler->getInvalidSessionId()) {
172  g_warmup_handler->disconnect(sessionId);
173  }
174 }
mapd::shared_ptr< MapDHandler > g_warmup_handler
Definition: MapDServer.cpp:88
+ Here is the caller graph for this function:

◆ run_warmup_queries()

void run_warmup_queries ( mapd::shared_ptr< MapDHandler handler,
std::string  base_path,
std::string  query_file_path 
)

Definition at line 176 of file MapDServer.cpp.

References g_warmup_handler, logger::INFO, LOG, releaseWarmupSession(), anonymous_namespace{DBObjectPrivilegesTest.cpp}::user, and logger::WARNING.

Referenced by main().

178  {
179  // run warmup queries to load cache if requested
180  if (query_file_path.empty()) {
181  return;
182  }
183  LOG(INFO) << "Running DB warmup with queries from " << query_file_path;
184  try {
185  g_warmup_handler = handler;
186  std::string db_info;
187  std::string user_keyword, user_name, db_name;
188  std::ifstream query_file;
191  TSessionId sessionId = g_warmup_handler->getInvalidSessionId();
192 
193  ScopeGuard session_guard = [&] { releaseWarmupSession(sessionId, query_file); };
194  query_file.open(query_file_path);
195  while (std::getline(query_file, db_info)) {
196  if (db_info.length() == 0) {
197  continue;
198  }
199  std::istringstream iss(db_info);
200  iss >> user_keyword >> user_name >> db_name;
201  if (user_keyword.compare(0, 4, "USER") == 0) {
202  // connect to DB for given user_name/db_name with super_user_rights (without
203  // password), & start session
204  g_warmup_handler->super_user_rights_ = true;
205  g_warmup_handler->connect(sessionId, user_name, "", db_name);
206  g_warmup_handler->super_user_rights_ = false;
207 
208  // read and run one query at a time for the DB with the setup connection
209  TQueryResult ret;
210  std::string single_query;
211  while (std::getline(query_file, single_query)) {
212  if (single_query.length() == 0) {
213  continue;
214  }
215  if (single_query.compare("}") == 0) {
216  single_query.clear();
217  break;
218  }
219  g_warmup_handler->sql_execute(ret, sessionId, single_query, true, "", -1, -1);
220  single_query.clear();
221  }
222 
223  // stop session and disconnect from the DB
224  g_warmup_handler->disconnect(sessionId);
225  sessionId = g_warmup_handler->getInvalidSessionId();
226  } else {
227  LOG(WARNING) << "\nSyntax error in the file: " << query_file_path.c_str()
228  << " Missing expected keyword USER. Following line will be ignored: "
229  << db_info.c_str() << std::endl;
230  }
231  db_info.clear();
232  }
233  } catch (...) {
234  LOG(WARNING) << "Exception while executing warmup queries. "
235  << "Warmup may not be fully completed. Will proceed nevertheless."
236  << std::endl;
237  }
238 }
#define LOG(tag)
Definition: Logger.h:182
void releaseWarmupSession(TSessionId &sessionId, std::ifstream &query_file)
Definition: MapDServer.cpp:169
mapd::shared_ptr< MapDHandler > g_warmup_handler
Definition: MapDServer.cpp:88
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ shutdown_handler()

void shutdown_handler ( )

Definition at line 94 of file MapDServer.cpp.

References g_mapd_handler, and g_shutdown_once_flag.

Referenced by main().

94  {
95  if (g_mapd_handler) {
96  std::call_once(g_shutdown_once_flag, []() { g_mapd_handler->shutdown(); });
97  }
98 }
mapd::shared_ptr< MapDHandler > g_mapd_handler
Definition: MapDServer.cpp:91
std::once_flag g_shutdown_once_flag
Definition: MapDServer.cpp:92
+ Here is the caller graph for this function:

◆ start_server()

void start_server ( TThreadedServer &  server,
const int  port 
)

Definition at line 161 of file MapDServer.cpp.

References logger::ERROR, and LOG.

Referenced by main().

161  {
162  try {
163  server.serve();
164  } catch (std::exception& e) {
165  LOG(ERROR) << "Exception: " << e.what() << ": port " << port << std::endl;
166  }
167 }
#define LOG(tag)
Definition: Logger.h:182
+ Here is the caller graph for this function:

◆ table_generations_from_thrift()

TableGenerations table_generations_from_thrift ( const std::vector< TTableGeneration > &  thrift_table_generations)

Definition at line 76 of file MapDServer.cpp.

References TableGenerations::setGeneration().

Referenced by target_meta_infos_from_thrift().

77  {
78  TableGenerations table_generations;
79  for (const auto& thrift_table_generation : thrift_table_generations) {
80  table_generations.setGeneration(
81  thrift_table_generation.table_id,
82  TableGeneration{static_cast<size_t>(thrift_table_generation.tuple_count),
83  static_cast<size_t>(thrift_table_generation.start_rowid)});
84  }
85  return table_generations;
86 }
void setGeneration(const uint32_t id, const TableGeneration &generation)
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

Variable Documentation

◆ connect_timeout

unsigned connect_timeout {20000}

Definition at line 56 of file MapDServer.cpp.

Referenced by ThriftClientConnection::ThriftClientConnection().

◆ g_cache_string_hash

bool g_cache_string_hash

◆ g_enable_bump_allocator

bool g_enable_bump_allocator

Definition at line 96 of file Execute.cpp.

Referenced by MapDProgramOptions::fillAdvancedOptions().

◆ g_enable_thrift_logs

bool g_enable_thrift_logs {false}

Definition at line 67 of file MapDServer.cpp.

Referenced by MapDProgramOptions::fillOptions(), and main().

◆ g_leaf_count

size_t g_leaf_count

Definition at line 63 of file ParserNode.cpp.

◆ g_mapd_handler

mapd::shared_ptr<MapDHandler> g_mapd_handler = 0

Definition at line 91 of file MapDServer.cpp.

Referenced by heartbeat(), main(), and shutdown_handler().

◆ g_max_memory_allocation_size

size_t g_max_memory_allocation_size

◆ g_min_memory_allocation_size

size_t g_min_memory_allocation_size

Definition at line 93 of file Execute.cpp.

Referenced by MapDProgramOptions::fillAdvancedOptions().

◆ g_running

std::atomic<bool> g_running {true}

Definition at line 69 of file MapDServer.cpp.

Referenced by heartbeat(), main(), and omnisci_signal_handler().

◆ g_saw_signal

std::atomic<int> g_saw_signal {-1}

Definition at line 70 of file MapDServer.cpp.

Referenced by heartbeat(), main(), and omnisci_signal_handler().

◆ g_shutdown_once_flag

std::once_flag g_shutdown_once_flag

Definition at line 92 of file MapDServer.cpp.

Referenced by heartbeat(), and shutdown_handler().

◆ g_skip_intermediate_count

bool g_skip_intermediate_count

Definition at line 41 of file RelAlgExecutor.cpp.

Referenced by MapDProgramOptions::fillAdvancedOptions().

◆ g_thrift_buf_server

TThreadedServer* g_thrift_buf_server {nullptr}

Definition at line 74 of file MapDServer.cpp.

Referenced by heartbeat(), and main().

◆ g_thrift_http_server

TThreadedServer* g_thrift_http_server {nullptr}

Definition at line 73 of file MapDServer.cpp.

Referenced by heartbeat(), and main().

◆ g_thrift_mutex

mapd_shared_mutex g_thrift_mutex

Definition at line 72 of file MapDServer.cpp.

Referenced by heartbeat(), and main().

◆ g_warmup_handler

mapd::shared_ptr<MapDHandler> g_warmup_handler
Initial value:
=
0

Definition at line 88 of file MapDServer.cpp.

Referenced by releaseWarmupSession(), and run_warmup_queries().

◆ recv_timeout

unsigned recv_timeout {300000}

Definition at line 57 of file MapDServer.cpp.

◆ send_timeout

unsigned send_timeout {300000}

Definition at line 58 of file MapDServer.cpp.

Referenced by ThriftClientConnection::ThriftClientConnection().