engine_pimpl.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_PIMPL_HPP_
#define FOEDUS_ENGINE_PIMPL_HPP_

#include <string>
#include <vector>

#include "foedus/engine_options.hpp"
#include "foedus/engine_type.hpp"
#include "foedus/fwd.hpp"
#include "foedus/initializable.hpp"
#include "foedus/module_type.hpp"
// This is pimpl. no need for further indirections. just include them all.
#include "foedus/cache/cache_manager.hpp"
#include "foedus/debugging/debugging_supports.hpp"
#include "foedus/log/log_manager.hpp"
#include "foedus/memory/engine_memory.hpp"
#include "foedus/proc/proc_manager.hpp"
#include "foedus/restart/restart_manager.hpp"
#include "foedus/savepoint/savepoint_manager.hpp"
#include "foedus/snapshot/snapshot_manager.hpp"
#include "foedus/soc/soc_id.hpp"
#include "foedus/soc/soc_manager.hpp"
#include "foedus/storage/storage_manager.hpp"
#include "foedus/thread/thread_pool.hpp"
#include "foedus/xct/xct_manager.hpp"

namespace foedus {
class EnginePimpl final : public DefaultInitializable {
 public:
  struct ModulePtr {
    ModulePtr() : ptr_(nullptr), type_(kInvalid) {}
    ModulePtr(Initializable* ptr, ModuleType type) : ptr_(ptr), type_(type) {}
    Initializable* ptr_;
    ModuleType type_;
  };

  EnginePimpl() = delete;
  EnginePimpl(Engine* engine, const EngineOptions &options);
  EnginePimpl(
    Engine* engine,
    EngineType type,
    soc::Upid master_upid,
    Eid master_eid,
    soc::SocId soc_id);

  bool        is_master() const { return type_ == kMaster; }
  ErrorStack  initialize_once() override;
  ErrorStack  initialize_modules();
  ErrorStack  uninitialize_once() override;
  ErrorStack  check_valid_options();

  void        on_module_initialized(ModuleType module);
  void        on_module_uninitialized(ModuleType module);

  EngineOptions                   options_;

  Engine* const                   engine_;

  const EngineType                type_;
  const soc::Upid                 master_upid_;
  const Eid                       master_eid_;
  const soc::SocId                soc_id_;

// Individual modules. Placed in initialize()/uninitialize() order
// (remember, modules have dependencies between them).

  soc::SocManager                 soc_manager_;
  debugging::DebuggingSupports    debug_;
  proc::ProcManager               proc_manager_;
  memory::EngineMemory            memory_manager_;
  savepoint::SavepointManager     savepoint_manager_;
  thread::ThreadPool              thread_pool_;
  log::LogManager                 log_manager_;
  snapshot::SnapshotManager       snapshot_manager_;
  cache::CacheManager             cache_manager_;
  storage::StorageManager         storage_manager_;
  xct::XctManager                 xct_manager_;
  restart::RestartManager         restart_manager_;

  std::vector< ModulePtr > get_modules() {
    std::vector< ModulePtr > modules;
    // modules.push_back(ModulePtr(&soc_manager_, kSoc));  SOC Manager is specially inited/uninited
    modules.push_back(ModulePtr(&debug_, kDebug));
    modules.push_back(ModulePtr(&proc_manager_, kProc));
    modules.push_back(ModulePtr(&memory_manager_, kMemory));
    modules.push_back(ModulePtr(&savepoint_manager_, kSavepoint));
    modules.push_back(ModulePtr(&thread_pool_, kThread));
    modules.push_back(ModulePtr(&log_manager_, kLog));
    modules.push_back(ModulePtr(&snapshot_manager_, kSnapshot));
    modules.push_back(ModulePtr(&cache_manager_, kCache));
    modules.push_back(ModulePtr(&storage_manager_, kStorage));
    modules.push_back(ModulePtr(&xct_manager_, kXct));
    modules.push_back(ModulePtr(&restart_manager_, kRestart));
    return modules;
  }
  std::string describe_short() const;

 private:
  static ErrorStack check_transparent_hugepage_setting();
  ErrorStack check_minimal_pool_size() const;
};
}  // namespace foedus
#endif  // FOEDUS_ENGINE_PIMPL_HPP_