diskaccess.cpp File Reference

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <limits.h>
#include <sys/time.h>
#include <sys/syscall.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include "vsidevice.h"

Go to the source code of this file.

Functions
void *	FuncaoThread (void *Param)
int	main (int argc, char *argv[])
Variables
char *	NomeDisco
unsigned long long int	TamanhoDisco
unsigned int	TamanhoBloco
unsigned int	NumeroBlocos
unsigned int	NumLeituras
unsigned int	MaxMicroSegundos
CvsiDevice	Disco

---

Function Documentation

void* FuncaoThread

(

void *

Param

)

Definition at line 37 of file diskaccess.cpp.

{
    int                erro;
    unsigned int       i;
    unsigned int       Bloco;
    unsigned int       TempoEspera;
    unsigned long long int PosicaoDisco;
    double             TempoInicial;
    double             TempoFinal; 
    CvsiDevice         DiscoThread;
    struct timeval     inicio;
    struct timeval     fim;
    char              *BufferLeitura;
    pthread_t          ThreadId;

    // Obtem a id da thread
    ThreadId = pthread_self();
    printf("Thread %lu (pid=%lu): iniciada. \n", ThreadId, syscall(SYS_gettid) ); 
    TempoEspera = random() % MaxMicroSegundos;
    printf("Thread %lu: esperando %u ms. \n", ThreadId, TempoEspera);
    usleep(TempoEspera * 1000);
    printf("Thread %lu: iniciando a leitura. \n", ThreadId); 
    // Cria o buffer de leitura
    BufferLeitura = new char[ TamanhoBloco ];

    if( BufferLeitura == NULL )
    {
        printf("Thread %lu: erro ao criar o buffer com %u bytes. \n", ThreadId, 
               TamanhoBloco );
        pthread_exit( NULL );
    }
    
    // Abre novamente o disco
    erro = DiscoThread.OpenDeviceAgain(NomeDisco, TamanhoDisco);
    if( erro != 0 )
    {
        printf( "Thread %lu: erro ao abrir o dispositivo %s. \n", ThreadId,
                NomeDisco );
        pthread_exit( NULL );
    }
    else
        printf( "Thread %lu: dispositivo %s aberto com sucesso. \n", ThreadId,
                NomeDisco);

    for( i = 0; i < NumLeituras; i++ )
    {
        // Escolhe um bloco do disco aleatoriamente do disco
        Bloco = random() % NumeroBlocos;
        PosicaoDisco = Bloco * TamanhoBloco;
        gettimeofday( &inicio, NULL );
        erro = DiscoThread.Read( PosicaoDisco, TamanhoBloco, BufferLeitura );   
        gettimeofday( &fim, NULL );
        if( erro != 0 )
        {
            printf( "Thread %lu: erro ao ler o bloco %u (com %u bytes) do dispositivo %s. ",
                    ThreadId, Bloco, TamanhoBloco, NomeDisco);
            printf( "Posicao no disco %llu. Tipo do erro gerado %d. ",
                    PosicaoDisco, erro);
            printf( "Erro do sistema %u (%s).\n", errno, strerror( errno ) );
            fflush( stdout );
        }
        else
        {
            TempoInicial = ( ( double ) inicio.tv_sec ) * 1000.0 +
                           ( ( double ) inicio.tv_usec / 1000.0);
            TempoFinal =   ( ( double ) fim.tv_sec ) * 1000.0 +
                           ( ( double ) fim.tv_usec / 1000.0);
            if( TempoFinal-TempoInicial > 1000 )
            {
                printf( "*************************************************\n" );
                printf( "Thread %lu: bloco %u (com %u bytes) do dispositivo %s lido em %4.6f ms. \n",
                        ThreadId, Bloco, TamanhoBloco, NomeDisco,
                        TempoFinal-TempoInicial );
                printf( "*************************************************\n" );
            }
            else
                printf( "Thread %lu: bloco %u (com %u bytes) do dispositivo %s lido em %4.6f ms. \n", 
                        ThreadId, Bloco, TamanhoBloco, NomeDisco,
                        TempoFinal-TempoInicial );
        }
    }
    
    delete[] BufferLeitura;
    DiscoThread.Close();
    printf( "Thread %lu: terminada. \n", ThreadId );
    pthread_exit( NULL );  
}

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 125 of file diskaccess.cpp.

{   
    int             erro;
    unsigned int    i;
    unsigned int    NumeroThreads;
    pthread_attr_t  ThreadAttr;
    pthread_t      *ThreadId;
    CvsiDevice      Disco;
    struct timeval  atual;

    gettimeofday( &atual, NULL );
    srandom(atual.tv_sec);

    if( argc < 6 )
    {
        printf( "Sintaxe: %s [dispositivo] [tambloco] [numthreads] [numleituras] [maxmicrosegundos]\n",
                argv[ 0 ] );
        return -1;  
    }
    
    NomeDisco        = argv[ 1 ];
    TamanhoBloco     = atoi(argv[ 2 ]);
    NumeroThreads    = atoi(argv[ 3 ]);
    NumLeituras      = atoi(argv[ 4 ]);
    MaxMicroSegundos = atoi(argv[ 5 ]);

    // Abre o dispositivo
    erro = Disco.Open( NomeDisco );
    if( erro != 0 )
    {
        printf( "main: erro ao abrir o dispositivo %s.\n", NomeDisco );
        return erro;    
    }   
    
    // Determina o numero total de blocos
    TamanhoDisco = Disco.Size();
    if( TamanhoDisco % TamanhoBloco != 0 )
    {
        printf( "main: o tamanho do bloco %u nao divide o tamanho do disco %llu.\n",
                TamanhoBloco, TamanhoDisco);
        Disco.Close();       
        return -2;  
    }
    
    NumeroBlocos = (unsigned int) (TamanhoDisco /
                                  (unsigned long long int) TamanhoBloco);
    // Cria as threads
    ThreadId = new pthread_t [NumeroThreads];
    if( ThreadId == NULL )
    {
        printf( "main: erro ao alocar o vetor com as ids de threads com %u ids/\n",
                NumeroThreads);
        Disco.Close();       
        return -3;  
    }
    
    pthread_attr_init( &ThreadAttr );
    pthread_attr_setstacksize( &ThreadAttr, 2 * PTHREAD_STACK_MIN );
    
    for( i = 0; i < NumeroThreads; i++ )
    {
        erro = pthread_create( &ThreadId[ i ], &ThreadAttr, FuncaoThread,
                               NULL );
        if( erro != 0 )
            printf("main: aviso - erro ao criar uma das threads.\n");
        else
            printf("main: thread %lu criada com sucesso.\n", ThreadId[i]);
    }
    // Espera pelas threads
    for( i = 0; i < NumeroThreads; i++ )
        pthread_join( ThreadId[ i ], NULL );

    Disco.Close();   
    delete[] ThreadId;    
    return 0;
}

---

Variable Documentation

CvsiDevice Disco

Definition at line 35 of file diskaccess.cpp.

unsigned int MaxMicroSegundos

Definition at line 34 of file diskaccess.cpp.

char* NomeDisco

Definition at line 29 of file diskaccess.cpp.

unsigned int NumeroBlocos

Definition at line 32 of file diskaccess.cpp.

unsigned int NumLeituras

Definition at line 33 of file diskaccess.cpp.

unsigned int TamanhoBloco

Definition at line 31 of file diskaccess.cpp.

unsigned long long int TamanhoDisco

Definition at line 30 of file diskaccess.cpp.