qdp_db_imp.h

Go to the documentation of this file.

// -*- C++ -*-
 
#ifndef QDP_DB_IMP_H
#define QDP_DB_IMP_H
 
#include "qdp_layout.h"
#include "ConfDataStoreDB.h"
 
namespace QDP
{

  const int db_cachesize = 50*1024*1024;

  const int db_pagesize = 64*1024;
 
  //--------------------------------------------------------------------------------

  template<typename K, typename D>
  class BinaryStoreDB
  {
  public:
    BinaryStoreDB ()
    {
      // Initialize default values
      if (Layout::primaryNode())
      {
        db.setCacheSize(db_cachesize);
//      db.enablePageMove();   // Disable!
        db.setMaxNumberConfigs(1);
      }
    }

    ~BinaryStoreDB() 
    {
      close();
    }

    virtual void setCacheSize (const unsigned int size)
    {
      if (Layout::primaryNode())
        db.setCacheSize(size);
    }
 
    
    virtual void setCacheSizeMB (const unsigned int size)
    {
      if (Layout::primaryNode())
        db.setCacheSizeMB(size);
    }
 

    virtual void setPageSize (const unsigned int size)
    {
      if (Layout::primaryNode()) 
        db.setPageSize(size);
    }
 

    virtual void setNumberBuckets (const unsigned int num)
    {
      if (Layout::primaryNode()) 
        db.setNumberBuckets(num);
    }
 

    virtual void enablePageMove (void)
    {
      if (Layout::primaryNode()) 
        db.enablePageMove();
    }
 
    virtual void disablePageMove (void)
    {
      if (Layout::primaryNode()) 
        db.disablePageMove();
    }

    virtual void setMaxUserInfoLen (unsigned int len)
    {
      if (Layout::primaryNode()) 
        db.setMaxUserInfoLen(len);
    }
 
    virtual unsigned int getMaxUserInfoLen (void) const
    {
      unsigned int ret = 0;
      if (Layout::primaryNode()) 
        ret = db.getMaxUserInfoLen();
 
      QDPInternal::broadcast(ret);
      return ret;
    }

    virtual void setMaxNumberConfigs (unsigned int num)
    {
      if (Layout::primaryNode()) 
        db.setMaxNumberConfigs(num);
    }
 
    virtual unsigned int getMaxNumberConfigs (void) const
    {
      unsigned int ret = 0;
      if (Layout::primaryNode()) 
        ret = db.getMaxNumberConfigs();
 
      QDPInternal::broadcast(ret);
      return ret;
    }
 

    virtual bool fileExists (const std::string& file) const
    {
      bool ret = false;
      if (Layout::primaryNode()) 
        ret = db.fileExists(file);
 
      QDPInternal::broadcast(ret);
      return ret;
    }
 

    virtual void open (const std::string& file, int open_flags, int mode)
    {
      int ret = 0;
      if (Layout::primaryNode()) 
        ret = db.open(file, open_flags, mode);
 
      QDPInternal::broadcast(ret);
      if (ret != 0)
      {
        QDPIO::cerr << "Cannot open db file= " << file << std::endl;
        QDP_abort(1);
      }
    }
 
 
    virtual void close (void)
    {
      int ret = 0;
      if (Layout::primaryNode()) 
        ret = db.close();
 
      QDPInternal::broadcast(ret);
      if (ret != 0)
      {
        QDPIO::cerr << "Error closing db file" << std::endl;
        QDP_abort(1);
      }
    }

    bool exist(const K& key)
    {
      bool ret = true;
      if (Layout::primaryNode()) 
        ret = db.exist(key);
 
      QDPInternal::broadcast(ret);
    
      return ret;
    }
 

    void insert (const K& key, const D& data)
    {
      int ret = 0;
      if (Layout::primaryNode()) 
        ret = db.insert(key, data);
 
      QDPInternal::broadcast(ret);
      if (ret != 0)
      {
        QDPIO::cerr << __func__ << ": error inserting into db" << std::endl;
        QDP_abort(1);
      }
    }
 

    void insertBinary (const std::string& key, const std::string& data)
    {
      int ret = 0;
      if (Layout::primaryNode()) 
        ret = db.insertBinary(key, data);
 
      QDPInternal::broadcast(ret);
      if (ret != 0)
      {
        QDPIO::cerr << __func__ << ": error in db" << std::endl;
        QDP_abort(1);
      }
    }
 

    int get (const K& key, D& data)
    {
      int ret = 0;
      if (Layout::primaryNode()) 
        ret = db.get(key, data);
      else
        notImplemented();
 
      QDPInternal::broadcast(ret);
      return ret;
    }
 

    int getBinary (const std::string& key, std::string& data)
    {
      int ret = 0;
      if (Layout::primaryNode()) 
        ret = db.getBinary(key, data);
      else
        notImplemented();
 
      QDPInternal::broadcast(ret);
      return ret;
    }

    virtual void keys (std::vector<K>& keys_)
    {
      if (Layout::primaryNode()) 
        db.keys(keys_);
      else
        notImplemented();
    }

    virtual void keysAndData (std::vector<K>& keys_, std::vector<D>& values_)
    {
      if (Layout::primaryNode()) 
        db.keysAndData(keys_, values_);
      else
        notImplemented();
    }
 

    virtual void binaryKeysAndData (std::vector<std::string> keys_,
                                    std::vector<std::string> values_)
    {
      if (Layout::primaryNode()) 
        db.binaryKeysAndData(keys_, values_);
      else
        notImplemented();
    }

    virtual void flush (void)
    {
      if (Layout::primaryNode()) 
        db.flush();
    }

    virtual std::string storageName (void) const
    {
      std::string ret;
      if (Layout::primaryNode()) 
        ret = db.storageName();
 
      QDPInternal::broadcast_str(ret);
      return ret;
    }
 
    
    virtual void insertUserdata (const std::string& user_data)
    {
      int ret = 0;
      if (Layout::primaryNode()) 
        ret = db.insertUserdata(user_data);
 
      QDPInternal::broadcast(ret);
      if (ret != 0)
      {
        QDPIO::cerr << __func__ << ": error inserting user data into db" << std::endl;
        QDP_abort(1);
      }
    }
    
    virtual void getUserdata (std::string& user_data)
    {
      int ret = 0;
      if (Layout::primaryNode()) 
        ret = db.getUserdata(user_data);
      /*
      else
        notImplemented();
      */
 
      QDPInternal::broadcast(ret);
      if (ret != 0)
      {
        QDPIO::cerr << __func__ << ": error getting user data from db" << std::endl;
        QDP_abort(1);
      }
                        
      QDPInternal::broadcast_str(user_data);
    }
 
 
  private:
    void notImplemented() const
    {
      QDP_error_exit("FILEDB read routines do not work (yet) in parallel - only single node");
    }
 
    FILEDB::ConfDataStoreDB<K,D> db;
  };
 
 
}  // namespace QDP
 
#endif