engine_options.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2014-2015, Hewlett-Packard Development Company, LP.
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation; either version 2 of the License, or (at your option)
 * any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details. You should have received a copy of the GNU General Public
 * License along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 *
 * HP designates this particular file as subject to the "Classpath" exception
 * as provided by HP in the LICENSE.txt file that accompanied this code.
 */
#ifndef FOEDUS_ENGINE_OPTIONS_HPP_
#define FOEDUS_ENGINE_OPTIONS_HPP_

#include <iosfwd>

// rather than forward declarations of option classes for each module, we include them here.
// these are anyway very small header files, and demanding user code to include each of them
// won't fly. further, just holding instances, rather than pointers, makes (de)allocation simpler.
#include "foedus/cxx11.hpp"
#include "foedus/error_stack.hpp"
#include "foedus/cache/cache_options.hpp"
#include "foedus/debugging/debugging_options.hpp"
#include "foedus/externalize/externalizable.hpp"
#include "foedus/log/log_options.hpp"
#include "foedus/memory/memory_options.hpp"
#include "foedus/proc/proc_options.hpp"
#include "foedus/restart/restart_options.hpp"
#include "foedus/savepoint/savepoint_options.hpp"
#include "foedus/snapshot/snapshot_options.hpp"
#include "foedus/soc/soc_options.hpp"
#include "foedus/storage/storage_options.hpp"
#include "foedus/thread/thread_options.hpp"
#include "foedus/xct/xct_options.hpp"
namespace foedus {
struct EngineOptions CXX11_FINAL : public virtual externalize::Externalizable {
  EngineOptions();
  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;

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

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

  static uint64_t read_int_from_proc_fs(const char* path, std::ostream* details_out);
  static uint64_t get_available_hugepage_memory(std::ostream* details_out);

  // options for each module
  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_;

  EXTERNALIZABLE(EngineOptions);
};
}  // namespace foedus
#endif  // FOEDUS_ENGINE_OPTIONS_HPP_