Line data    Source code

       1             : /*
       2             :  * Copyright (c) 2013 Juniper Networks, Inc. All rights reserved.
       3             :  */
       4             : 
       5             : #include "base/task.h"
       6             : #include "db/db.h"
       7             : #include "db/db_partition.h"
       8             : #include "db/db_table.h"
       9             : #include "db/db_table_walker.h"
      10             : #include "db/db_table_walk_mgr.h"
      11             : 
      12             : using namespace std;
      13             : 
      14             : int DB::partition_count_;
      15             : 
      16             : // factory map is declared as a local static variable in order to avoid
      17             : // static initialization order dependencies.
      18      290288 : DB::FactoryMap *DB::factories() {
      19      290288 :     static FactoryMap factory_map;
      20      290290 :     return &factory_map;
      21             : }
      22             : 
      23        1558 : void DB::RegisterFactory(const std::string &prefix, CreateFunction create_fn) {
      24        1558 :     DB::factories()->insert(make_pair(prefix, create_fn));
      25        1558 : }
      26             : 
      27          15 : void DB::ClearFactoryRegistry() {
      28          15 :     DB::factories()->clear();
      29          15 : }
      30             : 
      31    40941972 : int DB::PartitionCount() {
      32             : 
      33             :     // Initialize static partition_count_.
      34    40941972 :     if (!partition_count_) {
      35         183 :         partition_count_ = TaskScheduler::GetInstance()->HardwareThreadCount();
      36             :     }
      37    40946049 :     return partition_count_;
      38             : }
      39             : 
      40             : // For unit testing only.
      41           4 : void DB::SetPartitionCount(int partition_count) {
      42           4 :     partition_count_ = partition_count;
      43           4 : }
      44             : 
      45       27400 : DB::DB(int task_id) : task_id_(task_id) {
      46       27400 :     if (task_id == -1)
      47       19188 :         task_id_ = TaskScheduler::GetInstance()->GetTaskId("db::DBTable");
      48       27400 :     walker_.reset(new DBTableWalker(task_id_));
      49       27400 :     walk_mgr_.reset(new DBTableWalkMgr());
      50      135950 :     for (int i = 0; i < PartitionCount(); i++) {
      51      108550 :         partitions_.push_back(new DBPartition(this, i));
      52             :     }
      53       27400 : }
      54             : 
      55       27400 : DB::~DB() {
      56       27400 :     Clear();
      57       27400 : }
      58             : 
      59     2355471 : DBPartition *DB::GetPartition(int index) {
      60     2355471 :     return partitions_[index];
      61             : }
      62             : 
      63     6252277 : const DBPartition *DB::GetPartition(int index) const {
      64     6252277 :     return partitions_[index];
      65             : }
      66             : 
      67     1523200 : DBTableBase *DB::FindTable(const string &name) {
      68     1523200 :     TableMap::iterator loc = tables_.find(name);
      69     1522522 :     if (loc != tables_.end()) {
      70     1466296 :         DBTableBase *tbl_base = loc->second;
      71     1466241 :         return tbl_base;
      72             :     }
      73       56328 :     return NULL;
      74             : }
      75             : 
      76           0 : DB::iterator DB::FindTableIter(const string &name) {
      77           0 :     return tables_.find(name);
      78             : }
      79             : 
      80     1233118 : void DB::AddTable(DBTableBase *tbl_base) {
      81             :     pair<TableMap::iterator, bool> result =
      82     1233118 :             tables_.insert(make_pair(tbl_base->name(), tbl_base));
      83     1233118 :     assert(result.second);
      84     1233118 : }
      85             : 
      86      288648 : void DB::RemoveTable(DBTableBase *tbl_base) {
      87      288648 :     tables_.erase(tbl_base->name());
      88      288648 : }
      89             : 
      90     1663763 : bool DB::IsDBQueueEmpty() const {
      91     7796014 :     for (int i = 0; i < PartitionCount(); i++) {
      92     6252277 :         if (!GetPartition(i)->IsDBQueueEmpty()) return false;
      93             :     }
      94             : 
      95     1543737 :     return true;
      96             : }
      97             : 
      98      288714 : DBTableBase *DB::CreateTable(const string &name) {
      99      288714 :     FactoryMap *factory_map = factories();
     100      288709 :     string prefix = name;
     101      527966 :     while (prefix.size()) {
     102      527945 :         FactoryMap::iterator loc = factory_map->find(prefix);
     103      527641 :         if (loc != factory_map->end()) {
     104      288632 :             DBTableBase *tbl_base = (loc->second)(this, name);
     105      288663 :             std::scoped_lock lock(mutex_);
     106      288767 :             tables_.insert(make_pair(name, tbl_base));
     107      288767 :             return tbl_base;
     108      288767 :         }
     109      239114 :         size_t index = prefix.find('.');
     110      239196 :         if (index == string::npos) {
     111           0 :             break;
     112             :         }
     113      239196 :         if (index == (prefix.length()-1)) {
     114           0 :             break;
     115             :         }
     116      239217 :         prefix = prefix.substr(index+1);
     117             :     }
     118           0 :     return NULL;
     119      288768 : }
     120             : 
     121          30 : DBGraph *DB::GetGraph(const std::string &name) {
     122          30 :     GraphMap::iterator loc = graph_map_.find(name);
     123          30 :     if (loc != graph_map_.end()) {
     124          30 :         return loc->second;
     125             :     }
     126           0 :     return NULL;
     127             : }
     128             : 
     129           6 : void DB::SetGraph(const std::string &name, DBGraph *graph) {
     130             :     pair<GraphMap::iterator, bool> result =
     131           6 :         graph_map_.insert(make_pair(name, graph));
     132           6 :     assert(result.second);
     133           6 : }
     134             : 
     135          10 : void DB::SetQueueDisable(bool disable) {
     136          44 :     for (int i = 0; i < PartitionCount(); i++) {
     137          34 :         partitions_[i]->SetQueueDisable(disable);
     138             :     }
     139          10 : }
     140             : 
     141       35459 : void DB::Clear() {
     142       35459 :     STLDeleteElements(&tables_);
     143       35459 :     STLDeleteValues(&partitions_);
     144       35459 : }