EIC code displayed by LXR master/​include/​dbstl_resource_manager.h	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2024-05-18 08:29:47

 /*-
  * Copyright (c) 2009, 2020 Oracle and/or its affiliates.  All rights reserved.
  *
  * See the file LICENSE for license information.
  *
  * $Id$
  */
 
 #ifndef _DB_STL_RESOURCE_MANAGER_H__
 #define _DB_STL_RESOURCE_MANAGER_H__
 
 #include <map>
 #include <vector>
 #include <stack>
 #include <set>
 
 #include "dbstl_common.h"
 #include "dbstl_inner_utility.h"
 
 START_NS(dbstl)
 
 class DbCursorBase;
 using std::map;
 using std::multimap;
 using std::set;
 using std::stack;
 
 ///////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////
 //
 // ResourceManager class definition
 //
 // This class manages all the Berkeley DB handles and their mapping
 // relationship. When it's only thread-specific instance is destructed,
 // these handles are automatically closed in the correct order (the db and
 // dbenv handles will be closed when the last thread using the handles in
 // the process is destructed).
 //
 // The Db* and DbEnv* handles are process-wide global, they can be shared
 // among multithreads, so they are stored into a static stl map, and access
 // to the two map objects (open_dbs_ & open_envs_) is protected by a process
 // wide mutex because few stl implementations support multithreaded access.
 // We use reference counting in the two map objects to make sure each handle
 // is closed when the last thread using it exits. Each thread sharing the
 // handle should call ResourceManager::register_db/dbenv to tell DBSTL that
 // it will use the handle, otherwise the handle may be closed prematurely.
 //
 // The transaction and cursor handles are thread specific. They are stored
 // into stl containers and each instance of the ResourceManager is stored
 // into thread local storage(TLS) of each thread. Thus the DB STL containers
 // are thread safe.
 //
 
 // This map contains cursors of all open databases opened in the same thread.
 // We can only duplicate a cursor of the same database; We don't allow sharing
 // Berkeley DB cursor handles across multiple threads, each thread needs to
 // open their own cursor handle;
 //
 typedef map<Db *, set<dbstl::DbCursorBase *> *> db_csr_map_t;
 
 // The set of cursors that belong to a db handle or a transaction.
 typedef set<dbstl::DbCursorBase *> csrset_t;
 // The cursors opened in each transaction.
 typedef map<DbTxn *, set<DbCursorBase *> *> txncsr_t;
 
 // This stack contains the transactions started in current thread. Each
 // transaction is the child transaction of the one under it in the stack.
 //
 // We support nested transactions for those created by the dbstl
 // users, but still keep reference counting for dbstl internally
 // created transactions so that the autocommit methods are really
 // autocommit with least overhead (nested transactions are overheads). The
 // way we keep both nested transaction and reference counting to internal
 // transactions in the same stack is:
 // 1. When creating an external transaction, look at the stack top, if there
 // is a transaction, it must be an external one too, so use it as the parent
 // transaction to create the external transaction.
 // 2. When creating an internal transaction, look at the stack top, if there
 // is one, call it T, look for its the reference counting, if there is a
 // reference count for it, T is an internal one, so we increment its
 // reference count; Otherwise, T is an external one, and according to the DB
 // autocommit semantics, this function should be in T's context, so we
 // simply use T and add it to the reference counting structure, and set its
 // reference count to 2.
 //
 // We don't support expanding a transaction across multiple threads,
 // because there are many restrictions to doing so, making it meaningless.
 //
 typedef stack<DbTxn *> txnstk_t;
 typedef map<DbEnv *, txnstk_t> env_txns_t;
 
 #ifdef WIN32
 #pragma warning( push )
 #pragma warning( disable:4251 )
 #endif
 // This class is used to wrap a ResourceManager instance pointer, so that
 // each thread has its own ResourceManager singleton.
 
 #ifdef TLS_DECL_MODIFIER
 template <Typename T>
 class TlsWrapper
 {
 public:
     static T *get_tls_obj()
     {
         return tinst_;
     }
 
     static void set_tls_obj(T *objp)
     {
         tinst_ = objp;
     }
 
 private:
     TlsWrapper(){}
 
     // Thread local pointer to the instance of type T.
     static TLS_DECL_MODIFIER T *tinst_;
 }; // TlsWrapper<>
 
 #elif defined(HAVE_PTHREAD_TLS)
 template <Typename T>
 class TlsWrapper
 {
 public:
     static T *get_tls_obj()
     {
         return static_cast<T*>(pthread_getspecific(tls_key_));
     }
 
     static void set_tls_obj(T *objp)
     {
         pthread_setspecific(tls_key_, objp);
     }
 
     // Friend declarations don't work portably, so we have to declare 
     // tls_key_ public.
     static pthread_key_t tls_key_;
 private:
     TlsWrapper();
 
 }; // TlsWrapper<>
 
 #else
 #error "A multi-threaded build of STL for Berkeley DB requires thread local storage.  None is configured."
 #endif
 
 class _exported ResourceManager : public DbstlGlobalInnerObject
 {
 private:
 
     ResourceManager(void);
     // open_dbs_ & open_envs_ are shared among threads, protected by
     // ghdl_mtx;
     static map<Db *, size_t> open_dbs_;
     static map<DbEnv *, size_t>open_envs_;
 
     // Transaction stack of all environments. Use a stack to allow nested
     // transactions. The transaction at the top of the stack is the
     // current active transaction.
     //
     env_txns_t env_txns_;
 
     // Cursors opened in a corresponding transaction context. When
     // committing or aborting a transaction, first close all open cursors.
     //
     txncsr_t txn_csrs_;
 
     // If in container X, its methods X::A and X::B both call begin and
     // commit transaction. X::A calls X::B after it's begin transaction
     // call, then X::B will commit the transaction prematurally. To avoid
     // will commit the only transaction prematurally, to avoid this, we use
     // this, we use this map to record each transaction's reference count.
     // Each begin/commit_txn() will increment/decrement the reference
     // count, when reference count goes to 0, the transaction is committed.
     // Abort_txn will unconditionally abort the transaction.
     //
     map<DbTxn *, size_t> txn_count_;
 
     // Contains the cursors opened in the current thread for each database,
     // So that we can close them in the right way, freeing any Berkeley DB
     // handles before exiting.
     //
     db_csr_map_t all_csrs_;
 
     // Remove cursors opened in the transaction txn's context, should be
     // called before commiting or aborting a transaction.
     //
     void remove_txn_cursor(DbTxn *txn);
 
     // Add a cursor to the current transaction's set of open cursors.
     void add_txn_cursor(DbCursorBase *dcbcsr, DbEnv *env);
 
     // The environment mtx_env_ and mtx_handle_ are used for synchronizing
     // multiple threads' access to open_dbs_ and open_envs_ and glob_objs_.
     // They are discarded when program exits, no deallocation/release
     // is done.
     static DbEnv *mtx_env_;
     static db_mutex_t mtx_handle_;
     static db_mutex_t mtx_globj_;
     static set<DbstlGlobalInnerObject *> glob_objs_;
 
     // This set stores db handles that are new'ed by open_db, and thus 
     // should be deleted after this db is closed automatically by dbstl.
     // If a db is new'ed and created by user without using open_db, users
     // should delete it.
     static set<Db *> deldbs; 
     static set<DbEnv *> delenvs; // Similar to deldbs, works with open_envs.
     static void set_global_callbacks();
 public:
     
     // This function should be called in a single thread inside a process, 
     // before any use of dbstl.
     static void global_startup();
     // Delete registered DbstlGlobalInnerObject objects.
     static void global_exit();
 
     // Delete the ResourceManager singleton of current thread, and remove it 
     // from glob_objs.
     static void thread_exit();
     static void register_global_object(DbstlGlobalInnerObject *gio);
     static DbEnv *get_mutex_env() { return mtx_env_; }
     // Lock mtx_handle_, if it is 0, allocate it first.
     static int global_lock(db_mutex_t dbcontainer_mtx);
     static int global_unlock(db_mutex_t dbcontainer_mtx);
     // Close pdb regardless of its reference count, users must make sure
     // pdb is not used by others before calling this method. We can't
     // close by reference count in this method, otherwise when the thread
     // exits pdb's reference count is decremented twice.
     void close_db(Db *pdb);
 
     // Close all db handles regardless of reference count, used to clean up
     // the calling thread's ResourceManager singleton.
     void close_all_dbs();
 
     // Close specified db env handle and remove it from resource manager.
     void close_db_env(DbEnv *penv);
 
     // Close and remove all db env registered in the resource manager.
     // Used to clean up the calling thread's ResourceManager singleton.
     void close_all_db_envs();
 
     // Begin a new transaction in the specified environment. When outtxn
     // is non-zero support nested transactions - the new transaction will
     // be started as a child of the current transaction. If outtxn is 0
     // we are starting an internal transaction for autocommit, no new
     // transaction will be started, but the current transaction's
     // reference count will be incremented if it already has a reference
     // count; otherwise, it was created by user, and we simply use this
     // transaction, set its reference count to 2.
     //
     // This function is called by both containers to begin an internal
     // transaction for autocommit, and by db stl users to begin an
     // external transaction.
     //
     DbTxn *begin_txn(u_int32_t flags/* flags for DbEnv::txn_begin */,
         DbEnv *env, int outtxn);
 
     // Decrement reference count if it exists and if it goes to 0, commit
     // current transaction T opened in env;
     // If T has no reference count(outside transaction), simply find
     // it by popping the stack and commit it.
     //
     // This function is called by db_container to commit a transaction
     // for auto commit, also can be called by db stl user to commit
     // an external explicit transaction.
     //
     void commit_txn(DbEnv *env, u_int32_t flags = 0);
 
     // Commit specified transaction txn: find it by popping the stack,
     // discard all its child transactions and commit it.
     //
     // This function is called by dbstl user to commit an external
     // explicit transaction.
     //
     void commit_txn(DbEnv *env, DbTxn *txn, u_int32_t flags = 0);
 
     // Abort current transaction of the environment.
     //
     void abort_txn(DbEnv *env);
 
     // Abort specified transaction: find it by popping the stack, discard
     // all its child transactions and abort it.
     //
     // This function is called by dbstl user to abort an external
     // explicit transaction.
     //
     void abort_txn(DbEnv *env, DbTxn *txn);
 
     // Set env's current transaction handle. The original transaction
     // handle is returned without aborting or commiting. This API can be
     // used to share a transaction handle among multiple threads.
     DbTxn* set_current_txn_handle(DbEnv *env, DbTxn *newtxn);
 
     // Register a Db handle. This handle and handles opened in it
     // will be closed by ResourceManager, so application code must not
     // try to close or delete it. Users can configure the handle before
     // opening the Db and then register it via this function.
     //
     void register_db(Db *pdb1);
 
     // Register a DbEnv handle. This handle and handles opened in it
     // will be closed by ResourceManager, so application code must not try
     // to close or delete it. Users can configure the handle before
     // opening the Environment and then register it via this function.
     //
     void register_db_env(DbEnv *env1);
 
     // Helper function to open a database and register it into
     // ResourceManager.
     // Users can set the create flags, open flags, db type, and flags
     // needing to be set before open.
     //
     Db* open_db (DbEnv *penv, const char *filename, DBTYPE dbtype,
         u_int32_t oflags, u_int32_t set_flags, int mode = 0644,
         DbTxn* txn = NULL, u_int32_t cflags = 0,
         const char *dbname = NULL);
 
     // Helper function to open a dbenv and register it into
     // ResourceManager.
     // Users can set the create flags, open flags, db type, and flags
     // needing to be set before open.
     //
     DbEnv *open_env(const char *env_home, u_int32_t set_flags,
         u_int32_t oflags = DB_CREATE | DB_INIT_MPOOL,
         u_int32_t cachesize = 4 * 1024 * 1024, int mode = 0644,
         u_int32_t cflags = 0/* Flags for DbEnv constructor. */);
 
     static ResourceManager *instance();
 
     // Release all registered resource in the right order.
     virtual ~ResourceManager(void);
 
     // Return current transaction of environment env, that is, the one on
     // the transaction stack top, the active one.
     //
     DbTxn *current_txn(DbEnv *env);
 
     // Open a Berkeley DB cursor.
     //
     int open_cursor(DbCursorBase *dcbcsr, Db *pdb, int flags = 0);
 
     // Add a db-cursor mapping.
     void add_cursor(Db *dbp, DbCursorBase *csr);
 
     // Close all cursors opened in the database.
     size_t close_db_cursors(Db *dbp1);
 
     // Close and remove a cursor from ResourceManager.
     //
     int remove_cursor(DbCursorBase *csr, bool remove_from_txncsrs = true);
 
 }; // ResourceManager
 
 END_NS
 #ifdef WIN32
 #pragma warning( pop )
 #endif
 #endif // !_DB_STL_RESOURCE_MANAGER_H__

This page was automatically generated by the 2.3.5 LXR engine. The LXR team