← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/logging_stats/scoreboard.cc

  • Committer: Olaf van der Spek
  • Date: 2011-07-05 16:50:17 UTC
  • mto: This revision was merged to the branch mainline in revision 2384.
  • Revision ID: olafvdspek@gmail.com-20110705165017-8ixqna9ucpfwn0yz
Refactor Scoreboard

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/logging_stats/scoreboard.cc
63
63
  /* calculate the number of elements in each bucket */
64
64
  number_per_bucket= static_cast<uint32_t> ( ceil( static_cast<double>(number_sessions) / static_cast<double>(number_buckets) ) );
65
65
 
 
66
  vector_of_scoreboard_vectors.reserve(number_buckets);
66
67
  /* populate the vector of scoreboard vectors */
67
68
  for (uint32_t j= 0; j < number_buckets; ++j)
68
69
  {
69
 
    vector<ScoreboardSlot* > *scoreboard_vector= new vector<ScoreboardSlot* >();
 
70
    vector<ScoreboardSlot* > *scoreboard_vector= new vector<ScoreboardSlot*>;
70
71
 
 
72
    scoreboard_vector->reserve(number_per_bucket);
71
73
    /* preallocate the individual vectors */
72
 
    vector<ScoreboardSlot* >::iterator scoreboard_vector_iterator= scoreboard_vector->begin();
73
74
    for (uint32_t h= 0; h < number_per_bucket; ++h)
74
 
    {
75
 
      ScoreboardSlot *scoreboard_slot= new ScoreboardSlot();
76
 
      scoreboard_vector_iterator= scoreboard_vector->insert(scoreboard_vector_iterator, scoreboard_slot);
77
 
    }  
78
 
    scoreboard_vector->resize(number_per_bucket);
79
 
 
 
75
      scoreboard_vector->push_back(new ScoreboardSlot);
80
76
 
81
77
    /* insert the vector into the vector of scoreboard vectors */
82
 
    vector<vector<ScoreboardSlot* >* >::iterator vector_of_scoreboard_vectors_iterator= 
83
 
      vector_of_scoreboard_vectors.begin();
84
 
 
85
 
    vector_of_scoreboard_vectors_iterator= 
86
 
      vector_of_scoreboard_vectors.insert(vector_of_scoreboard_vectors_iterator, scoreboard_vector); 
 
78
    vector_of_scoreboard_vectors.push_back(scoreboard_vector); 
87
79
  }
88
 
  vector_of_scoreboard_vectors.resize(number_buckets);
89
80
  
 
81
  vector_of_scoreboard_locks.reserve(number_buckets);
90
82
  /* populate the scoreboard locks vector each ScoreboardSlot vector gets a lock */
91
 
  vector<boost::shared_mutex* >::iterator vector_of_scoreboard_locks_iterator= vector_of_scoreboard_locks.begin();
92
83
  for (uint32_t k= 0; k < number_buckets; ++k)
93
 
  {
94
 
    boost::shared_mutex* lock= new boost::shared_mutex();
95
 
    vector_of_scoreboard_locks_iterator= 
96
 
      vector_of_scoreboard_locks.insert(vector_of_scoreboard_locks_iterator, lock);   
97
 
  } 
98
 
  vector_of_scoreboard_locks.resize(number_buckets);
 
84
    vector_of_scoreboard_locks.push_back(new boost::shared_mutex);
99
85
 
100
86
  /* calculate the approximate memory allocation of the scoreboard */
101
87
  size_t statusVarsSize= sizeof(StatusVars) + sizeof(system_status_var);
106
92
 
107
93
Scoreboard::~Scoreboard()
108
94
{
109
 
  vector<vector<ScoreboardSlot* >* >::iterator v_of_scoreboard_v_begin_it= vector_of_scoreboard_vectors.begin();
110
 
  vector<vector<ScoreboardSlot* >* >::iterator v_of_scoreboard_v_end_it= vector_of_scoreboard_vectors.end();
111
 
 
112
 
  for (; v_of_scoreboard_v_begin_it != v_of_scoreboard_v_end_it; ++v_of_scoreboard_v_begin_it)
113
 
  {
114
 
    vector<ScoreboardSlot* > *scoreboard_vector= *v_of_scoreboard_v_begin_it; 
115
 
 
116
 
    vector<ScoreboardSlot* >::iterator scoreboard_vector_it= scoreboard_vector->begin();
117
 
    vector<ScoreboardSlot* >::iterator scoreboard_vector_end= scoreboard_vector->end();
118
 
    for (; scoreboard_vector_it != scoreboard_vector_end; ++scoreboard_vector_it)
119
 
    {
120
 
      delete *scoreboard_vector_it; 
121
 
    }
122
 
    
123
 
    scoreboard_vector->clear();
124
 
    delete scoreboard_vector;
125
 
  } // vector_of_scoreboard_vectors is not on the stack and does not deletion
126
 
  
127
 
  vector<boost::shared_mutex* >::iterator vector_of_scoreboard_locks_it= vector_of_scoreboard_locks.begin();
128
 
  vector<boost::shared_mutex* >::iterator vector_of_scoreboard_locks_end= vector_of_scoreboard_locks.end();
129
 
 
130
 
  for (; vector_of_scoreboard_locks_it != vector_of_scoreboard_locks_end; ++vector_of_scoreboard_locks_it)
131
 
  {
132
 
    boost::shared_mutex* lock= *vector_of_scoreboard_locks_it;
133
 
    delete lock;
 
95
  BOOST_FOREACH(std::vector<ScoreboardSlot*>* it0, vector_of_scoreboard_vectors)
 
96
  {
 
97
    BOOST_FOREACH(ScoreboardSlot* it, *it0)
 
98
      delete it; 
 
99
    delete it0;
134
100
  }
 
101
  BOOST_FOREACH(boost::shared_mutex* it, vector_of_scoreboard_locks)
 
102
    delete it;
135
103
}
136
104
 
137
 
uint32_t Scoreboard::getBucketNumber(Session *session)
 
105
uint32_t Scoreboard::getBucketNumber(Session *session) const
138
106
{
139
 
  return (session->getSessionId() % number_buckets);
 
107
  return session->getSessionId() % number_buckets;
140
108
}
141
109
 
142
110
ScoreboardSlot* Scoreboard::findScoreboardSlotToLog(Session *session) 
150
118
  /* Check if this session has already claimed a slot */
151
119
  int32_t session_scoreboard_slot= session->getScoreboardIndex();
152
120
 
153
 
  if (session_scoreboard_slot == -1)
154
 
  {
155
 
    boost::shared_mutex* LOCK_scoreboard_vector= vector_of_scoreboard_locks.at(bucket_number);
156
 
    LOCK_scoreboard_vector->lock();
157
 
 
158
 
    ScoreboardSlot *scoreboard_slot= NULL;
159
 
 
160
 
    int32_t slot_index= 0;
161
 
    for (vector<ScoreboardSlot *>::iterator it= scoreboard_vector->begin();
162
 
         it != scoreboard_vector->end(); ++it, ++slot_index)
163
 
    {
164
 
      scoreboard_slot= *it;
165
 
 
166
 
      if (scoreboard_slot->isInUse() == false)
167
 
      {
168
 
        scoreboard_slot->setInUse(true);
169
 
        scoreboard_slot->setSessionId(session->getSessionId());
170
 
        scoreboard_slot->setUser(session->user()->username());
171
 
        scoreboard_slot->setIp(session->user()->address());
172
 
        session->setScoreboardIndex(slot_index);
173
 
        LOCK_scoreboard_vector->unlock();
174
 
        return scoreboard_slot; 
175
 
      }
176
 
    }
177
 
  
178
 
    LOCK_scoreboard_vector->unlock(); 
179
 
  } 
180
 
  else // already claimed a slot just do a lookup
181
 
  {
182
 
    ScoreboardSlot *scoreboard_slot= scoreboard_vector->at(session_scoreboard_slot);
183
 
    return scoreboard_slot;  
 
121
  if (session_scoreboard_slot != -1)
 
122
    return scoreboard_vector->at(session_scoreboard_slot);
 
123
 
 
124
  boost::shared_mutex* LOCK_scoreboard_vector= vector_of_scoreboard_locks.at(bucket_number);
 
125
  LOCK_scoreboard_vector->lock();
 
126
 
 
127
  int32_t slot_index= 0;
 
128
  for (vector<ScoreboardSlot*>::iterator it= scoreboard_vector->begin(); it != scoreboard_vector->end(); ++it, ++slot_index)
 
129
  {
 
130
    ScoreboardSlot& slot= **it;
 
131
    if (slot.isInUse())
 
132
      continue;
 
133
    slot.setInUse(true);
 
134
    slot.setSessionId(session->getSessionId());
 
135
    slot.setUser(session->user()->username());
 
136
    slot.setIp(session->user()->address());
 
137
    session->setScoreboardIndex(slot_index);
 
138
    LOCK_scoreboard_vector->unlock();
 
139
    return &slot; 
184
140
  }
185
141
 
 
142
  LOCK_scoreboard_vector->unlock(); 
 
143
 
186
144
  /* its possible we did not claim a slot if the scoreboard size is somehow smaller then the 
187
145
     active connections */ 
188
146
  return NULL; 
190
148
 
191
149
ScoreboardSlot* Scoreboard::findOurScoreboardSlot(Session *session)
192
150
{
193
 
  /* our bucket */
194
 
  uint32_t bucket_number= getBucketNumber(session);
195
 
 
196
 
  /* our vector corresponding to bucket_number */
197
 
  vector<ScoreboardSlot* > *scoreboard_vector= vector_of_scoreboard_vectors.at(bucket_number);
198
 
 
199
151
  /* Check if this session has already claimed a slot */
200
152
  int32_t session_scoreboard_slot= session->getScoreboardIndex();
201
 
 
202
153
  if (session_scoreboard_slot == -1) 
203
 
  {
204
154
    return NULL;
205
 
  }
206
 
 
207
 
  ScoreboardSlot *scoreboard_slot= scoreboard_vector->at(session_scoreboard_slot);
208
 
  return scoreboard_slot;
 
155
  return vector_of_scoreboard_vectors.at(getBucketNumber(session))->at(session_scoreboard_slot);
209
156
}