Database Engine

Database Engine, the top-level component of foedus. More...

Detailed Description

Database Engine, the top-level component of foedus.

bluh

Module Dependency

Sub-modules in the engine have dependencies between them. For example, all other sub-modules depend on Debug-Support functionalities, so the debugging module is initialized at first, and uninitialized at end. There must not be a cycle, obviously. Below is the list of dependencies

• SOC and IPC must start up at the beginning as this is a special module.
• All other modules depend on Debug-Support functionalities.
• System and User Procedures depends on Debug-Support functionalities and SOC and IPC.
• Thread and Thread-Group depend on Memory Manager.
• Log Manager depend on Thread and Thread-Group and Savepoint Manager.
• Snapshot Manager and Snapshot Cache Manager depend on Log Manager.
• Storage Manager depend on Snapshot Manager and Snapshot Cache Manager.
• Transaction Manager depends on Storage Manager.
• Restart Manager depends on everything else (and runs only at restart by definition).

(transitively implied dependencies omitted, eg Log Manager of course depends on Memory Manager).

Hence, we initialize/uninitialize the modules in the above order.

Collaboration diagram for Database Engine:

Classes
class	foedus::Engine
	Database engine object that holds all resources and provides APIs. More...
struct	foedus::EngineOptions
	Set of option values given to the engine at start-up. More...
struct	foedus::EnginePimpl::ModulePtr
	pair of module pointer and its type. More...
class	foedus::EnginePimpl
	Pimpl object of Engine. More...
class	foedus::Epoch
	Represents a time epoch. More...
class	foedus::memory::EngineMemory
	Repository of all memories dynamically acquired and shared within one database engine. More...

Enumerations
enum	foedus::EngineType {   foedus::kMaster, foedus::kChildEmulated, foedus::kChildForked, foedus::kChildLocalSpawned,   foedus::kChildRemoteSpawned }
	Type of an engine instance of how to launch it. More...
enum	foedus::ModuleType {   foedus::kInvalid = 0, foedus::kSoc, foedus::kDebug, foedus::kProc,   foedus::kMemory, foedus::kSavepoint, foedus::kThread, foedus::kLog,   foedus::kSnapshot, foedus::kCache, foedus::kStorage, foedus::kXct,   foedus::kRestart, foedus::kDummyTail }
	Enumerates modules in FOEDUS engine. More...

Enumeration Type Documentation

enum foedus::EngineType

Type of an engine instance of how to launch it.

Enumerator
kMaster	The central instance that launches child engines on each NUMA node (SOC). This is the only engine type a user explicitly instantiates.
kChildEmulated	A child SOC instance launched just as a thread in the same process as master. This is the most handy way of launching child SOCs, but has a scalability limit around 30-50 threads in one process. Instead, users can easily specify function pointers and also debug/profile the program just like a usual standalone program. Most testing and development uses this.
kChildForked	A child SOC instance launched via fork(). This is also handy next to emulated children, and also does not require a change in main() function of the program as the forked processes start from the fork() position rather than main(). fork() preserves address space as-of the fork, so if the user pre-registers function pointers BEFORE the fork (Engine's initialize()), they can be also available in all SOCs. However, after the fork, the only way to register user-specified procedures is to provide additional shared libraries. One (probably) minor drawback: fork() is not available in Windows.
kChildLocalSpawned	A child SOC instance launched via spawn(). In order to use this type, the user has to put one-liner in her main() function to catch the spawned child process and forward the control to FOEDUS library. Instead, the user can register arbitrary function pointers in the main() function, which is executed in all SOCs. This way of registering user procedures do not need to compile separate shared libraries. Further, the user can choose to launch different binaries for each SOC, as an alternative of executable/library text replication for each NUMA node to reduce instruction cache miss cost.
kChildRemoteSpawned	A child SOC instance launched in other machines. This type is not implemented yet. On cache-incoherent machines, we have to use this type. Todo: How to launch programs remotely? How to use RVMA?

Definition at line 35 of file engine_type.hpp.

                {
  kMaster,

  kChildEmulated,

  kChildForked,

  kChildLocalSpawned,

  kChildRemoteSpawned,
};

enum foedus::ModuleType

Enumerates modules in FOEDUS engine.

In initialization order.

Enumerator
kInvalid
kSoc
kDebug
kProc
kMemory
kSavepoint
kThread
kLog
kSnapshot
kCache
kStorage
kXct
kRestart
kDummyTail

Definition at line 26 of file module_type.hpp.

                {
  kInvalid = 0,
  kSoc,
  kDebug,
  kProc,
  kMemory,
  kSavepoint,
  kThread,
  kLog,
  kSnapshot,
  kCache,
  kStorage,
  kXct,
  kRestart,
  kDummyTail,
};