config.h

Go to the documentation of this file.

/***************************************************************************
 * include/stxxl/bits/mng/config.h
 *
 * Part of the STXXL. See http://stxxl.sourceforge.net
 *
 * Copyright (C) 2002-2005 Roman Dementiev <[email protected]>
 * Copyright (C) 2008, 2009 Andreas Beckmann <[email protected]>
 * Copyright (C) 2013 Timo Bingmann <[email protected]>
 *
 * Distributed under the Boost Software License, Version 1.0.
 * (See accompanying file LICENSE_1_0.txt or copy at
 * http://www.boost.org/LICENSE_1_0.txt)
 **************************************************************************/

#ifndef STXXL_MNG_CONFIG_HEADER
#define STXXL_MNG_CONFIG_HEADER

#include <vector>
#include <string>
#include <cstdlib>
#include <cassert>

#include <stxxl/version.h>
#include <stxxl/bits/singleton.h>
#include <stxxl/bits/common/log.h>

STXXL_BEGIN_NAMESPACE

//! \addtogroup mnglayer
//! \{

//! Encapsulate the configuration of one "disk". The disk is actually a file
//! I/O object which block_manager uses to read/write blocks.
class disk_config
{
public:
 //! \name Basic Disk Configuration Parameters
 //! \{

 //! the file path used by the io implementation
 std::string path;

 //! file size to initially allocate
 uint64 size;

 //! io implementation to access file
 std::string io_impl;

 //! \}

public:
 //! default constructor
 disk_config();

 //! initializing constructor, also parses fileio parameter
 disk_config(const std::string& path, uint64 size, const std::string& fileio);

 //! initializing constructor, parse full line as in config files
 disk_config(const std::string& line);

 //! parse a disk=<path>,<size>,<fileio> options line into disk_config,
 //! throws std::runtime_error on parse errors.
 void parse_line(const std::string& line);

 //! parse the "io_impl" parameter into the optional parameter fields.
 void parse_fileio();

 //! return formatted fileio name and optional configuration parameters
 std::string fileio_string() const;

public:
 //! \name Optional Disk / File I/O Implementation Parameters
 //! \{

 //! autogrow file if more disk space is needed, automatically set if size == 0.
 bool autogrow;

 //! delete file on program exit (default for autoconfigurated files)
 bool delete_on_exit;

 //! tristate variable: direct=0 -> force direct OFF, direct=1 -> try direct
 //! ON, if fails print warning and open without direct, direct=2 -> force
 //! direct ON, fail if unavailable.
 enum direct_type { DIRECT_OFF = 0, DIRECT_TRY = 1, DIRECT_ON = 2 } direct;

 //! marks flash drives (configuration entries with flash= instead of disk=)
 bool flash;

 //! select request queue for disk. Use different queues for files on
 //! different disks. queue=-1 -> default queue (one for each disk).
 int queue;

 //! the selected physical device id (e.g. for calculating prefetching
 //! sequences). If -1 then the device id is chosen automatically.
 unsigned int device_id;

 //! turned on by syscall fileio when the path points to a raw block device
 bool raw_device;

 //! unlink file immediately after opening (available on most Unix)
 bool unlink_on_open;

 //! desired queue length for linuxaio_file and linuxaio_queue
 int queue_length;

 //! \}
};

//! Access point to disks properties. Since 1.4.0: no config files are read
//! automatically!
//! \remarks is a singleton
class config : public singleton<config>
{
 friend class singleton<config>;

 //! typedef of list of configured disks
 typedef std::vector<disk_config> disk_list_type;

 //! list of configured disks
 disk_list_type disks_list;

 //! In disks_list, flash devices come after all regular disks
 unsigned first_flash;

 //! Finished initializing config
 bool is_initialized;

 //! Constructor: this must be inlined to print the header version
 //! string.
 inline config()
 : is_initialized(false)
 {
 logger::get_instance();
 STXXL_MSG(get_version_string_long());
 print_library_version_mismatch();
 }

 //! deletes autogrow files
 ~config();

 //! Search several places for a config file.
 void find_config();

 //! If disk list is empty, then search different locations for a disk
 //! configuration file, or load a default config if everything fails.
 void initialize();

public:
 //! \name Initialization Functions
 //! \{

 //! Check that initialize() was called.
 //! \note This function need not be called by the user, block_manager will
 //! always call it.
 void check_initialized()
 {
 if (!is_initialized) initialize();
 }

 //! Load disk configuration file.
 void load_config_file(const std::string& config_path);

 //! Load default configuration.
 void load_default_config();

 //! Add a disk to the configuration list.
 //!
 //! \warning This function should only be used during initialization, as it
 //! has no effect after construction of block_manager.
 inline config & add_disk(const disk_config& cfg)
 {
 disks_list.push_back(cfg);
 return *this;
 }

 //! \}

protected:
 //! \name Automatic Disk Enumeration Functions
 //! \{

 //! static counter for automatic physical device enumeration
 unsigned int m_max_device_id;

public:
 //! Returns automatic physical device id counter
 unsigned int get_max_device_id();

 //! Returns next automatic physical device id counter
 unsigned int get_next_device_id();

 //! Update the automatic physical device id counter
 void update_max_device_id(unsigned int devid);

 //! \}

public:
 //! \name Query Functions
 //! \{

 //! Returns number of disks available to user.
 //! \return number of disks
 inline size_t disks_number()
 {
 check_initialized();
 return disks_list.size();
 }

 //! Returns contiguous range of regular disks w/o flash devices in the array of all disks.
 //! \return range [begin, end) of regular disk indices
 inline std::pair<unsigned, unsigned> regular_disk_range() const
 {
 assert(is_initialized);
 return std::pair<unsigned, unsigned>(0, first_flash);
 }

 //! Returns contiguous range of flash devices in the array of all disks.
 //! \return range [begin, end) of flash device indices
 inline std::pair<unsigned, unsigned> flash_range() const
 {
 assert(is_initialized);
 return std::pair<unsigned, unsigned>(first_flash, (unsigned)disks_list.size());
 }

 //! Returns mutable disk_config structure for additional disk parameters
 inline disk_config & disk(size_t disk)
 {
 check_initialized();
 return disks_list[disk];
 }

 //! Returns constant disk_config structure for additional disk parameters
 inline const disk_config & disk(size_t disk) const
 {
 assert(is_initialized);
 return disks_list[disk];
 }

 //! Returns path of disks.
 //! \param disk disk's identifier
 //! \return string that contains the disk's path name
 inline const std::string & disk_path(size_t disk) const
 {
 assert(is_initialized);
 return disks_list[disk].path;
 }

 //! Returns disk size.
 //! \param disk disk's identifier
 //! \return disk size in bytes
 inline stxxl::uint64 disk_size(size_t disk) const
 {
 assert(is_initialized);
 return disks_list[disk].size;
 }

 //! Returns name of I/O implementation of particular disk.
 //! \param disk disk's identifier
 inline const std::string & disk_io_impl(size_t disk) const
 {
 assert(is_initialized);
 return disks_list[disk].io_impl;
 }

 //! Returns the total size over all disks
 uint64 total_size() const;

 //! \}
};

//! \}

STXXL_END_NAMESPACE

#endif // !STXXL_MNG_CONFIG_HEADER
// vim: et:ts=4:sw=4