CStreamControl Class Reference

Classe para implementar o controle de fluxo ao enviar blocos de video (ela nao sera usada nas copias de dados). More...

#include <StreamControl.h>

Public Member Functions

 CStreamControl ()
 CStreamControl construtor da classe, chamado quando um objeto e criado usando o comando new.
 ~CStreamControl ()
 ~CStreamControl destrutor da classe, chamado quando um objeto e removido com o comando delete.
int Start (RioNeti *rn, unsigned int MaxClientsCredits, unsigned int MaxNetworkCredits, unsigned long long int TimeBetweenCredits)
 Start Inicializa um objeto da classe CStreamControl.
void Stop ()
 Stop Para o processamento do objeto da classe CStreamControl.
int Put (NetBuf *nbp)
 Put coloca um fragmento, dado pelo objeto nbp da classe NetBuf, para ser processado pelo controle de fluxo gerenciado pelo objeto da classe CStreamControl.

Static Private Member Functions

static void * PoolThread (void *Param)
 PoolThread funcao usada pela thread que controla o pool de fragmentos passados pelo objeto da classe RioNeti (pela funcao nbSend) ao objeto responsavel pelo controle de fluxo.
static void * ClientsThread (void *Param)
 ClientsThread funcao usada pela thread que controla a passagem dos fragmentos das listas dos clientes para a fila de saida do controle de fluxo (do objeto m_SendData da classe CSendData com os fragmentos a serem enviados.
static void * SendDataThread (void *Param)
 SendDataThread funcao usada pela thread que controla o envio dos fragmentos controlados pelo controle de fluxo pela rede.
static void * UpdateThread (void *Param)
 UpdateThread funcao usada pela thread que atualiza os creditos do objeto m_SendData da classe CSendData.

Private Attributes

CSendData * m_SendData
 Ponteiro para a classe com a fila FIFO que com os objetos FragmentInfo que podem ser enviados.
CFPool * m_FPool
 Ponteiro para a classe com a fila FIFO com os objetos FragmentInfo que ainda vao ser processados pela thread que gerencia os clientes.
CClientHeap * m_ClientHeap
 Ponteiro para a classe que gerencia o heap com os clientes.
pthread_t m_SendThread
 Identificador da thread que envia os objetos FragmentInfo quando existirem creditos.
pthread_t m_PoolThread
 Identificador da thread que processa os objetos FragmentInfo dos recebidos da RioNeti pela funcao Put e os coloca nas listas dos clientes.
pthread_t m_ClientsThread
 Identificador da thread que processa os objetos FragmentInfo nas listas dos clientes e os coloca na lista de envio (processada pela thread identificada por m_SendThread).
pthread_t m_UpdateThread
 Identificador da thread que atualiza os creditos do objeto m_SendData, para desbloquear a thread SendDataThread que envia objetos FragmentInfo para a rede, usando a chamada scSend da RioNeti.
RioNeti * m_RioNeti
 Ponteiro para a classe RioNeti que esta usando a classe StreamControl para controlar o fluxo de dados.
bool m_Started
 Variavel booleana que indica se a classe esta inicializada.

Detailed Description

Classe para implementar o controle de fluxo ao enviar blocos de video (ela nao sera usada nas copias de dados).

Definition at line 704 of file StreamControl.h.

Constructor & Destructor Documentation

CStreamControl::CStreamControl (  ) 

CStreamControl construtor da classe, chamado quando um objeto e criado usando o comando new.

Definition at line 1485 of file StreamControl.cpp.

01486 {
01487     #ifdef RIO_DEBUG1
01488     RioErr << "[CStreamControl - Construtor] Start" << endl;
01489     #endif
01490 
01491     // Inicializa as variaveis da classe.
01492     m_SendData = NULL;
01493     m_FPool = NULL;
01494     m_ClientHeap = NULL;
01495     m_SendThread = 0;
01496     m_PoolThread = 0;
01497     m_ClientsThread = 0;
01498     m_UpdateThread = 0;
01499     m_RioNeti = NULL;
01500     m_Started = false;
01501 
01502     #ifdef RIO_DEBUG1
01503     RioErr << "[CStreamControl - Construtor] Finish" << endl;
01504     #endif
01505 }

CStreamControl::~CStreamControl (  ) 

~CStreamControl destrutor da classe, chamado quando um objeto e removido com o comando delete.

Definition at line 1508 of file StreamControl.cpp.

01509 {
01510     #ifdef RIO_DEBUG1
01511     RioErr << "[CStreamControl - Destrutor] Start" << endl;
01512     #endif
01513 
01514     Stop();
01515 
01516     #ifdef RIO_DEBUG1
01517     RioErr << "[CStreamControl - Destrutor] Finish" << endl;
01518     #endif
01519 }

Member Function Documentation

void * CStreamControl::ClientsThread ( void *  Param  )  [static, private]

ClientsThread funcao usada pela thread que controla a passagem dos fragmentos das listas dos clientes para a fila de saida do controle de fluxo (do objeto m_SendData da classe CSendData com os fragmentos a serem enviados.

Os fragmentos da fila de cada cliente sao passados para a fila de saida do controle de fluxo apos ocorrer o evento que dispara a atualizacao dos creditos deste clientes. O numero de fragmentos copiados sera igual ao numero de creditos depois desta atualizacao. Se nao existirem clientes (de tempo real) atualmente conectados ao servidor, a thread ficara bloqueada na variavel de condicao do objeto m_ClientHeap da classe CClientHeap ate que fragmentos de um cliente chegem para serem processados pelo controle de fluxo.

Parameters:
Param ponteiro para o objeto da CStreamControl associado a thread que esta sendo executada.

Definition at line 1569 of file StreamControl.cpp.

01570 {
01571     CStreamControl *psc;
01572     int result;
01573     unsigned int f; 
01574     TFragments Fragments;
01575 
01576     #ifdef RIO_DEBUG1
01577     RioErr << "[CStreamControl - ClientsThread] Start" << endl;
01578     #endif
01579 
01580     psc = (CStreamControl *) Param;
01581     
01582     RioErr << "CStreamControl::ClientsThread thread iniciada." << endl;
01583 
01584     RioErr << "CLIENTSTHREADID " << syscall( SYS_gettid ) << endl;
01585 
01586     for( ; ; )
01587     {
01588         // Agora vamos obter o primeiro fragmento a ser copiado para a fila
01589         // FIFO de envio dos fragmentos. Se a funcao retornar NULL, entao
01590         // o cliente que estava no topo do heap (o cliente para o qual
01591         // atualizamos os creditos), nao possui fragmentos a serem enviados
01592         // (note que o cliente deveria possuir creditos, pois dormimos, no
01593         // procedimento GetFragments chamado a seguir, ate que esteja na 
01594         // hora de atualizar os creditos do cliente associado ao topo do
01595         // heap.
01596         psc->m_ClientHeap->GetFragments( Fragments );
01597         for( f = 0; f < Fragments.size(); f++ ) 
01598         {
01599             // Devemos inserir o objeto FragmentInfo no final da fila FIFO de
01600             // envio.
01601             while ( ( result = psc->m_SendData->Insert( Fragments[ f ] ) ) 
01602                              != S_OK ) 
01603             {
01604                 RioErr << "StreamControl::ClientsThread erro de alocacao "
01605                        << "de memoria ao criar um objeto da classe "
01606                        << "CSendData. Tentando novamente." << endl;
01607             }
01608         }
01609     }
01610 
01611     #ifdef RIO_DEBUG1
01612     RioErr << "[CStreamControl - ClientsThread] Finish" << endl;
01613     #endif
01614 
01615     return NULL;
01616 }

void * CStreamControl::PoolThread ( void *  Param  )  [static, private]

PoolThread funcao usada pela thread que controla o pool de fragmentos passados pelo objeto da classe RioNeti (pela funcao nbSend) ao objeto responsavel pelo controle de fluxo.

A thread copia cada um dos fragmentos deste pool para a lista do cliente correspondente a este fragmento. Quando o pool estiver vazio, a thread e bloqueada na variavel de condicao do Pool (o objeto m_FPool da classe CFPool) ate que a funcao nbSend do objeto da classe RioNeti insira fragmentos no Pool.

Parameters:
Param ponteiro para o objeto da CStreamControl associado a thread que esta sendo executada.

Definition at line 1522 of file StreamControl.cpp.

01523 {
01524     CStreamControl *psc;
01525     FragmentInfo *fip;
01526     int result;
01527 
01528     #ifdef RIO_DEBUG1
01529     RioErr << "[CStreamControl - PoolThread] Start" << endl;
01530     #endif
01531 
01532     psc = (CStreamControl *) Param;
01533 
01534     RioErr << "CStreamControl::PoolThread thread iniciada." << endl;
01535 
01536     RioErr << "POOLTHREADID " << syscall( SYS_gettid ) << endl;
01537    
01538     for( ; ; )
01539     
01540     {
01541         // Se o pool estiver vazio, entao espera na variavel de condicao 
01542         // da classe CFPool pela chegada de Fragmentos.
01543         psc->m_FPool->WaitObject();
01544         // Remove todos os objetos FragmentInfo do pool m_FPool.
01545         while( ( fip = psc->m_FPool->Remove() ) != NULL ) 
01546         {
01547             // Insere o objeto na lista do cliente correto, usando a
01548             // funcao Insert da classe CClientList. 
01549             while ( ( result = psc->m_ClientHeap->Insert( fip ) ) 
01550                       != S_OK ) 
01551             {
01552                 RioErr << "StreamControl::PoolThread erro de alocacao "
01553                        << "de memoria ao inserir um fragmento na lista "
01554                        << "de um cliente da classe CClientHeap. Tentando " 
01555                        << "novamente." << endl;
01556             }
01557         } 
01558     }
01559 
01560     #ifdef RIO_DEBUG1
01561     RioErr << "[CStreamControl - PoolThread] Finish" << endl;
01562     #endif
01563 
01564     return NULL;
01565 }

int CStreamControl::Put ( NetBuf *  nbp  ) 

Put coloca um fragmento, dado pelo objeto nbp da classe NetBuf, para ser processado pelo controle de fluxo gerenciado pelo objeto da classe CStreamControl.

Este fragmento sera colocado pela funcao iSend do objeto (apontado pelo parametro interno m_RioNeti da classe) da classe RioNeti.

Parameters:
nbp ponteiro para o objeto da classe NetBuf com o fragmento.
Returns:
S_OK se o fragmento foi colocado com sucesso na fila de processamento inicial da classe de controle de fluxo (o Pool apontado pelo objeto m_FPool), e valor diferente de S_OK se algum erro ocorrer ao inicializar o objeto da classe.

Definition at line 1900 of file StreamControl.cpp.

01901 {
01902     FragmentInfo *fip;
01903 
01904     #ifdef RIO_DEBUG1
01905     RioErr << "[CStreamControl - Put] Start" << endl;
01906     #endif
01907 
01908     // Adiciona um elemento Fragment no pool m_FPool para ser processado pela
01909     // thread ProcessThread.
01910     // Verifica se a classe foi inicializada, e insere um elemento no pool
01911     // somente se a classe foi inicializada.
01912     if( m_Started )
01913     {
01914         // Cria uma novo objeto FragmentInfo e copia os dados do fragmento
01915         // nele.
01916         fip = new FragmentInfo;
01917         if( fip == NULL )
01918         {
01919 
01920             #ifdef RIO_DEBUG1
01921             RioErr << "[CStreamControl - Put] Finish1" << endl;
01922             #endif
01923 
01924             return ERROR_STREAMCONTROL + ERROR_MEMORY;
01925         }
01926         // Obtem os dados do objeto NetBuf
01927         // Obtem uma copia do fragmento que deveria ter sido enviado.
01928         if( nbp->GetFragmentInfo( &fip->FragmentData, &fip->FragmentSize ) != 
01929             S_OK )
01930         {
01931 
01932             #ifdef RIO_DEBUG1
01933             RioErr << "[CStreamControl - Put] Finish2" << endl;
01934             #endif
01935 
01936             delete fip;
01937             return ERROR_STREAMCONTROL + ERROR_MEMORY;
01938         }    
01939         // Obtem o IP e a porta do cliente.
01940         nbp->GetIPAndPort( &fip->IP, &fip->Port );
01941         // Obtem o tempo da atualizacao entre os creditos.
01942         fip->TimeBetweenCredits = nbp->GetTimeBetweenCredits();
01943 
01944         #ifdef RIO_DEBUG1
01945         RioErr << "[CStreamControl - Put] Finish3" << endl;
01946         #endif
01947 
01948         return m_FPool->Insert( fip );
01949     }
01950     else
01951     { 
01952 
01953         #ifdef RIO_DEBUG1
01954         RioErr << "[CStreamControl - Put] Finish4" << endl;
01955         #endif
01956 
01957         return ERROR_STREAMCONTROL + ERROR_NOT_STARTED;
01958     }
01959 }

void * CStreamControl::SendDataThread ( void *  Param  )  [static, private]

SendDataThread funcao usada pela thread que controla o envio dos fragmentos controlados pelo controle de fluxo pela rede.

Os fragmentos serao enviados enquando o objeto m_SendData da classe CSendData possuir fragmentos para serem enviados e creditos para enviar estes faragmentos. A thread ficara bloqueada em uma das variaveis de condicao (m_WaitObject) do objeto m_SendData se nao existirem fragmentos a serem enviados (colocados na fila de saida pela thread que executa a funcao ClientsThread), ou em uma outra variavel de condicao do objeto (m_WaitCredits) se o objeto m_SendData nao possuir creditos para enviar fragmentos pela rede (os creditos do objeto sao atualizados por uma outra thread que executa a funcao UpdateThread descrita a seguir).

Parameters:
Param ponteiro para o objeto da CStreamControl associado a thread que esta sendo executada.

Definition at line 1620 of file StreamControl.cpp.

01621 {
01622     CStreamControl *psc;
01623     FragmentInfo *fip;
01624     int result;
01625 
01626     #ifdef RIO_DEBUG1
01627     RioErr << "[CStreamControl - SendDataThread] Start" << endl;
01628     #endif
01629 
01630     psc = (CStreamControl *) Param;
01631     
01632     RioErr << "CStreamControl::SendDataThread thread iniciada." << endl;
01633 
01634     RioErr << "SENDDATATHREADID " << syscall( SYS_gettid ) << endl;
01635 
01636     for( ; ; )
01637     {
01638         // Tenta obter um objeto FragmentInfo. Se a fila FIFO da classe CSendData
01639         // estiver vazia, a thread sera bloqueada ate que um objeto seja
01640         // colocado na fila. A thread tambem sera bloqueada se nao existirem
01641         // creditos.
01642         fip = psc->m_SendData->Remove();
01643         if( fip != NULL ) 
01644         {  
01645             // Envia os dados do fragmento associado ao objeto FragmentInfo.
01646             result = psc->m_RioNeti->nbSend( NULL, fip->FragmentData, 
01647                                              fip->FragmentSize, fip->IP, 
01648                                              fip->Port);
01649             // Remove os dados do fragmento (eles sao uma copia) e a estrutura 
01650             // com estes dados
01651             #ifdef RIO_DEBUG2
01652             psc->TotalSendFragments++;
01653             RioErr << "CStreamControl::SendDataThread enviado o fragmento "
01654                    << "numero " << psc->TotalSendFragments << endl;
01655             #endif       
01656             delete fip->FragmentData;
01657             delete fip;
01658         } 
01659         else
01660            RioErr << "CStreamControl::SendDataThread erro - fip = NULL" 
01661                   << endl;                               
01662     }
01663 
01664     #ifdef RIO_DEBUG1
01665     RioErr << "[CStreamControl - SendDataThread] Finish" << endl;
01666     #endif
01667 
01668     return NULL;
01669 }

int CStreamControl::Start ( RioNeti *  rn,
unsigned int  MaxClientsCredits,
unsigned int  MaxNetworkCredits,
unsigned long long int  TimeBetweenCredits 
)

Start Inicializa um objeto da classe CStreamControl.

Parameters:
rn ponteiro para o objeto da classe RioNeti que esta usando o objeto para fazer o controle de fluxo.
MaxClientsCredits Numero maximo de creditos para cada um dos clientes conectados ao servidor.
MaxNetworkCredits Numero maximo de creditos ao enviarmos os fragmentos pela rede.
TimeBetweenCredits tempo entre as atualizacoes de credito usados ao enviarmos os fragmentos pela rede (obs: o tempo de atualizacao dos creditos de cada cliente dependera da taxa de transmissao de video e, devido a isso, sera passado junto com o fragmento a ser enviado para aquele cliente).
Returns:
S_OK se o objeto foi corretamente inicializado, e valor diferente de S_OK se algum erro ocorrer ao inicializar o objeto da classe.

Definition at line 1706 of file StreamControl.cpp.

01709 {
01710     // Atributos para as threads criadas pela classe.
01711     pthread_attr_t attribSendThread;
01712     pthread_attr_t attribPoolThread;
01713     pthread_attr_t attribClientsThread;
01714     pthread_attr_t attribUpdateThread;
01715 
01716     #ifdef RIO_DEBUG1
01717     RioErr << "[CStreamControl - Start] Start" << endl;
01718     #endif
01719 
01720     // Verifica se a classe ja foi inicializada.
01721     if( m_Started )
01722     {
01723 
01724         #ifdef RIO_DEBUG1
01725         RioErr << "[CStreamControl - Start] Finish1" << endl;
01726         #endif
01727         
01728         return ERROR_STREAMCONTROL + ERROR_STARTED; 
01729     }
01730     // Cria as classes usadas pela classe StreamControl.
01731     // Cria a classe com a fila FIFO com os objetos FragmentInfo a serem enviados
01732     // pela thread m_SendThread.
01733     // (corrigir os parametros 0, 0 para os valores corretos do numero 
01734     // maximo de creditos e do tempo da atualizacao entre os creditos.
01735     m_SendData = new CSendData( MaxNetworkCredits, TimeBetweenCredits );
01736     if( m_SendData == NULL )  
01737     {
01738         
01739         #ifdef RIO_DEBUG1
01740         RioErr << "[CStreamControl - Start] Finish2" << endl;
01741         #endif
01742 
01743         return ERROR_STREAMCONTROL + ERROR_MEMORY; 
01744     }
01745     // Cria o pool de objetos FragmentInfo que armazenara os objetos colocados
01746     // pela funcao Put e retirados pela thread m_ProcessThread.
01747     m_FPool = new CFPool;
01748     if( m_FPool == NULL ) 
01749     {
01750         
01751         #ifdef RIO_DEBUG1
01752         RioErr << "[CStreamControl - Start] Finish3" << endl;
01753         #endif
01754 
01755         delete m_SendData;
01756         return ERROR_STREAMCONTROL + ERROR_MEMORY; 
01757     }
01758     // Cria a lista com com os objetos FragmentInfo que devem ser enviados para
01759     // os clientes.
01760     m_ClientHeap = new CClientHeap( MaxClientsCredits );
01761     if ( m_ClientHeap == NULL )
01762     {
01763         
01764         #ifdef RIO_DEBUG1
01765         RioErr << "[CStreamControl - Start] Finish4" << endl;
01766         #endif
01767 
01768         delete m_SendData;
01769         delete m_FPool;
01770         return ERROR_STREAMCONTROL + ERROR_MEMORY; 
01771     }
01772     // Inicializa os atributos das threads usadas pela classe.
01773     pthread_attr_init( &attribSendThread );
01774     pthread_attr_init( &attribPoolThread );
01775     pthread_attr_init( &attribClientsThread );
01776     pthread_attr_init( &attribUpdateThread );
01777     pthread_attr_setstacksize( &attribSendThread, 2*PTHREAD_STACK_MIN );
01778     pthread_attr_setstacksize( &attribPoolThread,  2*PTHREAD_STACK_MIN );
01779     pthread_attr_setstacksize( &attribClientsThread,  2*PTHREAD_STACK_MIN );
01780     pthread_attr_setstacksize( &attribUpdateThread,  2*PTHREAD_STACK_MIN );
01781     // Cria as threads usadas pela classe.
01782     if ( pthread_create( &m_PoolThread, &attribPoolThread, PoolThread, this )   
01783                         != 0 )
01784     {
01785         
01786         #ifdef RIO_DEBUG1
01787         RioErr << "[CStreamControl - Start] Finish5" << endl;
01788         #endif
01789 
01790         delete m_SendData;
01791         delete m_FPool;
01792         delete m_ClientHeap;
01793         return ERROR_STREAMCONTROL + ERROR_CREATE_THREAD; 
01794     }
01795     if ( pthread_create( &m_ClientsThread, &attribClientsThread, ClientsThread, 
01796                          this ) != 0 )
01797     {
01798         
01799         #ifdef RIO_DEBUG1
01800         RioErr << "[CStreamControl - Start] Finish6" << endl;
01801         #endif
01802 
01803         delete m_SendData;
01804         delete m_FPool;
01805         delete m_ClientHeap;
01806         pthread_cancel( m_PoolThread );
01807         return ERROR_STREAMCONTROL + ERROR_CREATE_THREAD; 
01808     }
01809     if ( pthread_create( &m_SendThread, &attribSendThread, SendDataThread, 
01810                          this ) != 0 )
01811     {
01812         
01813         #ifdef RIO_DEBUG1
01814         RioErr << "[CStreamControl - Start] Finish7" << endl;
01815         #endif
01816 
01817         delete m_SendData;
01818         delete m_FPool;
01819         delete m_ClientHeap;
01820         pthread_cancel( m_PoolThread );
01821         pthread_cancel( m_ClientsThread );
01822         return ERROR_STREAMCONTROL + ERROR_CREATE_THREAD; 
01823     }
01824     if ( pthread_create( &m_UpdateThread, &attribUpdateThread, UpdateThread, 
01825                          this ) != 0 )
01826     {
01827         
01828         #ifdef RIO_DEBUG1
01829         RioErr << "[CStreamControl - Start] Finish8" << endl;
01830         #endif
01831 
01832         delete m_SendData;
01833         delete m_FPool;
01834         delete m_ClientHeap;
01835         pthread_cancel( m_PoolThread );
01836         pthread_cancel( m_ClientsThread );
01837         pthread_cancel( m_SendThread );
01838         return ERROR_STREAMCONTROL + ERROR_CREATE_THREAD; // Esta correto?
01839     }
01840     // Inicializa as variaveis internas.
01841     m_RioNeti = rn;
01842     m_Started = true;
01843 
01844     #ifdef RIO_DEBUG2
01845     // Acumula o numero de fragmentos enviados (usado para depuracao).
01846     TotalSendFragments = 0;
01847     #endif
01848 
01849     #ifdef RIO_DEBUG1
01850     RioErr << "[CStreamControl - Start] Finish9" << endl;
01851     #endif
01852 
01853     return S_OK; 
01854 }

void CStreamControl::Stop ( void   ) 

Stop Para o processamento do objeto da classe CStreamControl.

Definition at line 1857 of file StreamControl.cpp.

01858 {
01859     #ifdef RIO_DEBUG1
01860     RioErr << "[CStreamControl - Stop] Start" << endl;
01861     #endif
01862 
01863     if( m_SendThread != 0 )
01864         pthread_cancel( m_SendThread );    
01865     if( m_PoolThread != 0 )
01866         pthread_cancel( m_PoolThread );    
01867     if( m_ClientsThread != 0 )
01868         pthread_cancel( m_ClientsThread );    
01869     if( m_UpdateThread != 0 )
01870         pthread_cancel( m_UpdateThread );    
01871     if( m_SendData != NULL )
01872         delete m_SendData;
01873     if( m_FPool != NULL )
01874         delete m_FPool;
01875     if( m_ClientHeap != NULL )
01876         delete m_ClientHeap;
01877     // Inicializa as variaveis da classe.
01878     m_SendData = NULL;
01879     m_FPool = NULL;
01880     m_ClientHeap = NULL;
01881     m_SendThread = 0;
01882     m_PoolThread = 0;
01883     m_ClientsThread = 0;
01884     m_UpdateThread = 0;
01885     m_RioNeti = NULL;
01886     m_Started = false;
01887 
01888     #ifdef RIO_DEBUG2
01889     TotalSendFragments = 0;
01890     #endif
01891 
01892     #ifdef RIO_DEBUG1
01893     RioErr << "[CStreamControl - Stop] Finish" << endl;
01894     #endif
01895 }

void * CStreamControl::UpdateThread ( void *  Param  )  [static, private]

UpdateThread funcao usada pela thread que atualiza os creditos do objeto m_SendData da classe CSendData.

Quando nao existirem creditos a serem atualizados (o objeto m_SendData ja possui o numero maximo de creditos), a thread que executa a funcao seja bloqueada na variavel de condicao m_WaitUseCredits do objeto ate que um dos creditos deste objeto sejam usados (eles serao usados ao enviarmos fragmentos pela thread que executa a funcao SendDataThread).

Parameters:
Param ponteiro para o objeto da CStreamControl associado a thread que esta sendo executada.

Definition at line 1672 of file StreamControl.cpp.

01673 {
01674     CStreamControl *psc;
01675 
01676     #ifdef RIO_DEBUG1
01677     RioErr << "[CStreamControl - UpdateThread] Start" << endl;
01678     #endif
01679 
01680     psc = (CStreamControl *) Param;
01681     
01682     RioErr << "CStreamControl::UpdateThread thread iniciada." << endl;
01683 
01684     RioErr << "UPDATETHREADID " << syscall( SYS_gettid ) << endl;
01685 
01686     for( ; ; )
01687     {
01688         psc->m_SendData->UpdateCredits();
01689     }
01690 
01691     #ifdef RIO_DEBUG1
01692     RioErr << "[CStreamControl - UpdateThread] Finish" << endl;
01693     #endif
01694 
01695     return NULL;
01696 }

Field Documentation

CClientHeap* CStreamControl::m_ClientHeap [private]

Ponteiro para a classe que gerencia o heap com os clientes.

Cada elemento do heap estara associado a um cliente, e contera os objetos FragmentInfo que devem ser enviados a este cliente.

Definition at line 720 of file StreamControl.h.

pthread_t CStreamControl::m_ClientsThread [private]

Identificador da thread que processa os objetos FragmentInfo nas listas dos clientes e os coloca na lista de envio (processada pela thread identificada por m_SendThread).

Definition at line 734 of file StreamControl.h.

CFPool* CStreamControl::m_FPool [private]

Ponteiro para a classe com a fila FIFO com os objetos FragmentInfo que ainda vao ser processados pela thread que gerencia os clientes.

Definition at line 715 of file StreamControl.h.

pthread_t CStreamControl::m_PoolThread [private]

Identificador da thread que processa os objetos FragmentInfo dos recebidos da RioNeti pela funcao Put e os coloca nas listas dos clientes.

Definition at line 729 of file StreamControl.h.

RioNeti* CStreamControl::m_RioNeti [private]

Ponteiro para a classe RioNeti que esta usando a classe StreamControl para controlar o fluxo de dados.

Definition at line 744 of file StreamControl.h.

CSendData* CStreamControl::m_SendData [private]

Ponteiro para a classe com a fila FIFO que com os objetos FragmentInfo que podem ser enviados.

Esta classe e usada para o controle de fluxo dos dados que estao sendo enviados pelo servidor.

Definition at line 711 of file StreamControl.h.

pthread_t CStreamControl::m_SendThread [private]

Identificador da thread que envia os objetos FragmentInfo quando existirem creditos.

Definition at line 724 of file StreamControl.h.

bool CStreamControl::m_Started [private]

Variavel booleana que indica se a classe esta inicializada.

Definition at line 746 of file StreamControl.h.

pthread_t CStreamControl::m_UpdateThread [private]

Identificador da thread que atualiza os creditos do objeto m_SendData, para desbloquear a thread SendDataThread que envia objetos FragmentInfo para a rede, usando a chamada scSend da RioNeti.

Definition at line 740 of file StreamControl.h.

The documentation for this class was generated from the following files:
Generated on Wed Jul 4 16:03:34 2012 for RIO by  doxygen 1.6.3