← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/logging_stats/scoreboard.cc

  • Committer: lbieber
  • Date: 2010-08-08 05:04:06 UTC
  • mfrom: (1694.2.1 staging)
  • Revision ID: lbieber@orisndriz03-20100808050406-h9b0lzvpwkp3ng2x
 Merge Stewart - recent patch didn't have updated result files for embedded_innodb when the handling of default values was fixed in the table proto
 Merge Joe Daly - use boost::shared_mutex for locking

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/logging_stats/scoreboard.cc
87
87
  vector_of_scoreboard_vectors.resize(number_buckets);
88
88
  
89
89
  /* populate the scoreboard locks vector each ScoreboardSlot vector gets a lock */
90
 
  vector<pthread_rwlock_t* >::iterator vector_of_scoreboard_locks_iterator= vector_of_scoreboard_locks.begin();
 
90
  vector<boost::shared_mutex* >::iterator vector_of_scoreboard_locks_iterator= vector_of_scoreboard_locks.begin();
91
91
  for (uint32_t k= 0; k < number_buckets; ++k)
92
92
  {
93
 
    pthread_rwlock_t* lock= new pthread_rwlock_t();
94
 
    (void) pthread_rwlock_init(lock, NULL);
 
93
    boost::shared_mutex* lock= new boost::shared_mutex();
95
94
    vector_of_scoreboard_locks_iterator= 
96
95
      vector_of_scoreboard_locks.insert(vector_of_scoreboard_locks_iterator, lock);   
97
96
  } 
118
117
    delete scoreboard_vector;
119
118
  } // vector_of_scoreboard_vectors is not on the stack and does not deletion
120
119
  
121
 
  vector<pthread_rwlock_t* >::iterator vector_of_scoreboard_locks_it= vector_of_scoreboard_locks.begin();
122
 
  vector<pthread_rwlock_t* >::iterator vector_of_scoreboard_locks_end= vector_of_scoreboard_locks.end();
 
120
  vector<boost::shared_mutex* >::iterator vector_of_scoreboard_locks_it= vector_of_scoreboard_locks.begin();
 
121
  vector<boost::shared_mutex* >::iterator vector_of_scoreboard_locks_end= vector_of_scoreboard_locks.end();
123
122
 
124
123
  for (; vector_of_scoreboard_locks_it != vector_of_scoreboard_locks_end; ++vector_of_scoreboard_locks_it)
125
124
  {
126
 
    pthread_rwlock_t* lock= *vector_of_scoreboard_locks_it;
127
 
    (void) pthread_rwlock_destroy(lock);
 
125
    boost::shared_mutex* lock= *vector_of_scoreboard_locks_it;
128
126
    delete lock;
129
127
  }
130
128
}
147
145
 
148
146
  if (session_scoreboard_slot == -1)
149
147
  {
150
 
    pthread_rwlock_t *LOCK_scoreboard_vector= vector_of_scoreboard_locks.at(bucket_number);
151
 
    pthread_rwlock_wrlock(LOCK_scoreboard_vector);
152
 
 
 
148
    boost::shared_mutex* LOCK_scoreboard_vector= vector_of_scoreboard_locks.at(bucket_number);
 
149
    LOCK_scoreboard_vector->lock();
 
150
 
153
151
    ScoreboardSlot *scoreboard_slot= NULL;
154
152
 
155
153
    int32_t slot_index= 0;
165
163
        scoreboard_slot->setUser(session->getSecurityContext().getUser());
166
164
        scoreboard_slot->setIp(session->getSecurityContext().getIp());
167
165
        session->setScoreboardIndex(slot_index);
168
 
        pthread_rwlock_unlock(LOCK_scoreboard_vector);
 
166
        LOCK_scoreboard_vector->unlock();
169
167
        return scoreboard_slot; 
170
168
      }
171
169
    }
172
 
 
173
 
    pthread_rwlock_unlock(LOCK_scoreboard_vector);
 
170
  
 
171
    LOCK_scoreboard_vector->unlock(); 
174
172
  } 
175
173
  else // already claimed a slot just do a lookup
176
174
  {