Classe que implementa uma lista duplamente encadeada com os clientes para os quais desejamos enviar dados. More...
#include <StreamControl.h>
Public Member Functions | |
| CClientHeap (unsigned int MaxClientsCredits) | |
| CClientHeap construtor da classe, chamado quando um objeto e criado usando o comando new. | |
| ~CClientHeap () | |
| ~CClientHeap destrutor da classe, chamado quando um objeto e removido com o comando delete. | |
| int | Insert (FragmentInfo *fip) |
| Insert Insere um objeto FragmentInfo no final da fila do cliente associado a este fragmento. | |
| void | GetFragments (TFragments &Fragments) |
| GetFragments Retorna os fragmentos do cliente associado ao topo do heap, se o heap nao estiver vazio. | |
Private Member Functions | |
| CClientInfo * | FindClient (int ip, int port) |
| FindClient verifica se existe, no heap, o cliente identificado pela sua conexao com o servidor, composta por seu endereco IP e por sua porta. | |
| CClientInfo * | CreateClient (int ip, int port, unsigned long long int TimeBetweenCredits) |
| CreateClient insere no heap o cliente identificado pela sua conexao com o servidor, composta por seu endereco IP e por sua porta. | |
| bool | RemoveClient (CClientInfo *Client) |
| CreateClient Funcao para remover do heap o cliente cujo ponteiro e passado como parametro. | |
Private Attributes | |
| unsigned int | m_MaxClientsCredits |
| Variavel que armazena o numero de creditos dos clientes ao enviar fragmentos. | |
| TClientsHeap | m_ClientsHeap |
| Heap usado para armazenar os clientes ativos no servidor. | |
| TClientsMap | m_ClientsMap |
| Mapa usado para acelerar a busca por um cliente no heap (usado ao copiarmos os fragmentos do pool para a lista dos clientes). | |
| CClientInfo * | m_LastClient |
| Ponteiro para o ultimo cliente achado pela funcao FindClient. | |
| pthread_mutex_t | m_AccessClients |
| Mutex para garantir o acesso exclusivo ao mapa descrito anteriormente, e a variavel m_LastClient. | |
| pthread_mutex_t | m_AccessClientsHeap |
| Mutex para garantir o acesso exclusivo ao heap descrito anteriormente. | |
| pthread_cond_t | m_WaitClients |
| Variavel de condicao usada pela thread que processa os clientes para esperar pelo evento indicando que o heap m_AccessClientsHeap da classe deixou de ficar vazio, isto e, um cliente possui fragmentos para serem enviados. | |
Classe que implementa uma lista duplamente encadeada com os clientes para os quais desejamos enviar dados.
Existira uma entrada para cada cliente ativo na lista. O objetivo da lista de um cliente e o de controlar o fluxo de saida para este cliente. Somente se o cliente possuir credito e que um dos objetos serao repassados a lista de controle de fluxo do servidor. Usada pela thread que gerencia os objetos FragmentInfo que devem ser enviados aos clientes.
Definition at line 567 of file StreamControl.h.
| CClientHeap::CClientHeap | ( | unsigned int | MaxClientsCredits | ) |
CClientHeap construtor da classe, chamado quando um objeto e criado usando o comando new.
| MaxClientsCredits | valor inteiro (nao sinalizado), definindo o numero maximo de creditos dos clientes associados ao heap. |
Definition at line 1064 of file StreamControl.cpp.
01065 { 01066 #ifdef RIO_DEBUG1 01067 RioErr << "[CClientHeap - Construtor] Start" << endl; 01068 #endif 01069 01070 // Inicializa as variaveis da classe 01071 // ClientsHeap: a fila de prioridades nao precisa ser inicializada. 01072 // ClientsMap: o mapa dos clientes nao precisa ser inicializado. 01073 m_MaxClientsCredits = MaxClientsCredits; 01074 // Inicializa a variavel m_LastClient. 01075 m_LastClient = NULL; 01076 // Cria o mutex usado para garantir o acesso exclusivo ao mapa e a 01077 // variavel m_LastClient. 01078 pthread_mutex_init( &m_AccessClients, NULL ); 01079 // Cria o mutex usado para garantir o acesso exclusivo ao heap. 01080 pthread_mutex_init( &m_AccessClientsHeap, NULL ); 01081 // Cria a variavel de condicao da classe (usada para esperar por clientes). 01082 pthread_cond_init( &m_WaitClients, NULL ); 01083 01084 #ifdef RIO_DEBUG1 01085 RioErr << "[CClientHeap - Construtor] Finish" << endl; 01086 #endif 01087 }
| CClientHeap::~CClientHeap | ( | ) |
~CClientHeap destrutor da classe, chamado quando um objeto e removido com o comando delete.
Definition at line 1090 of file StreamControl.cpp.
01091 { 01092 #ifdef RIO_DEBUG1 01093 RioErr << "[CClientHeap - Destrutor] Start" << endl; 01094 #endif 01095 01096 // Remove o mutex usado para garantir o acesso exclusivo ao mapa e a 01097 // variavel m_LastClient. 01098 pthread_mutex_destroy( &m_AccessClients ); 01099 // Remove o mutex da classe para o acesso ao heap. 01100 pthread_mutex_destroy( &m_AccessClientsHeap ); 01101 // Cria a variavel de condicao da classe (usada para esperar por clientes). 01102 pthread_cond_destroy( &m_WaitClients ); 01103 01104 #ifdef RIO_DEBUG1 01105 RioErr << "[CClientHeap - Destrutor] Finish" << endl; 01106 #endif 01107 }
| CClientInfo * CClientHeap::CreateClient | ( | int | ip, | |
| int | port, | |||
| unsigned long long int | TimeBetweenCredits | |||
| ) | [private] |
CreateClient insere no heap o cliente identificado pela sua conexao com o servidor, composta por seu endereco IP e por sua porta.
Um sinal para a variavel de condicao m_WaitClients sera gerado para desbloquear, se necessario, uma thread que pode ter sido bloqueada nesta variavel de condicao, ao executar a funcao GetFragments, caso o heap estivesse vazio quando a thread executou a funcao.
| ip | endereco IP do cliente a ser inserido no heap. | |
| port | porta do cliente a ser inserido no heap. | |
| TimeBetweenCredits | tempo em microsegundos entre duas atualizacoes do credito do cliente inserido no heap. |
Definition at line 1173 of file StreamControl.cpp.
01175 { 01176 unsigned long long int ClientMapId; 01177 CClientInfo *Client; 01178 01179 #ifdef RIO_DEBUG1 01180 RioErr << "[CClientHeap - CreateClient] Start" << endl; 01181 #endif 01182 01183 #ifdef RIO_DEBUG2 01184 struct in_addr clientaddr; 01185 clientaddr.s_addr = ip; 01186 RioErr << "CClientList::CreateClient criando uma lista para o cliente com " 01187 << "o IP " << inet_ntoa( clientaddr ) << " e a porta " 01188 << ntohs( port ) << endl; 01189 #endif 01190 // Tentamos criar uma lista para o cliente identificado por IP e port. 01191 Client = new CClientInfo( m_MaxClientsCredits, TimeBetweenCredits, ip, 01192 port ); 01193 if( Client == NULL ) 01194 { 01195 01196 #ifdef RIO_DEBUG1 01197 RioErr << "[CClientHeap - CreateClient] Finish1" << endl; 01198 #endif 01199 01200 return NULL; 01201 } 01202 // Adiciona o cliente no heap. 01203 // Obtem acesso exclusivo ao heap. 01204 pthread_mutex_lock( &m_AccessClientsHeap ); 01205 // Verifica se o heap esta vazio, pois neste caso, precisamos gerar um 01206 // sinal para desbloquear a thread m_ClientsThread que processa os 01207 // clientes do heap 01208 if( m_ClientsHeap.empty() ) 01209 pthread_cond_signal( &m_WaitClients ); 01210 m_ClientsHeap.push( Client ); 01211 // Libera o acesso exclusivo ao heap. 01212 pthread_mutex_unlock( &m_AccessClientsHeap ); 01213 // Determina o ID (com 64 bits) do cliente (os 32 bits superiores sao a 01214 // porta do cliente, e os 32 bits inferiores sao o IP do cliente). 01215 ClientMapId = ( unsigned int ) port; 01216 ClientMapId = ( ClientMapId << 32 ) | ( ( unsigned int ) ip ); 01217 // Devemos agora inserir o cliente no mapa. 01218 m_ClientsMap.insert( pair< unsigned long long int, CClientInfo * > 01219 ( ClientMapId, Client ) ); 01220 #ifdef RIO_DEBUG2 01221 RioErr << "CClientList::CreateClient inserindo no mapa o cliente com o IP " 01222 << inet_ntoa( clientaddr ) << ", a porta " << ntohs( port ) 01223 << ", e a ID " << ClientMapId << endl; 01224 #endif 01225 01226 #ifdef RIO_DEBUG1 01227 RioErr << "[CClientHeap - CreateClient] Finish2" << endl; 01228 #endif 01229 01230 return Client; 01231 }
| CClientInfo * CClientHeap::FindClient | ( | int | ip, | |
| int | port | |||
| ) | [private] |
FindClient verifica se existe, no heap, o cliente identificado pela sua conexao com o servidor, composta por seu endereco IP e por sua porta.
| ip | endereco IP do cliente a ser procurado no heap. | |
| port | porta do cliente a ser procurado no heap. |
Definition at line 1113 of file StreamControl.cpp.
01114 { 01115 unsigned long long int ClientMapId; 01116 // Define um iterador para uma posicao qualquer do mapa, e um iterador para 01117 // o final do mapa. 01118 TClientsMap::iterator ClientIt, EndIt; 01119 01120 #ifdef RIO_DEBUG1 01121 RioErr << "[CClientHeap - FindClient] Start" << endl; 01122 #endif 01123 01124 #ifdef RIO_DEBUG2 01125 struct in_addr clientaddr; 01126 clientaddr.s_addr = ip; 01127 RioErr << "CClientList::FindClient procurando pelo cliente com o IP " 01128 << inet_ntoa( clientaddr ) << " e a porta " 01129 << ntohs( port ) << endl; 01130 #endif 01131 // Determina o ID (com 64 bits) do cliente (os 32 bits superiores sao a 01132 // porta do cliente, e os 32 bits inferiores sao o IP do cliente). 01133 ClientMapId = ( unsigned int ) port; 01134 ClientMapId = ( ClientMapId << 32 ) | ( ( unsigned int ) ip ); 01135 // Verifica se o cliente com a ID computada anteriormente esta no mapa. 01136 ClientIt = m_ClientsMap.find( ClientMapId ); 01137 EndIt = m_ClientsMap.end(); 01138 if( ClientIt != EndIt ) 01139 { 01140 #ifdef RIO_DEBUG2 01141 RioErr << "CClientList::FindClient cliente com a ID " << ClientMapId 01142 << " achado no mapa." << endl; 01143 #endif 01144 01145 #ifdef RIO_DEBUG1 01146 RioErr << "[CClientHeap - FindClient] Finish1" << endl; 01147 #endif 01148 01149 // Se o cliente estiver no mapa, entao retornamos um ponteiro para uma 01150 // estrutura CHeapElement com as informacoes do cliente (este ponteiro 01151 // e dado por it->second. O valor id->first e igual ao valor de ID). 01152 return ClientIt->second; 01153 } 01154 else 01155 { 01156 #ifdef RIO_DEBUG2 01157 RioErr << "CClientList::FindClient cliente com a ID " << ClientMapId 01158 << " nao achado no mapa." << endl; 01159 #endif 01160 01161 #ifdef RIO_DEBUG1 01162 RioErr << "[CClientHeap - FindClient] Finish2" << endl; 01163 #endif 01164 01165 // Se o cliente nao estiver no mapa, entao retornamos NULL. 01166 return NULL; 01167 } 01168 }
| void CClientHeap::GetFragments | ( | TFragments & | Fragments | ) |
GetFragments Retorna os fragmentos do cliente associado ao topo do heap, se o heap nao estiver vazio.
Este cliente sera aquele com o tempo de atualizacao dos creditos mais proximo do tempo atual. Apos remover o cliente do heap, os creditos do cliente serao atualizados apos esperarmos pelo tempo desta atualizacao (usando a funcao usleep), e apos isso, um numero de fragmentos nao maior do que o numero de creditos deste cliente (que pode ser menor do que este numero caso a fila do cliente possua menos fragmentos do que o numero de creditos) sera retornado pela funcao. Se nao existirem fragmentos a serem enviados para este cliente (o cliente pode estar inativo), o cliente sera novamente inserido no heap, na ordem do proximo tempo da sua atualizacao de credito, se o contador de inatividade nao for nulo. Se ele for nulo, o cliente nao sera inserido no heap, e seu objeto da classe CClientInfo sera removido. Agora, se o heap estiver vazio, a thread que executou a funcao sera bloqueada na variavel de condicao m_WaitClients ate que um cliente seja inserido no heap (por outra thread) a partir da funcao Insert.
Definition at line 1378 of file StreamControl.cpp.
01379 { 01380 unsigned long long int CurrentTime, UpdateTime; 01381 bool InsertClient; 01382 FragmentInfo *fip; 01383 CClientInfo *Client; 01384 struct timeval tvCurrentTime; 01385 01386 #ifdef RIO_DEBUG1 01387 RioErr << "[CClientHeap - GetFragments] Start" << endl; 01388 #endif 01389 01390 // Obtem a cabeca do heap. 01391 // Obtem acesso exclusivo ao heap. 01392 pthread_mutex_lock( &m_AccessClientsHeap ); 01393 // Verifica se existem elementos no heap. Caso o heap esteja vazio, espera 01394 // pela chegada de novos clientes. 01395 if( m_ClientsHeap.empty() ) 01396 pthread_cond_wait( &m_WaitClients, &m_AccessClientsHeap ); 01397 // Agora que temos pelo menos um cliente (pois o heap nao esta vazio), 01398 // entao vamos processar o proximo cliente, que esta no topo do heap, 01399 // associado ao evento que devera ser primeiramente executado. 01400 Client = m_ClientsHeap.top(); 01401 // Remove a cabeca do heap. 01402 m_ClientsHeap.pop(); 01403 // Libera o acesso exclusivo ao heap. 01404 pthread_mutex_unlock( &m_AccessClientsHeap ); 01405 // Obtem o tempo de atualizacao do credito. 01406 UpdateTime = Client->NextTimeToUpdateCredits(); 01407 // Determina o tempo atual. 01408 gettimeofday( &tvCurrentTime, NULL ); 01409 // Converte o tempo atual (computado anteriormente) para microsegundos. 01410 CurrentTime = ( ( unsigned long long int ) tvCurrentTime.tv_sec ) 01411 * 1000000ull + 01412 ( ( unsigned long long int ) tvCurrentTime.tv_usec ); 01413 // Verifica se precisamos dormir por alguns microsegundos. Isso ocorrera 01414 // se o tempo de atualizacao x for maior do que o tempo atual a. Se o 01415 // tempo de atualizacao x for maior, entao deverenis dormir por a - x 01416 // microsegundos. 01417 if( UpdateTime > CurrentTime ) 01418 usleep( UpdateTime - CurrentTime ); 01419 // Agora, como ja passou o tempo de atualizacao do cliente (pelo menos, 01420 // isso deveria ocorrer), atualizamos os creditos do cliente. 01421 Client->UpdateCredits(); 01422 // Inicializa a variavel que diz se devemos ou nao inserir novamente o 01423 // cliente no heap. 01424 InsertClient = true; 01425 // Verificamos se temos fragmentos para o cliente. Note que o cliente 01426 // deveria possuir creditos, pois dormimos ate o tempo da proxima 01427 // atualizacao do credito do cliente. 01428 Fragments.clear(); 01429 while ( ( fip = Client->Remove() ) != NULL ) 01430 { 01431 // Insere os fragmentos no vetor enquanto o cliente possuir creditos 01432 // ou fragmentos para serem enviados. 01433 Fragments.insert( Fragments.end(), fip ); 01434 } 01435 if( Fragments.size() > 0 ) 01436 { 01437 #ifdef RIO_DEBUG2 01438 struct in_addr clientaddr; 01439 char StrAux[ 256 ]; 01440 unsigned int f; 01441 for( f = 0; f < Fragments.size(); f++ ) 01442 { 01443 clientaddr.s_addr = Fragments[ f ]->IP; 01444 sprintf( StrAux, 01445 "enviando fragmento %u para o cliente [IP=%s,Port=%u]", 01446 f+1, inet_ntoa( clientaddr ), 01447 ntohs( Fragments[ f ]->Port ) ); 01448 RioErr << "CClientHeap::GetNextFragment " << StrAux << endl; 01449 } 01450 #endif 01451 } 01452 else 01453 { 01454 // O cliente esta inativo por muito tempo e precisa ser removido do 01455 // mapa. Como o cliente ja foi removido do heap, bastara remove-lo do 01456 // mapa e deletar a estrutura Client. Isso sera feito pela funcao 01457 // RemoveClient da classe, que retornara true se o cliente pode ser 01458 // removido. O cliente nao podera ser removido se outra thread 01459 // estiver tentando inserir fragmentos na fila dele. Note que o valor 01460 // de InsertClient e a negacao do retorno da funcao porque somente 01461 // deveremos inserir o cliente no heap se ele nao pode ser removido. 01462 InsertClient = !RemoveClient( Client ); 01463 } 01464 // Obtem acesso exclusivo ao heap. 01465 pthread_mutex_lock( &m_AccessClientsHeap ); 01466 // Se InsertClient for true, deveremos reinserir o cliente no heap. 01467 if( InsertClient ) 01468 m_ClientsHeap.push( Client ); 01469 // Libera o acesso exclusivo ao heap. 01470 pthread_mutex_unlock( &m_AccessClientsHeap ); 01471 01472 #ifdef RIO_DEBUG1 01473 RioErr << "[CClientHeap - GetFragments] Finish" << endl; 01474 #endif 01475 }
| int CClientHeap::Insert | ( | FragmentInfo * | fip | ) |
Insert Insere um objeto FragmentInfo no final da fila do cliente associado a este fragmento.
Para descobrirmos o cliente, usanmos o endereco IP e a porta dado no objeto para descobrirmos no heap o cliente associado ao fragmento. Se este cliente estiver no heap, o objeto sera inserido no filal da fila associada ao cliente. Se o cliente nao estiver no heap, um novo objeto da classe CClientInfo sera criado para o cliente, o fragmento sera depois inserido no inicio da fila do cliente e, finalmente, o cliente sera inserido no heap.
| fip | ponteiro para o objeto a ser inserido no final da fila. |
Definition at line 1294 of file StreamControl.cpp.
01295 { 01296 int result; 01297 CClientInfo *Client; 01298 01299 #ifdef RIO_DEBUG1 01300 RioErr << "[CClientHeap - Insert] Start" << endl; 01301 #endif 01302 01303 // Obtem acesso exclusivo ao mapa e a variavel m_LastClient. 01304 pthread_mutex_lock( &m_AccessClients ); 01305 // Determina se precisamos buscar um novo cliente (isso sera visto pelo par 01306 // IP, porta do cliente dado em m_LastClient. Se o valor de m_LastClient for 01307 // NULL, e se o IP ou a porta forem diferentes do cliente refenreciado por 01308 // m_LastClient, faremos uma nova busca pelo cliente e, se nao acharmos este 01309 // cliente, criaremos uma nova lista para ele. 01310 if( ( m_LastClient == NULL ) || ( m_LastClient->GetIPAddress() != fip->IP ) || 01311 ( m_LastClient->GetPort() != fip->Port ) ) 01312 { 01313 // Tenta obter a lista do cliente. Se necessario, cria uma nova lista 01314 // para o cliente. Tentaremos buscar o cliente ate conseguirmos obter 01315 // um ponteiro. 01316 Client = FindClient( fip->IP, fip->Port ); 01317 if( Client == NULL ) 01318 { 01319 // Precisamos criar uma nova lista para o cliente, pois ele nao 01320 // foi achado no mapa dos clientes. 01321 Client = CreateClient( fip->IP, fip->Port, 01322 fip->TimeBetweenCredits ); 01323 if( Client == NULL ) 01324 { 01325 01326 #ifdef RIO_DEBUG1 01327 RioErr << "[CClientHeap - Insert] Finish1" << endl; 01328 #endif 01329 01330 return ERROR_STREAMCONTROL + ERROR_MEMORY; 01331 } 01332 } 01333 m_LastClient = Client; 01334 } 01335 else 01336 Client = m_LastClient; // Como o ultimo fragmento inserido foi o do 01337 // cliente para o qual devemos enviar fip, 01338 // entao simplesmente usados o ponteiro ao 01339 // inves de busca-lo no mapa. 01340 // Libera o acesso exclusivo ao mapa e a variavel m_LastClient. 01341 pthread_mutex_unlock( &m_AccessClients ); 01342 // Agora adicionamos o novo objeto FragmentInfo na fila FIFO de objetos 01343 // do cliente referenciado por Client (ou seja, no final da fila). 01344 result = Client->Insert( fip ); 01345 if( result == S_OK ) 01346 { 01347 // Agora imprimimos a lista do cliente, com usando seu par IP, porta 01348 // para identifica-lo. 01349 #ifdef RIO_DEBUG2 01350 struct in_addr clientaddr; 01351 clientaddr.s_addr = Client->GetIPAddress(); 01352 char StrAux[ 256 ]; 01353 sprintf( StrAux, "Insercao em CClientList [IP=%s,Port=%u]", 01354 inet_ntoa( clientaddr ), ntohs( Client->GetPort() ) ); 01355 Client->PrintFragmentQueue( StrAux ); 01356 #endif 01357 01358 } 01359 01360 #ifdef RIO_DEBUG1 01361 RioErr << "[CClientHeap - Insert] Finish2" << endl; 01362 #endif 01363 01364 return result; 01365 }
| bool CClientHeap::RemoveClient | ( | CClientInfo * | Client | ) | [private] |
CreateClient Funcao para remover do heap o cliente cujo ponteiro e passado como parametro.
A funcao retorna true se a remocao do cliente foi feita com sucesso, e false se ela nao foi feita com sucesso (isto e, se a thread que insere fragmentos nos clientes estiver inserindo um fragmento neste cliente).
| Client | Ponteiro para a estrutura do cliente a ser removido do heap. |
Definition at line 1237 of file StreamControl.cpp.
01238 { 01239 unsigned long long int ClientMapId; 01240 bool result; 01241 01242 #ifdef RIO_DEBUG1 01243 RioErr << "[CClientHeap - RemoveClient] Start" << endl; 01244 #endif 01245 01246 // Note que o cliente ja estara fora do heap (pois sempre removemos o 01247 // cliente do heap e o recolocamos apos atualizar o tempo de atualizacao 01248 // entre os creditos). 01249 // Obtem acesso exclusivo ao mapa e a variavel m_LastClient. 01250 pthread_mutex_lock( &m_AccessClients ); 01251 if( ( Client->MustRemoveClient() ) && ( m_LastClient != Client ) ) 01252 { 01253 #ifdef RIO_DEBUG2 01254 struct in_addr clientaddr; 01255 clientaddr.s_addr = Client->GetIPAddress(); 01256 RioErr << "CClientList::RemoveClient removendo a lista do cliente com o " 01257 << "IP " << inet_ntoa( clientaddr ) << " e a porta " 01258 << ntohs( Client->GetPort() ) << endl; 01259 #endif 01260 // Determina o ID (com 64 bits) do cliente (os 32 bits superiores sao a 01261 // porta do cliente, e os 32 bits inferiores sao o IP do cliente). 01262 ClientMapId = ( unsigned int ) Client->GetPort(); 01263 ClientMapId = ( ClientMapId << 32 ) | 01264 ( ( unsigned int ) Client->GetIPAddress() ); 01265 // Remove o cliente do mapa. 01266 m_ClientsMap.erase( ClientMapId ); 01267 // Corrige o ponteiro de busca caso ele aponte para este cliente. 01268 if( m_LastClient == Client ) 01269 m_LastClient = NULL; 01270 #ifdef RIO_DEBUG2 01271 RioErr << "CClientList::RemoveClient removendo do mapa o cliente com " 01272 << "o IP " << inet_ntoa( clientaddr ) << ", a porta " 01273 << ntohs( Client->GetPort() ) << ", e a ID " << ClientMapId 01274 << endl; 01275 #endif 01276 // Deleta o objeto associado ao cliente. 01277 delete Client; 01278 result = true; 01279 } 01280 else 01281 result = false; 01282 // Libera o acesso exclusivo ao mapa e a variavel m_LastClient. 01283 pthread_mutex_unlock( &m_AccessClients ); 01284 01285 #ifdef RIO_DEBUG1 01286 RioErr << "[CClientHeap - RemoveClient] Finish" << endl; 01287 #endif 01288 01289 return result; 01290 }
pthread_mutex_t CClientHeap::m_AccessClients [private] |
Mutex para garantir o acesso exclusivo ao mapa descrito anteriormente, e a variavel m_LastClient.
Definition at line 596 of file StreamControl.h.
pthread_mutex_t CClientHeap::m_AccessClientsHeap [private] |
Mutex para garantir o acesso exclusivo ao heap descrito anteriormente.
Definition at line 600 of file StreamControl.h.
TClientsHeap CClientHeap::m_ClientsHeap [private] |
Heap usado para armazenar os clientes ativos no servidor.
Ele e usado como uma lista de eventos, e e ordenado, em ordem crescente, pelo tempo de atualizacao dos creditos dos clientes.
Definition at line 578 of file StreamControl.h.
TClientsMap CClientHeap::m_ClientsMap [private] |
Mapa usado para acelerar a busca por um cliente no heap (usado ao copiarmos os fragmentos do pool para a lista dos clientes).
Cada entrada do mapa (com um identificador dado por um inteiro de bits cujos 32 bits superiores sao a porta do cliente e os 32 bits inferiores sao o IP do cliente) aponta para a entrada no heap de um cliente diferente.
Definition at line 586 of file StreamControl.h.
CClientInfo* CClientHeap::m_LastClient [private] |
Ponteiro para o ultimo cliente achado pela funcao FindClient.
Usado pela funcao Insert para evitar a busca por clientes no mapa ClientsMap a cada vez que um fragmento e inserido via a funcao Insert dada a seguir.
Definition at line 592 of file StreamControl.h.
unsigned int CClientHeap::m_MaxClientsCredits [private] |
Variavel que armazena o numero de creditos dos clientes ao enviar fragmentos.
Definition at line 573 of file StreamControl.h.
pthread_cond_t CClientHeap::m_WaitClients [private] |
Variavel de condicao usada pela thread que processa os clientes para esperar pelo evento indicando que o heap m_AccessClientsHeap da classe deixou de ficar vazio, isto e, um cliente possui fragmentos para serem enviados.
Definition at line 606 of file StreamControl.h.
1.6.3