foedus::EngineOptions Struct Reference

Set of option values given to the engine at start-up. More...

Detailed Description

Set of option values given to the engine at start-up.

This object is a collection of engine-wide settings and settings for individual modules (XxxOptions). To configure options, instantiate this class then modify values in each sub-module's options. When you start-up the database engine, you have to provide this object.

Instantiating EngineOptions object

To instantiate an EngineOptions object, simply call the default constructor like:

EngineOptions options;

This sets default values to all settings. See each module's option classes for the description of their default values.

Externalization: Loading and Saving config values.

You can save and load this object to an XML file:

EngineOptions options;
... (change something in options)
if (options.save_to_file("/your/path/to/foedus_config.xml").is_error()) {
   // handle errors. It might be file permission issue or other file I/O issues.
}

.... (after doing something else, possibly after restarting the program)
.... (or, maybe the user has edited the config file on text editor)
if (options.load_from_file("/your/path/to/foedus_config.xml").is_error()) {
   // handle errors. It might be file permission, corrupted XML files, etc.
}

Definition at line 75 of file engine_options.hpp.

#include <engine_options.hpp>

Inheritance diagram for foedus::EngineOptions:

Collaboration diagram for foedus::EngineOptions:

Public Member Functions
	EngineOptions ()
	Constructs option values with default values. More...
	EngineOptions (const EngineOptions &other)
EngineOptions &	operator= (const EngineOptions &other)
void	calculate_required_memory (uint64_t *shared_bytes, uint64_t *local_bytes) const
ErrorStack	prescreen (std::ostream *details_out) const
	Checks the machine environment and raises as many errors as possible before the engine starts up. More...
void	prescreen_ulimits (uint64_t required_total_safe_bytes, bool *has_any_error, std::ostream *details_out) const
	Subroutine of prescreen to check ulimit values. More...
void	prescreen_sysctl (uint64_t required_shared_safe_bytes, bool *has_any_error, std::ostream *details_out) const
	Subroutine of prescreen to check sysctl values. More...
ErrorStack	load (tinyxml2::XMLElement *element) override
	Reads the content of this object from the given XML element. More...
ErrorStack	save (tinyxml2::XMLElement *element) const override
	Writes the content of this object to the given XML element. More...
const char *	get_tag_name () const override
	Returns an XML tag name for this object as a root element. More...
void	assign (const foedus::externalize::Externalizable *other) override
	Polymorphic assign operator. More...
Public Member Functions inherited from foedus::externalize::Externalizable
ErrorStack	load_from_string (const std::string &xml)
	Load the content of this object from the given XML string. More...
void	save_to_stream (std::ostream *ptr) const
	Invokes save() and directs the resulting XML text to the given stream. More...
ErrorStack	load_from_file (const fs::Path &path)
	Load the content of this object from the specified XML file. More...
ErrorStack	save_to_file (const fs::Path &path) const
	Atomically and durably writes out this object to the specified XML file. More...

Static Public Member Functions
static uint64_t	read_int_from_proc_fs (const char *path, std::ostream *details_out)
	A utility method to read /proc/ value in linux. More...
static uint64_t	get_available_hugepage_memory (std::ostream *details_out)
	A utility method to check how much hugepage memory is currently available. More...
Static Public Member Functions inherited from foedus::externalize::Externalizable
static ErrorStack	insert_comment (tinyxml2::XMLElement *element, const std::string &comment)
static ErrorStack	append_comment (tinyxml2::XMLElement *parent, const std::string &comment)
static ErrorStack	create_element (tinyxml2::XMLElement *parent, const std::string &name, tinyxml2::XMLElement **out)
template<typename T >
static ErrorStack	add_element (tinyxml2::XMLElement *parent, const std::string &tag, const std::string &comment, T value)
	Only declaration in header. More...
template<uint MAXLEN, typename CHAR >
static ErrorStack	add_element (tinyxml2::XMLElement *parent, const std::string &tag, const std::string &comment, const assorted::FixedString< MAXLEN, CHAR > &value)
template<typename T >
static ErrorStack	add_element (tinyxml2::XMLElement *parent, const std::string &tag, const std::string &comment, const std::vector< T > &value)
	vector version More...
template<typename ENUM >
static ErrorStack	add_enum_element (tinyxml2::XMLElement *parent, const std::string &tag, const std::string &comment, ENUM value)
	enum version More...
static ErrorStack	add_child_element (tinyxml2::XMLElement *parent, const std::string &tag, const std::string &comment, const Externalizable &child)
	child Externalizable version More...
template<typename T >
static ErrorStack	get_element (tinyxml2::XMLElement *parent, const std::string &tag, T *out, bool optional=false, T value=0)
	Only declaration in header. More...
static ErrorStack	get_element (tinyxml2::XMLElement *parent, const std::string &tag, std::string *out, bool optional=false, const char *value="")
	string type is bit special. More...
template<uint MAXLEN, typename CHAR >
static ErrorStack	get_element (tinyxml2::XMLElement *parent, const std::string &tag, assorted::FixedString< MAXLEN, CHAR > *out, bool optional=false, const assorted::FixedString< MAXLEN, CHAR > &value=assorted::FixedString< MAXLEN, CHAR >())
template<typename ENUM >
static ErrorStack	get_enum_element (tinyxml2::XMLElement *parent, const std::string &tag, ENUM *out, bool optional=false, ENUM default_value=static_cast< ENUM >(0))
	enum version More...
template<typename T >
static ErrorStack	get_element (tinyxml2::XMLElement *parent, const std::string &tag, std::vector< T > *out, bool optional=false)
	vector version. More...
static ErrorStack	get_child_element (tinyxml2::XMLElement *parent, const std::string &tag, Externalizable *child, bool optional=false)
	child Externalizable version More...

Public Attributes
cache::CacheOptions	cache_
debugging::DebuggingOptions	debugging_
log::LogOptions	log_
memory::MemoryOptions	memory_
proc::ProcOptions	proc_
restart::RestartOptions	restart_
savepoint::SavepointOptions	savepoint_
snapshot::SnapshotOptions	snapshot_
soc::SocOptions	soc_
storage::StorageOptions	storage_
thread::ThreadOptions	thread_
xct::XctOptions	xct_

Friends
std::ostream &	operator<< (std::ostream &o, const EngineOptions &v)

Constructor & Destructor Documentation

foedus::EngineOptions::EngineOptions

(

)

Constructs option values with default values.

Definition at line 38 of file engine_options.cpp.

Referenced by load().

                             {
}

Here is the caller graph for this function:

foedus::EngineOptions::EngineOptions

(

const EngineOptions &

other

)

Definition at line 40 of file engine_options.cpp.

References operator=().

                                                       {
  operator=(other);
}

Here is the call graph for this function:

Member Function Documentation

void foedus::EngineOptions::assign ( const foedus::externalize::Externalizable *  other )

inlineoverridevirtual

Polymorphic assign operator.

This should invoke operator= of the derived class.

Parameters

[in]

other

assigned value. It must be dynamic-castable to the assignee class.

Implements foedus::externalize::Externalizable.

Definition at line 149 of file engine_options.hpp.

void foedus::EngineOptions::calculate_required_memory	(	uint64_t *	shared_bytes,
		uint64_t *	local_bytes
	)		const

Parameters

[out]	shared_bytes	Byte size of shared hugepage memory the engine will consume when an engine starts up with these option values.
[out]	local_bytes	Byte size of node-local hugepage memory the engine will consume when an engine starts up with these option values.

Definition at line 341 of file engine_options.cpp.

References cache_, foedus::soc::SharedMemoryRepo::calculate_global_memory_size(), foedus::memory::NumaCoreMemory::calculate_local_small_memory_size(), foedus::soc::SharedMemoryRepo::calculate_node_memory_size(), foedus::thread::ThreadOptions::get_total_thread_count(), foedus::thread::ThreadOptions::group_count_, foedus::xct::XctOptions::local_work_memory_size_mb_, log_, foedus::log::LogOptions::log_buffer_kb_, foedus::log::LogOptions::loggers_per_node_, memory_, foedus::memory::MemoryOptions::page_pool_size_mb_per_node_, foedus::cache::CacheOptions::snapshot_cache_size_mb_per_node_, thread_, and xct_.

Referenced by prescreen().

                               {
  const uint32_t nodes = thread_.group_count_;
  const uint32_t total_threads = thread_.get_total_thread_count();

  // First, shared memories. soc::SharedMemoryRepo has exact methods for that.
  *shared_bytes = 0;

  // No idea how big the XML representation would be, but surely within 4MB.
  uint64_t kMaxXmlSize = 1ULL << 22;
  *shared_bytes += soc::SharedMemoryRepo::calculate_global_memory_size(kMaxXmlSize, *this);
  *shared_bytes += soc::SharedMemoryRepo::calculate_node_memory_size(*this) * nodes;
  *shared_bytes += (static_cast<uint64_t>(memory_.page_pool_size_mb_per_node_) << 20) * nodes;

  // Then, local memories, which are allocated in various places, so
  // we need to list up each of them.. maybe missing something.
  *local_bytes = 0;

  // snapshot cache pool
  *local_bytes += cache_.snapshot_cache_size_mb_per_node_ * (1ULL << 20) * nodes;

  // logger buffer
  *local_bytes += log_.log_buffer_kb_ * (1ULL << 10) * log_.loggers_per_node_ * nodes;

  // misc memory in NumaNodeMemory. for volatile pool and snapshot cache pool
  *local_bytes += sizeof(memory::PagePoolOffsetChunk) * 2ULL * total_threads * 2;

  // core-local memories in NumaCoreMemory. work_memory and "small_memory" (terrible name, yes)
  *local_bytes += xct_.local_work_memory_size_mb_ * (1ULL << 20) * total_threads;
  *local_bytes += memory::NumaCoreMemory::calculate_local_small_memory_size(*this) * total_threads;
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint64_t foedus::EngineOptions::get_available_hugepage_memory ( std::ostream *  details_out )

static

A utility method to check how much hugepage memory is currently available.

Returns byte size of available memory backed by non-transparent hugepages.

Parameters

[out]

details_out

if there is any concern, we output some message to this stream.

Returns

byte size of available memory backed by non-transparent hugepages.

Definition at line 96 of file engine_options.cpp.

References ASSERT_ND.

Referenced by prescreen().

                                                                             {
  std::ifstream file("/proc/meminfo");
  if (!file.is_open()) {
    *details_out << "[FOEDUS] Failed to open /proc/meminfo. Cannot check available hugepages."
      << std::endl;
    return 0;
  }

  std::string line;
  uint64_t hugepage_size = 1ULL << 21;
  uint64_t hugepage_count = 0;
  while (std::getline(file, line)) {
    if (line.find("Hugepagesize:") != std::string::npos) {
      // /proc/meminfo should have "Hugepagesize:    1048576 kB" for 1GB hugepages
      if (line.find("1048576 kB") != std::string::npos) {
        hugepage_size = 1ULL << 30;
      } else {
        ASSERT_ND(line.find("2048 kB") != std::string::npos);
      }
    } else if (line.find("HugePages_Free:") != std::string::npos) {
      ASSERT_ND(hugepage_count == 0);
      // And "HugePages_Free:    12345" for the number of available hugepages.
      std::string pages_str = line.substr(std::string("HugePages_Free:").length());
      hugepage_count = std::stoull(pages_str);
    }
  }
  file.close();
  return hugepage_count * hugepage_size;
}

Here is the caller graph for this function:

const char* foedus::EngineOptions::get_tag_name ( ) const

inlineoverridevirtual

Returns an XML tag name for this object as a root element.

We might want to give a different name for same externalizable objects, so this is used only when it is the root element of xml.

Implements foedus::externalize::Externalizable.

Definition at line 149 of file engine_options.hpp.

ErrorStack foedus::EngineOptions::load ( tinyxml2::XMLElement *  element )

overridevirtual

Reads the content of this object from the given XML element.

Parameters

[in]

element

the XML element that represents this object

Expect errors due to missing-elements, out-of-range values, etc.

Implements foedus::externalize::Externalizable.

Definition at line 79 of file engine_options.cpp.

References CHECK_ERROR, EngineOptions(), foedus::externalize::Externalizable::get_child_element(), foedus::get_children(), and foedus::kRetOk.

                                                          {
  *this = EngineOptions();  // This guarantees default values for optional XML elements.
  for (externalize::Externalizable* child : get_children(this)) {
    CHECK_ERROR(get_child_element(element, child->get_tag_name(), child));
  }
  return kRetOk;
}

Here is the call graph for this function:

EngineOptions & foedus::EngineOptions::operator=

(

const EngineOptions &

other

)

Definition at line 69 of file engine_options.cpp.

References ASSERT_ND, and foedus::get_children().

Referenced by EngineOptions().

                                                                  {
  auto mine = get_children(this);
  auto others = get_children(&other);
  ASSERT_ND(mine.size() == others.size());
  for (size_t i = 0; i < mine.size(); ++i) {
    mine[i]->assign(others[i]);
  }
  return *this;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorStack foedus::EngineOptions::prescreen

(

std::ostream *

details_out

)

const

Checks the machine environment and raises as many errors as possible before the engine starts up.

Parameters

[out]

details_out

We write out detailed messages (more like a documentation to help users configure linux) to this stream, not to glog, because glog might not be initialized at this point.

There are several linux configurations the user must get right. Some, not all, of misconfigurations can be detected beforehand by checking the machine configuration and values of EngineOptions. This method has no side-effect. It just checks the environment.

Attention

This method can NOT detect all errors. For example, even if the number of hugepages is apparantely sufficient at this point but other processes might consume all of them by the time this engine allocates memory. Still, this method is supposed to catch 99% of mis-configurations beforehand.

Definition at line 126 of file engine_options.cpp.

References ASSERT_ND, calculate_required_memory(), ERROR_STACK_MSG, get_available_hugepage_memory(), foedus::assorted::int_div_ceil(), foedus::kErrorCodeEnvPrescreenFailed, foedus::kRetOk, memory_, prescreen_sysctl(), prescreen_ulimits(), foedus::memory::MemoryOptions::rigorous_page_boundary_check_, and foedus::memory::MemoryOptions::suppress_memory_prescreening_.

Referenced by foedus::EnginePimpl::check_valid_options().

                                                                 {
  ASSERT_ND(details_out);
  std::stringstream out_buffer;
  const uint64_t kMarginRatio = 4;  // Add 1/4 to be safe

  // we don't stop prescreening on individual errors so that
  // the user can see all issues at once.
  bool has_any_error = false;

  if (RUNNING_ON_VALGRIND && memory_.rigorous_page_boundary_check_) {
    out_buffer
      << "[FOEDUS] WARNING. We strongly discourage rigorous_page_boundary_check_ on valgrind."
      << " If you are sure what you are doing, consider increasing VG_N_SEGMENTS and recompile"
      << " valgrind."
      << std::endl;
  }

  // Check available hugepages
  uint64_t available_hugepage_bytes = get_available_hugepage_memory(&out_buffer);
  uint64_t required_shared_bytes;
  uint64_t required_local_bytes;
  calculate_required_memory(&required_shared_bytes, &required_local_bytes);

  uint64_t required_total_bytes = required_shared_bytes + required_local_bytes;
  uint64_t required_total_safe_bytes = required_total_bytes + required_total_bytes / kMarginRatio;
  if (available_hugepage_bytes < required_total_safe_bytes) {
    has_any_error = true;

    out_buffer
      << "[FOEDUS] There are not enough hugepages available."
      << " Based on the values in EngineOptions, the machine should have at least "
      << required_total_safe_bytes << " bytes ("
      << assorted::int_div_ceil(required_total_safe_bytes, 1ULL << 21) << " 2MB pages, or "
      << assorted::int_div_ceil(required_total_safe_bytes, 1ULL << 30) << " 1GB pages)"
      << " of hugepages, but there are only " << available_hugepage_bytes << " bytes available."
      << " eg: sudo sh -c 'echo xyz > /proc/sys/vm/nr_hugepages' "
      << std::endl;
  }

  // Check ulimit values
  prescreen_ulimits(required_total_safe_bytes, &has_any_error, &out_buffer);

  // Check sysctl values
  uint64_t required_shared_safe_bytes
    = required_shared_bytes + required_shared_bytes / kMarginRatio;
  prescreen_sysctl(required_shared_safe_bytes, &has_any_error, &out_buffer);

  std::string error_messages = out_buffer.str();
  *details_out << error_messages;

  if (has_any_error) {
    if (memory_.suppress_memory_prescreening_) {
      *details_out
        << "**********************************************************" << std::endl
        << "**** ENVIRONMENT PRESCREENING DETECTED SOME ISSUES." << std::endl
        << "**** HOWEVER, suppress_memory_prescreening option was specified." << std::endl
        << "**** FOEDUS will start up." << std::endl
        << "**********************************************************" << std::endl;
      return kRetOk;
    } else {
      *details_out
        << "**********************************************************" << std::endl
        << "**** ENVIRONMENT PRESCREENING FAILED." << std::endl
        << "**** FOEDUS does not start up because of issues listed above." << std::endl
        << "**********************************************************" << std::endl;
      return ERROR_STACK_MSG(kErrorCodeEnvPrescreenFailed, error_messages.c_str());
    }
  } else {
    return kRetOk;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void foedus::EngineOptions::prescreen_sysctl	(	uint64_t	required_shared_safe_bytes,
		bool *	has_any_error,
		std::ostream *	details_out
	)		const

Subroutine of prescreen to check sysctl values.

Definition at line 269 of file engine_options.cpp.

References read_int_from_proc_fs().

Referenced by prescreen().

                                 {
  uint64_t shmall = read_int_from_proc_fs("/proc/sys/kernel/shmall", details_out);
  if (shmall < required_shared_safe_bytes) {
    *has_any_error = true;

    *details_out
      << "[FOEDUS] /proc/sys/kernel/shmall is too small (" << shmall << ".)"
      << " It must be at least " << required_shared_safe_bytes
      << ". We recommend to simply set semi-inifinite value: "
      << " sudo sysctl -w kernel.shmall=1152921504606846720"
      << " and adding an entry 'kernel.shmall = 1152921504606846720' to /etc/sysctl.conf"
      << " then sudo sysctl -p"
      << std::endl;
  }

  uint64_t shmmax = read_int_from_proc_fs("/proc/sys/kernel/shmmax", details_out);
  if (shmmax < required_shared_safe_bytes) {
    *has_any_error = true;

    *details_out
      << "[FOEDUS] /proc/sys/kernel/shmmax is too small(" << shmmax << ")."
      << " It must be at least " << required_shared_safe_bytes
      << ". We recommend to simply set semi-inifinite value: "
      << " sudo sysctl -w kernel.shmmax=9223372036854775807"
      << " and adding an entry 'kernel.shmmax = 9223372036854775807' to /etc/sysctl.conf"
      << " then sudo sysctl -p"
      << std::endl;
  }

  uint64_t shmmni = read_int_from_proc_fs("/proc/sys/kernel/shmmni", details_out);
  const uint64_t kMinShmmni = 4096;
  if (shmmni < kMinShmmni) {
    *has_any_error = true;

    *details_out
      << "[FOEDUS] /proc/sys/kernel/shmmni is too small(" << shmmni << ")."
      << " It must be at least " << kMinShmmni
      << ". We recommend to set : "
      << " sudo sysctl -w kernel.shmmni=" << kMinShmmni
      << " and adding an entry 'kernel.shmmni = " << kMinShmmni << "' to /etc/sysctl.conf"
      << " then sudo sysctl -p"
      << std::endl;
  }

  uint64_t shm_group = read_int_from_proc_fs("/proc/sys/vm/hugetlb_shm_group", details_out);
  // This one is not an error. It works in some environment even without this parameter.
  // So, we only warn about it so far. Also, we don't even check if the user is in this group.
  if (shm_group == 0) {
    *details_out
      << "[FOEDUS] Warning: /proc/sys/vm/hugetlb_shm_group is not set."
      << " In some environment, this is fine: FOEDUS can allocate shared memory backed by hugepages"
      << " without configuring it, but some environment might fail without it"
      << std::endl;
  }

  uint64_t map_count = read_int_from_proc_fs("/proc/sys/vm/max_map_count", details_out);
  if (map_count <= 65530U) {
    *details_out
      << "[FOEDUS] /proc/sys/vm/max_map_count is only " << map_count
      << " When rigorous_memory_boundary_check or rigorous_page_boundary_check features"
      << " are specified, you must set a large number to it."
      << ". We recommend to set : "
      << " sudo sysctl -w vm.max_map_count=2147483647"
      << " and adding an entry 'vm.max_map_count=2147483647' to /etc/sysctl.conf"
      << " then sudo sysctl -p"
      << std::endl;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void foedus::EngineOptions::prescreen_ulimits	(	uint64_t	required_total_safe_bytes,
		bool *	has_any_error,
		std::ostream *	details_out
	)		const

Subroutine of prescreen to check ulimit values.

Definition at line 198 of file engine_options.cpp.

References foedus::thread::ThreadOptions::get_total_thread_count(), and thread_.

Referenced by prescreen().

                                 {
  // nofile (number of file/socket that can be opened)
  ::rlimit nofile_limit;
  ::getrlimit(RLIMIT_NOFILE, &nofile_limit);
  const uint64_t kMinNoFile = std::max(1U << 13, thread_.get_total_thread_count() * 16U);
  if (nofile_limit.rlim_cur < kMinNoFile) {
    *has_any_error = true;

    *details_out
      << "[FOEDUS] ulimit -n is too small (" << nofile_limit.rlim_cur
      << "). You must have at least " << kMinNoFile << std::endl;
  }
  // Record of a struggle: WTF,, no idea why, but I'm seeing an weird behavior only on Ubuntu.
  // I did set limits.conf, and ulimit -n is saying 100000, but the above code returns "8192"
  // on Ubuntu. As a tentative solution, reduced the min value to 8192.
  // This happens only when I run the code as jenkins user from jenkins service.
  // If I run it as myself, or "sudo su jenkins" then run it, it runs fine. WWWTTTTFFF.

  // 2015 Jun: Ahhh, I got it. It's because jenkins service is started by a daemon script:
  // http://blog.mindfab.net/2013/12/changing-ulimits-for-jenkins-daemons.html
  //  "The important part is that you have to specify the ulimits, e.g., for the number
  //   of open files before start-stop-daemon is called. The reason is that
  //   **start-stop-daemon doesn't consider pam**
  //   and hence will not find the limits which have been specified in /etc/security/limits.conf."

  // Note that proc means threads in linux.
  ::rlimit proc_limit;
  ::getrlimit(RLIMIT_NPROC, &proc_limit);
  const uint64_t kMinProc = std::max(1U << 12, thread_.get_total_thread_count() * 2U);
  if (proc_limit.rlim_cur < kMinProc) {
    *has_any_error = true;

    *details_out
      << "[FOEDUS] ulimit -u is too small(" << proc_limit.rlim_cur
      << "). You must have at least " << kMinProc << std::endl;
  }

  // memlock
  ::rlimit memlock_limit;
  ::getrlimit(RLIMIT_MEMLOCK, &memlock_limit);
  if (memlock_limit.rlim_cur * (1ULL << 10) < required_total_safe_bytes) {
    *has_any_error = true;

    *details_out
      << "[FOEDUS] ulimit -l is too small(" << memlock_limit.rlim_cur
      << "). You must have at least "
      << (required_total_safe_bytes >> 10) << std::endl;
  }

  // Should also check: RLIMIT_AS, RLIMIT_DATA, RLIMIT_FSIZE, RLIMIT_LOCKS
  // but it's rarely an issue in typical setup.
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint64_t foedus::EngineOptions::read_int_from_proc_fs ( const char *  path, std::ostream *  details_out  )

static

A utility method to read /proc/ value in linux.

Parameters

[in]	path	file path representing a config value, eg "/proc/sys/kernel/shmall"
[out]	details_out	if there is any concern, we output some message to this stream.

Returns

an integer value stored in /proc/...

Definition at line 254 of file engine_options.cpp.

Referenced by prescreen_sysctl().

                                                                                       {
  // _sysctl() is now strongly discouraged, so let's simlpy read as a file.
  std::ifstream file(path);
  if (!file.is_open()) {
    *details_out << "[FOEDUS] Fails to read " << path;
    return 0;
  }

  std::string line;
  std::getline(file, line);
  file.close();

  return std::stoull(line);
}

Here is the caller graph for this function:

ErrorStack foedus::EngineOptions::save ( tinyxml2::XMLElement *  element ) const

overridevirtual

Writes the content of this object to the given XML element.

Parameters

[in]

element

the XML element that represents this object

Expect only out-of-memory error. We receive the XML element this object will represent, so this method does not determine the XML element name of itself. The parent object determines children's tag names because one parent object might have multiple child objects of the same type with different XML element name.

Implements foedus::externalize::Externalizable.

Definition at line 87 of file engine_options.cpp.

References foedus::externalize::Externalizable::add_child_element(), CHECK_ERROR, foedus::get_children(), foedus::externalize::Externalizable::insert_comment(), and foedus::kRetOk.

                                                                {
  CHECK_ERROR(insert_comment(element, "Set of options given to the engine at start-up"));
  for (const externalize::Externalizable* child : get_children(this)) {
    CHECK_ERROR(add_child_element(element, child->get_tag_name(), "", *child));
  }
  return kRetOk;
}

Here is the call graph for this function:

Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream &  o, const EngineOptions &  v  )

friend

Definition at line 149 of file engine_options.hpp.

Member Data Documentation

cache::CacheOptions foedus::EngineOptions::cache_

Definition at line 136 of file engine_options.hpp.

Referenced by calculate_required_memory(), foedus::thread::ThreadPimpl::find_or_read_a_snapshot_page(), foedus::thread::ThreadPimpl::find_or_read_snapshot_pages_batch(), foedus::cache::CacheManagerPimpl::initialize_once(), foedus::memory::NumaNodeMemory::initialize_once(), and foedus::thread::ThreadPimpl::initialize_once().

debugging::DebuggingOptions foedus::EngineOptions::debugging_

Definition at line 137 of file engine_options.hpp.

log::LogOptions foedus::EngineOptions::log_

Definition at line 138 of file engine_options.hpp.

Referenced by foedus::soc::NodeMemoryAnchors::allocate_arrays(), foedus::snapshot::calculate_logger_id(), foedus::soc::SharedMemoryRepo::calculate_node_memory_size(), calculate_required_memory(), foedus::snapshot::LogMapper::handle_process(), foedus::log::MetaLogger::initialize_once(), foedus::log::LogManagerPimpl::initialize_once(), foedus::savepoint::SavepointManagerPimpl::initialize_once(), foedus::log::Logger::initialize_once(), foedus::snapshot::SnapshotManagerPimpl::initialize_once(), foedus::xct::XctManagerPimpl::precommit_xct_readwrite(), foedus::restart::RestartManagerPimpl::redo_meta_logs(), foedus::savepoint::SavepointManagerPimpl::update_shared_savepoint(), and foedus::log::ThreadLogBuffer::wait_for_space().

memory::MemoryOptions foedus::EngineOptions::memory_

Definition at line 139 of file engine_options.hpp.

Referenced by foedus::memory::NumaNodeMemory::allocate_numa_memory_general(), foedus::soc::SharedMemoryRepo::allocate_shared_memories(), foedus::soc::SharedMemoryRepo::attach_shared_memories(), foedus::soc::SharedMemoryRepo::calculate_node_memory_size(), calculate_required_memory(), foedus::cache::CacheManagerPimpl::initialize_once(), foedus::memory::NumaNodeMemory::initialize_once(), foedus::memory::NumaCoreMemory::initialize_once(), foedus::memory::NumaNodeMemoryRef::NumaNodeMemoryRef(), and prescreen().

proc::ProcOptions foedus::EngineOptions::proc_

Definition at line 140 of file engine_options.hpp.

Referenced by foedus::soc::SharedMemoryRepo::calculate_node_memory_size().

restart::RestartOptions foedus::EngineOptions::restart_

Definition at line 141 of file engine_options.hpp.

savepoint::SavepointOptions foedus::EngineOptions::savepoint_

Definition at line 142 of file engine_options.hpp.

Referenced by foedus::savepoint::SavepointManagerPimpl::initialize_once().

snapshot::SnapshotOptions foedus::EngineOptions::snapshot_

Definition at line 143 of file engine_options.hpp.

Referenced by foedus::snapshot::LogReducerRef::append_log_chunk(), foedus::soc::SharedMemoryRepo::calculate_node_memory_size(), foedus::snapshot::LogReducerRef::get_buffer_size(), foedus::snapshot::SnapshotManagerPimpl::get_option(), foedus::cache::SnapshotFileSet::get_or_open_file(), foedus::snapshot::LogMapper::handle_process(), foedus::snapshot::LogMapper::initialize_once(), foedus::snapshot::LogReducer::initialize_once(), foedus::snapshot::LogReducer::LogReducer(), and foedus::snapshot::SnapshotWriter::open().

soc::SocOptions foedus::EngineOptions::soc_

Definition at line 144 of file engine_options.hpp.

Referenced by foedus::soc::SharedMemoryRepo::calculate_global_memory_size(), foedus::proc::ProcManagerPimpl::emulated_register(), foedus::soc::SocManager::get_shared_user_memory_size(), foedus::soc::SocManagerPimpl::initialize_master(), foedus::soc::SocManagerPimpl::launch_spawned_children(), foedus::proc::ProcManagerPimpl::pre_register(), foedus::soc::SocManagerPimpl::wait_for_child_attach(), foedus::soc::SocManagerPimpl::wait_for_child_terminate(), and foedus::soc::SocManagerPimpl::wait_for_children_module().

storage::StorageOptions foedus::EngineOptions::storage_

Definition at line 145 of file engine_options.hpp.

Referenced by foedus::soc::SharedMemoryRepo::calculate_global_memory_size(), foedus::soc::SharedMemoryRepo::calculate_node_memory_size(), foedus::storage::hash::HashStoragePimpl::create(), foedus::storage::StorageManagerPimpl::get_max_storages(), foedus::thread::ThreadPimpl::handle_tasks(), foedus::xct::Xct::initialize(), foedus::snapshot::SnapshotManagerPimpl::initialize_once(), foedus::storage::PartitionerMetadata::locate_data(), and foedus::snapshot::SnapshotManagerPimpl::uninitialize_once().

thread::ThreadOptions foedus::EngineOptions::thread_

Definition at line 146 of file engine_options.hpp.

Referenced by foedus::soc::NodeMemoryAnchors::allocate_arrays(), foedus::memory::NumaCoreMemory::calculate_local_small_memory_size(), foedus::soc::SharedMemoryRepo::calculate_node_memory_size(), calculate_required_memory(), foedus::storage::array::ArrayPartitioner::design_partition(), foedus::storage::sequential::SequentialStoragePimpl::drop(), foedus::storage::sequential::SequentialComposer::drop_volatiles(), foedus::memory::EngineMemory::dump_free_memory_stat(), foedus::storage::sequential::SequentialStoragePimpl::for_every_page(), foedus::storage::sequential::SequentialStoragePimpl::get_head_pointer(), foedus::Engine::get_soc_count(), foedus::storage::sequential::SequentialStoragePimpl::get_tail_pointer(), foedus::thread::ThreadPoolPimpl::impersonate(), foedus::thread::ThreadPoolPimpl::impersonate_on_numa_node(), foedus::storage::sequential::SequentialStoragePimpl::initialize_head_tail_pages(), foedus::soc::SocManagerPimpl::initialize_master(), foedus::thread::ThreadGroup::initialize_once(), foedus::thread::ThreadPoolPimpl::initialize_once(), foedus::cache::CacheManagerPimpl::initialize_once(), foedus::memory::EngineMemory::initialize_once(), foedus::memory::NumaCoreMemory::initialize_once(), foedus::EnginePimpl::initialize_once(), foedus::proc::ProcManagerPimpl::initialize_once(), foedus::log::LogManagerPimpl::initialize_once(), foedus::savepoint::SavepointManagerPimpl::initialize_once(), foedus::snapshot::SnapshotManagerPimpl::initialize_once(), foedus::soc::SocManagerPimpl::launch_emulated_children(), foedus::soc::SocManagerPimpl::launch_forked_children(), foedus::soc::SocManagerPimpl::launch_spawned_children(), prescreen_ulimits(), foedus::thread::ThreadPimpl::set_thread_schedule(), foedus::thread::ThreadGroupRef::ThreadGroupRef(), foedus::savepoint::SavepointManagerPimpl::update_shared_savepoint(), foedus::soc::SocManagerPimpl::wait_for_child_attach(), foedus::soc::SocManagerPimpl::wait_for_child_terminate(), and foedus::soc::SocManagerPimpl::wait_for_children_module().

xct::XctOptions foedus::EngineOptions::xct_

Definition at line 147 of file engine_options.hpp.

Referenced by foedus::memory::NumaCoreMemory::calculate_local_small_memory_size(), calculate_required_memory(), foedus::xct::XctManagerPimpl::handle_epoch_chime(), foedus::thread::ThreadPimpl::handle_tasks(), foedus::xct::Xct::initialize(), foedus::memory::NumaCoreMemory::initialize_once(), foedus::thread::ThreadPimpl::initialize_once(), and foedus::xct::XctManagerPimpl::precommit_xct_lock().

---

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

• /home/shino/foedus_code/foedus-core/include/foedus/engine_options.hpp
• /home/shino/foedus_code/foedus-core/src/foedus/engine_options.cpp