00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00047 #include <config.h>
00048 #include <drizzled/plugin.h>
00049 #include "scoreboard.h"
00050
00051 #include <math.h>
00052
00053 using namespace drizzled;
00054 using namespace std;
00055
00056 Scoreboard::Scoreboard(uint32_t in_number_sessions, uint32_t in_number_buckets)
00057 :
00058 number_sessions(in_number_sessions),
00059 number_buckets(in_number_buckets)
00060 {
00061
00062
00063 number_per_bucket= static_cast<uint32_t> ( ceil( static_cast<double>(number_sessions) / static_cast<double>(number_buckets) ) );
00064
00065
00066 for (uint32_t j= 0; j < number_buckets; ++j)
00067 {
00068 vector<ScoreboardSlot* > *scoreboard_vector= new vector<ScoreboardSlot* >();
00069
00070
00071 vector<ScoreboardSlot* >::iterator scoreboard_vector_iterator= scoreboard_vector->begin();
00072 for (uint32_t h= 0; h < number_per_bucket; ++h)
00073 {
00074 ScoreboardSlot *scoreboard_slot= new ScoreboardSlot();
00075 scoreboard_vector_iterator= scoreboard_vector->insert(scoreboard_vector_iterator, scoreboard_slot);
00076 }
00077 scoreboard_vector->resize(number_per_bucket);
00078
00079
00080
00081 vector<vector<ScoreboardSlot* >* >::iterator vector_of_scoreboard_vectors_iterator=
00082 vector_of_scoreboard_vectors.begin();
00083
00084 vector_of_scoreboard_vectors_iterator=
00085 vector_of_scoreboard_vectors.insert(vector_of_scoreboard_vectors_iterator, scoreboard_vector);
00086 }
00087 vector_of_scoreboard_vectors.resize(number_buckets);
00088
00089
00090 vector<boost::shared_mutex* >::iterator vector_of_scoreboard_locks_iterator= vector_of_scoreboard_locks.begin();
00091 for (uint32_t k= 0; k < number_buckets; ++k)
00092 {
00093 boost::shared_mutex* lock= new boost::shared_mutex();
00094 vector_of_scoreboard_locks_iterator=
00095 vector_of_scoreboard_locks.insert(vector_of_scoreboard_locks_iterator, lock);
00096 }
00097 vector_of_scoreboard_locks.resize(number_buckets);
00098
00099
00100 size_t statusVarsSize= sizeof(StatusVars) + sizeof(system_status_var);
00101 size_t userCommandsSize= sizeof(UserCommands) + sizeof(uint64_t) * SQLCOM_END;
00102
00103 scoreboard_size_bytes= (statusVarsSize + userCommandsSize) * number_per_bucket * number_buckets;
00104 }
00105
00106 Scoreboard::~Scoreboard()
00107 {
00108 vector<vector<ScoreboardSlot* >* >::iterator v_of_scoreboard_v_begin_it= vector_of_scoreboard_vectors.begin();
00109 vector<vector<ScoreboardSlot* >* >::iterator v_of_scoreboard_v_end_it= vector_of_scoreboard_vectors.end();
00110
00111 for (; v_of_scoreboard_v_begin_it != v_of_scoreboard_v_end_it; ++v_of_scoreboard_v_begin_it)
00112 {
00113 vector<ScoreboardSlot* > *scoreboard_vector= *v_of_scoreboard_v_begin_it;
00114
00115 vector<ScoreboardSlot* >::iterator scoreboard_vector_it= scoreboard_vector->begin();
00116 vector<ScoreboardSlot* >::iterator scoreboard_vector_end= scoreboard_vector->end();
00117 for (; scoreboard_vector_it != scoreboard_vector_end; ++scoreboard_vector_it)
00118 {
00119 delete *scoreboard_vector_it;
00120 }
00121
00122 scoreboard_vector->clear();
00123 delete scoreboard_vector;
00124 }
00125
00126 vector<boost::shared_mutex* >::iterator vector_of_scoreboard_locks_it= vector_of_scoreboard_locks.begin();
00127 vector<boost::shared_mutex* >::iterator vector_of_scoreboard_locks_end= vector_of_scoreboard_locks.end();
00128
00129 for (; vector_of_scoreboard_locks_it != vector_of_scoreboard_locks_end; ++vector_of_scoreboard_locks_it)
00130 {
00131 boost::shared_mutex* lock= *vector_of_scoreboard_locks_it;
00132 delete lock;
00133 }
00134 }
00135
00136 uint32_t Scoreboard::getBucketNumber(Session *session)
00137 {
00138 return (session->getSessionId() % number_buckets);
00139 }
00140
00141 ScoreboardSlot* Scoreboard::findScoreboardSlotToLog(Session *session)
00142 {
00143
00144 uint32_t bucket_number= getBucketNumber(session);
00145
00146
00147 vector<ScoreboardSlot* > *scoreboard_vector= vector_of_scoreboard_vectors.at(bucket_number);
00148
00149
00150 int32_t session_scoreboard_slot= session->getScoreboardIndex();
00151
00152 if (session_scoreboard_slot == -1)
00153 {
00154 boost::shared_mutex* LOCK_scoreboard_vector= vector_of_scoreboard_locks.at(bucket_number);
00155 LOCK_scoreboard_vector->lock();
00156
00157 ScoreboardSlot *scoreboard_slot= NULL;
00158
00159 int32_t slot_index= 0;
00160 for (vector<ScoreboardSlot *>::iterator it= scoreboard_vector->begin();
00161 it != scoreboard_vector->end(); ++it, ++slot_index)
00162 {
00163 scoreboard_slot= *it;
00164
00165 if (scoreboard_slot->isInUse() == false)
00166 {
00167 scoreboard_slot->setInUse(true);
00168 scoreboard_slot->setSessionId(session->getSessionId());
00169 scoreboard_slot->setUser(session->user()->username());
00170 scoreboard_slot->setIp(session->user()->address());
00171 session->setScoreboardIndex(slot_index);
00172 LOCK_scoreboard_vector->unlock();
00173 return scoreboard_slot;
00174 }
00175 }
00176
00177 LOCK_scoreboard_vector->unlock();
00178 }
00179 else
00180 {
00181 ScoreboardSlot *scoreboard_slot= scoreboard_vector->at(session_scoreboard_slot);
00182 return scoreboard_slot;
00183 }
00184
00185
00186
00187 return NULL;
00188 }
00189
00190 ScoreboardSlot* Scoreboard::findOurScoreboardSlot(Session *session)
00191 {
00192
00193 uint32_t bucket_number= getBucketNumber(session);
00194
00195
00196 vector<ScoreboardSlot* > *scoreboard_vector= vector_of_scoreboard_vectors.at(bucket_number);
00197
00198
00199 int32_t session_scoreboard_slot= session->getScoreboardIndex();
00200
00201 if (session_scoreboard_slot == -1)
00202 {
00203 return NULL;
00204 }
00205
00206 ScoreboardSlot *scoreboard_slot= scoreboard_vector->at(session_scoreboard_slot);
00207 return scoreboard_slot;
00208 }