db_table_partition.h

Go to the documentation of this file.

/*
 * Copyright (c) 2013 Juniper Networks, Inc. All rights reserved.
 */
 
#ifndef ctrlplane_db_table_partition_h
#define ctrlplane_db_table_partition_h
 
#include <mutex>
 
#include <boost/intrusive/list.hpp>
#include <tbb/spin_rw_mutex.h>
 
#include "db/db_entry.h"
 
class DBTableBase;
class DBTable;
 
// Table shard contained within a DBPartition.
class DBTablePartBase {
public:
    static const int kMaxIterations = 256;
    typedef boost::intrusive::member_hook<DBEntryBase,
            boost::intrusive::list_member_hook<>,
            &DBEntryBase::chg_list_> ChangeListMember;
 
    typedef boost::intrusive::list<DBEntryBase, ChangeListMember> ChangeList;
 
 
    DBTablePartBase(DBTableBase *tbl_base, int index)
        : parent_(tbl_base), index_(index) {
    }
 
    // Input processing stage for DBRequests. Called from per-partition thread.
    virtual void Process(DBClient *client, DBRequest *req) = 0;
 
    // Enqueue a change notification. Deferred until the RunNotify stage.
    void Notify(DBEntryBase *entry);
 
    // Run the notification queue.
    bool RunNotify();
 
    DBTableBase *parent() { return parent_; }
    int index() const { return index_; }
 
    virtual void Remove(DBEntryBase *) = 0;
 
    void Delete(DBEntryBase *);
 
    // Walk functions
    virtual DBEntryBase *lower_bound(const DBEntryBase *key) = 0;
    virtual DBEntryBase *GetFirst() = 0;
    virtual DBEntryBase *GetNext(const DBEntryBase *) = 0;
 
    tbb::spin_rw_mutex &dbstate_mutex() {
        return dbstate_mutex_;
    }
 
    virtual ~DBTablePartBase() {};
private:
    tbb::spin_rw_mutex dbstate_mutex_;
    DBTableBase *parent_;
    int index_;
    ChangeList change_list_;
    DISALLOW_COPY_AND_ASSIGN(DBTablePartBase);
};
 
class DBTablePartition : public DBTablePartBase {
public:
    typedef boost::intrusive::member_hook<DBEntry,
        boost::intrusive::set_member_hook<>,
        &DBEntry::node_> SetMember;
    typedef boost::intrusive::set<DBEntry, SetMember> Tree;
 
    DBTablePartition(DBTable *parent, int index);
 
    // Virtual functions from DBTableBase implemented by DBTable
    void Process(DBClient *client, DBRequest *req);
    // Returns the matching route or next in lex order
    virtual DBEntry *lower_bound(const DBEntryBase *entry);
 
    // Returns the next route (Doesn't search). Threaded walk
    virtual DBEntry *GetNext(const DBEntryBase *entry);
 
    virtual DBEntry *GetFirst();
 
    // Methods used in implementing DBTablePartition
 
    // Add a DB Entry
    virtual void Add(DBEntry *entry);
 
    // Generate Change notification for an entry
    virtual void Change(DBEntry *entry);
 
    // Remove an entry from DB Table. Entry will not be accessible from
    // DB anymore
    virtual void Remove(DBEntryBase *entry);
 
    // Find DB Entry. Get key from from argument
    DBEntry *Find(const DBEntry *entry);
    const DBEntry *Find(const DBEntry *entry) const;
    DBEntry *FindNoLock(const DBEntry *entry);
 
    // Find DB Entry. Get key from from argument
    DBEntry *Find(const DBRequestKey *key);
    DBEntry *FindNoLock(const DBRequestKey *key);
 
    // Find the next in lex order
    DBEntry *FindNext(const DBRequestKey *key);
 
    DBTable *table();
    size_t size() const { return tree_.size(); }
 
    // Add an entry to DB without allocating
    void AddWithoutAlloc(DBEntry *entry);
 
    // Remove an entry from DB without delete
    void RemoveWithoutDelete(DBEntry *entry);
 
private:
    DBEntry *FindInternal(const DBEntry *entry);
    const DBEntry *FindInternal(const DBEntry *entry) const;
 
    mutable std::mutex mutex_;
    Tree tree_;
    DISALLOW_COPY_AND_ASSIGN(DBTablePartition);
};
 
#endif