Line data    Source code

       1             : /*
       2             :  * Copyright (c) 2013 Juniper Networks, Inc. All rights reserved.
       3             :  */
       4             : 
       5             : #include "db/db_entry.h"
       6             : 
       7             : #include <tbb/mutex.h>
       8             : 
       9             : #include "base/time_util.h"
      10             : #include "db/db_table_partition.h"
      11             : 
      12             : using namespace std;
      13             : 
      14     9468663 : DBEntryBase::DBEntryBase()
      15     9468663 :         : tpart_(NULL), flags(0), last_change_at_(UTCTimestampUsec()) {
      16     9469734 :     onremoveq_ = false;
      17     9469955 : }
      18             : 
      19     9459079 : DBEntryBase::~DBEntryBase() {
      20     9459079 : }
      21             : 
      22     3691625 : void DBEntryBase::SetState(DBTableBase *tbl_base, ListenerId listener,
      23             :                            DBState *state) {
      24     3691625 :     DBTablePartBase *tpart = tbl_base->GetTablePartition(this);
      25     3691574 :     tbb::spin_rw_mutex::scoped_lock lock(tpart->dbstate_mutex(), true);
      26     3693500 :     pair<StateMap::iterator, bool> res = state_.insert(
      27     3693310 :         make_pair(listener, state));
      28     3693039 :     if (!res.second) {
      29     1224752 :         res.first->second = state;
      30             :     } else {
      31     2468287 :         assert(!IsDeleted());
      32             :         // Account for state addition for this listener.
      33     2468282 :         tbl_base->AddToDBStateCount(listener, 1);
      34             :     }
      35     3692992 : }
      36             : 
      37    12139678 : DBState *DBEntryBase::GetState(DBTableBase *tbl_base, ListenerId listener) const {
      38    12139678 :     DBTablePartBase *tpart = tbl_base->GetTablePartition(this);
      39    12138167 :     tbb::spin_rw_mutex::scoped_lock lock(tpart->dbstate_mutex(), false);
      40    12151036 :     StateMap::const_iterator loc = state_.find(listener);
      41    12135378 :     if (loc != state_.end()) {
      42     7796070 :         return loc->second;
      43             :     }
      44     4342280 :     return NULL;
      45    12137855 : }
      46             : 
      47         802 : const DBState *DBEntryBase::GetState(const DBTableBase *tbl_base,
      48             :                                      ListenerId listener) const {
      49         802 :     DBTableBase *table = const_cast<DBTableBase *>(tbl_base);
      50         802 :     DBTablePartBase *tpart = table->GetTablePartition(this);
      51         802 :     tbb::spin_rw_mutex::scoped_lock lock(tpart->dbstate_mutex(), false);
      52         802 :     StateMap::const_iterator loc = state_.find(listener);
      53         802 :     if (loc != state_.end()) {
      54         771 :         return loc->second;
      55             :     }
      56          31 :     return NULL;
      57         802 : }
      58             : 
      59             : //
      60             : // Concurrency: called from arbitrary task.
      61             : //
      62             : // Evaluate concurrency issues with DBTablePartBase::RunNotify when making
      63             : // changes to this method.  We expect that either this method or RunNotify
      64             : // is responsible for removing the DBEntryBase when they run concurrently,
      65             : // assuming the DBEntryBase is eligible for removal.  The dbstate_mutex in
      66             : // in DBTablePartBase is used for synchronization.
      67             : //
      68             : // Remove DBState on this DBEntryBase for the given listener and enqueue
      69             : // for removal if appropriate.
      70             : // Note that the entry cannot be removed from DBTablePartBase here since
      71             : // this method may be called from an arbitrary Task.
      72             : //
      73     2467798 : void DBEntryBase::ClearState(DBTableBase *tbl_base, ListenerId listener) {
      74     2467798 :     DBTablePartBase *tpart = tbl_base->GetTablePartition(this);
      75     2467580 :     tbb::spin_rw_mutex::scoped_lock lock(tpart->dbstate_mutex(), true);
      76             : 
      77     2468445 :     assert(state_.erase(listener) != 0);
      78             : 
      79             :     // Account for state removal for this listener.
      80     2467573 :     tbl_base->AddToDBStateCount(listener, -1);
      81             : 
      82     2468327 :     if (state_.empty() && IsDeleted() && !is_onlist() && !IsOnRemoveQ()) {
      83      517481 :         tbl_base->EnqueueRemove(this);
      84             :     }
      85     2468276 : }
      86             : 
      87     1057428 : bool DBEntryBase::is_state_empty(DBTablePartBase *tpart) {
      88     1057428 :     tbb::spin_rw_mutex::scoped_lock lock(tpart->dbstate_mutex(), false);
      89     2114915 :     return state_.empty();
      90     1057372 : }
      91             : 
      92      517499 : bool DBEntryBase::is_state_empty_unlocked(DBTablePartBase *tpart) {
      93      517499 :     return state_.empty();
      94             : }
      95             : 
      96     2185736 : void DBEntryBase::set_last_change_at_to_now() {
      97     2185736 :     last_change_at_ = UTCTimestampUsec();
      98     2185813 : }
      99             : 
     100           0 : void DBEntryBase::set_last_change_at(uint64_t time) {
     101           0 :     last_change_at_ = time;
     102           0 : }
     103             : 
     104     2301358 : void DBEntryBase::set_last_update_at_to_now() {
     105     2301358 :     last_update_at_ = UTCTimestampUsec();
     106     2301413 : }
     107             : 
     108         150 : void DBEntryBase::set_last_update_at(uint64_t time) {
     109         150 :     last_update_at_ = time;
     110         150 : }
     111     1430832 : void DBEntryBase::set_table_partition(DBTablePartBase *tpart) {
     112     1430832 :     tpart_ = tpart;
     113     1430832 : }
     114             : 
     115     3184650 : DBTablePartBase *DBEntryBase::get_table_partition() const {
     116     3184650 :     return tpart_;
     117             : }
     118             : 
     119     9318642 : DBTableBase *DBEntryBase::get_table() const {
     120     9318642 :     return (tpart_ ? tpart_->parent() : NULL);
     121             : }
     122             : 
     123           0 : const std::string DBEntryBase::last_change_at_str() const {
     124           0 :     return duration_usecs_to_string(UTCTimestampUsec() - last_change_at_);
     125             : }
     126             : 
     127       60160 : void DBEntryBase::Notify() {
     128       60160 :     tpart_->Notify(this);
     129       60160 : }
     130             : 
     131       48080 : void DBEntryBase::Delete() {
     132       48080 :     if (!IsDeleted())
     133       48080 :         tpart_->Delete(this);
     134       48080 : }