TestFIO.C

Go to the documentation of this file.

#include "ADFLogCollector.h"

#ifndef _BasicAFP
#include "BasicAFP.h"
#endif
#ifndef _BasicAFC
#include "BasicAFC.h"
#endif

#ifndef _TestFIO
#include "TestFIO.h"
#endif

#include <sys/times.h>

#include <iostream>
#include <sstream>
#include <string>

/*
compilation (standalone) : 
        g++ -O -Wall -fPIC -I../ -L../ -lADF TestFIO.C -o TestFIO
        g++ -g -pg -I../ -L../ -lADF TestFIO.C -o TestFIO

In a root session (with include to gammaware's includes properly defined)
        root
        gSystem->Load("libGWCORE")
        gSystem->Load("libGWADF")
        .L Producer.C++
                
--> DEBUG 
Linux SL4

--> VALGRIND

Memory leak
Profiling
        
*/

using namespace ADF;

int TestFIO_0_1()
{
        const char *MainPATH = "./";    
        std::string tmp_path;
        
        // to-pre initiate the ADF system (not mandatory)
        UInt_t error_adf = 0u;  
        NarvalInterface::process_config(MainPATH,&error_adf);
        if ( error_adf > 0u ) 
                { printf("Error in NarvalInterface::process_config %d \n ",error_adf); return 1; }
                        
        // A log collector is created to collector logs in a file
        // it becomes automatically the current collector
        // WARNING !! should be pointer since all collectors are collected
        // and destroyed at the end by the global collector
//      OStreamCollector *test_collector = new OStreamCollector("TEST.log");
        
        // block going from producer to filter and from filter to consumer
        const UInt_t size_buf_in  = 400*aKByte;
        const UInt_t size_buf_out = aMByte;     
        Char_t *buf1 = NULL;
        Char_t *buf2 = NULL;    
        buf1 = BaseBuffer::New(buf1,size_buf_in);
        buf2 = BaseBuffer::New(buf2,size_buf_out); 
                        
        // it creates and inits the different actors
        // producer
        UInt_t error_pro = 0u;
        tmp_path = MainPATH;
        BasicAFP::process_config(tmp_path.data(),&error_pro); 
        if ( error_pro > 0u ) 
                printf("Error in BasicAFP::process_config %d \n ",error_pro);
        BasicAFP *pro = new BasicAFP(); 
        pro->process_initialise(&error_pro);
        if ( error_pro > 0u ) 
                printf("Error in BasicAFP::process_config %d \n ",error_pro);
                
        // filter
        UInt_t error_filter = 0u;
        tmp_path = MainPATH;
        TestFIO::process_config(tmp_path.data(),&error_filter);
        if ( error_filter > 0u ) 
                printf("Error in TestFIO::process_config %d \n ",error_filter);
        TestFIO *filter = new TestFIO() ; 
        filter->process_initialise(&error_filter);      
        if ( error_filter > 0u ) 
                printf("Error in TestFIO::process_config %d \n ",error_filter);

        // consumer
        UInt_t error_cons = 0u;
        tmp_path = MainPATH;    
        BasicAFC::process_config(tmp_path.data(),&error_cons); 
        if ( error_cons > 0u ) 
                printf("Error in BasicAFC::process_config %d \n ",error_cons);
        BasicAFC *cons = new BasicAFC(); 
        cons->process_initialise(&error_cons);
        if ( error_cons > 0u ) 
                printf("Error in BasicAFC::process_config %d \n ",error_cons);
                
        // loop on events
        UInt_t realsize1 = 0u, realsize2= 0u, nb_loop = 0u, error = 0u; 
        struct tms t0, t; times(&t0);   
        while ( error == 0u ) {
                // printf("nb_loop_in %d \n",nb_loop);
                // to get an input block
                pro->process_block(buf1,size_buf_in,&realsize1,&error); if ( realsize1 == 0u ) break;
                std::cout << "realsize1 " << realsize1 << std::endl;
                //
                filter->process_block(buf1,realsize1,buf2,size_buf_out,&realsize2,&error);
                //
                std::cout << "realsize2 " << realsize2 << std::endl;
                cons->process_block(buf1,realsize1,&error); nb_loop++;          
//              cons->process_block(buf2,realsize2,&error); nb_loop++;
        }
        // 
        printf("\n");
        printf("[[ test0.1 ]] : BENCHMARKS \n[...\n");
        printf("nb_loop %d %d\n",nb_loop,error);
        times(&t);
        std::cout << "User " << Float_t(t.tms_utime-t0.tms_utime)/sysconf(_SC_CLK_TCK)
             << " second, System " << Float_t(t.tms_stime-t0.tms_stime)/sysconf(_SC_CLK_TCK) 
             << " seconds" << std::endl; 
        printf("...]\n\n");
          
        if ( pro ) 
                delete pro; 
        if ( filter )
                delete filter;
        if ( cons )
                delete cons;
        BaseBuffer::Delete(buf2);BaseBuffer::Delete(buf1);
                
        return 0;
}

int TestFIO_0_2()
{
        const char *MainPATH = "./";    
        std::string tmp_path;
        
        // to-pre initiate the ADF system (not mandatory)
        UInt_t error_adf = 0u;  
        NarvalInterface::process_config(MainPATH,&error_adf);
        if ( error_adf > 0u ) 
                { printf("Error in NarvalInterface::process_config %d \n ",error_adf); return 1; }
                        
        // A log collector is created to collector logs in a file
        // it becomes automatically the current collector
        // WARNING !! should be pointer since all collectors are collected
        // and destroyed at the end by the global collector
//      OStreamCollector *test_collector = new OStreamCollector("TEST.log");
        
        // block going from producer to filter and from filter to consumer
        OneBlock FB0_1(aMByte);  
        OneBlock FB1_2(aMByte);  
                
        // it creates and inits the different actors
        // producer
        UInt_t error_pro = 0u;
        tmp_path = MainPATH;
        BasicAFP::process_config(tmp_path.data(),&error_pro); 
        if ( error_pro > 0u ) 
                printf("Error in BasicAFP::process_config %d \n ",error_pro);
        BasicAFP *pro = new BasicAFP(); 
        pro->process_initialise(&error_pro);
        if ( error_pro > 0u ) 
                printf("Error in BasicAFP::process_config %d \n ",error_pro);
                
        // filter
        UInt_t error_filter = 0u;
        tmp_path = MainPATH;
        TestFIO::process_config(tmp_path.data(),&error_filter);
        if ( error_filter > 0u ) 
                printf("Error in TestFIO::process_config %d \n ",error_filter);
        TestFIO *filter = new TestFIO() ; 
        filter->process_initialise(&error_filter);      
        if ( error_filter > 0u ) 
                printf("Error in TestFIO::process_config %d \n ",error_filter);

        // consumer
        UInt_t error_cons = 0u;
        tmp_path = MainPATH;    
        BasicAFC::process_config(tmp_path.data(),&error_cons); 
        if ( error_cons > 0u ) 
                printf("Error in BasicAFC::process_config %d \n ",error_cons);
        BasicAFC *cons = new BasicAFC(); 
        cons->process_initialise(&error_cons);
        if ( error_cons > 0u ) 
                printf("Error in BasicAFC::process_config %d \n ",error_cons);
                
        // loop on events
        UInt_t nb_loop = 0u, error = 0u; struct tms t0, t; times(&t0);  
        while ( error == 0u ) {
                // to get an input block
                printf("Call producer \n");
                if ( pro->ProcessBlock(FB0_1) != 0u ) 
                        break;
                if ( FB0_1.GetSize() == 0u )
                        break;
                else
                        printf("Produced block with size %d \n",FB0_1.GetSize());       
                // to apply the algorithm
                printf("Call filter \n");               
                if ( filter->ProcessBlock(FB0_1,FB1_2) != 0u ) 
                        break;
                if ( FB1_2.GetSize() == 0u )
                        break;
                else
                        printf("Output filter size %d \n",FB1_2.GetSize());
                // to save the outpout of the algorithm
                printf("Call consumer \n");
                
                if ( cons->ProcessBlock(FB1_2) != 0u ) 
                        break; 
                nb_loop++;
//              if ( nb_loop == 1u )
//                      break;
        }
        // 
        printf("\n");
        printf("[[ test0.2 ]] : BENCHMARKS \n[...\n");
        printf("nb_loop %d %d\n",nb_loop,error);
        times(&t);
        std::cout << "User " << Float_t(t.tms_utime-t0.tms_utime)/sysconf(_SC_CLK_TCK)
             << " second, System " << Float_t(t.tms_stime-t0.tms_stime)/sysconf(_SC_CLK_TCK) 
             << " seconds" << std::endl; 
        printf("...]\n\n");
          
        if ( pro ) 
                delete pro; 
        if ( filter )
                delete filter;
        if ( cons )
                delete cons;
                
        return 0;
}

int TestFIO_1_2()
{
        const char *MainPATH = "./";    
        std::string tmp_path;
        
        // to-pre initiate the ADF system (not mandatory)
        UInt_t error_adf = 0u;  
        NarvalInterface::process_config(MainPATH,&error_adf);
        if ( error_adf > 0u ) 
                { printf("Error in NarvalInterface::process_config %d \n ",error_adf); return 1; }
                        
        // A log collector is created to collector logs in a file
        // it becomes automatically the current collector
        // WARNING !! should be pointer since all collectors are collected
        // and destroyed at the end by the global collector
//      OStreamCollector *test_collector = new OStreamCollector("TEST.log");
        
        // block going from producer to filter and from filter to consumer
        OneBlock FB0_1(aMByte);  
        OneBlock FB1_2(aMByte);  
                
        // it creates and inits the different actors
        // producer
        UInt_t error_pro = 0u;
        tmp_path = MainPATH;
        BasicAFP::process_config(tmp_path.data(),&error_pro); 
        if ( error_pro > 0u ) 
                printf("Error in BasicAFP::process_config %d \n ",error_pro);
        BasicAFP *pro = new BasicAFP(); 
        pro->process_initialise(&error_pro);
        if ( error_pro > 0u ) 
                printf("Error in BasicAFP::process_config %d \n ",error_pro);
                
        // filter
        UInt_t error_filter = 0u;
        tmp_path = MainPATH;
        TestFIO::process_config(tmp_path.data(),&error_filter);
        if ( error_filter > 0u ) 
                printf("Error in TestFIO::process_config %d \n ",error_filter);
        TestFIO *filter = new TestFIO() ; 
        filter->process_initialise(&error_filter);      
        if ( error_filter > 0u ) 
                printf("Error in TestFIO::process_config %d \n ",error_filter);
                
        // loop on events
        UInt_t nb_loop = 0u, error = 0u; struct tms t0, t; times(&t0);  
        while ( error == 0u ) {
                // to get an input block
//              printf("Call producer \n");
                if ( pro->ProcessBlock(FB0_1) != 0u ) 
                        break;
                if ( FB0_1.GetSize() == 0u )
                        break;
//              else
//                      printf("Produced block with size %d \n",FB0_1.GetSize());       
                // to apply the algorithm
//              printf("Call filter \n");               
                if ( filter->ProcessBlock(FB0_1,FB1_2) != 0u ) 
                        break;

                nb_loop++;
//              if ( nb_loop == 1u )
//                      break;
        }
        // 
        printf("\n");
        printf("[[ test1.2 ]] : BENCHMARKS \n[...\n");
        printf("nb_loop %d %d\n",nb_loop,error);
        times(&t);
        std::cout << "User " << Float_t(t.tms_utime-t0.tms_utime)/sysconf(_SC_CLK_TCK)
             << " second, System " << Float_t(t.tms_stime-t0.tms_stime)/sysconf(_SC_CLK_TCK) 
             << " seconds" << std::endl; 
        printf("...]\n\n");
          
        if ( pro ) 
                delete pro; 
        if ( filter )
                delete filter;
                
        return 0;
}


#if ADF_STANDALONE == 1
int main(int argc, char **argv)
{
        const int nbtest = 2;
        if ( argc == 1 ) 
                std::cout << " Usage is : \n\t" 
                          << argv[0] << " i \n i being a integer from 1 to "<< nbtest << std::endl;
                          
        int nwhat; UInt_t number = 100;
        if ( argc > 1 ) {
                std::istringstream what(argv[1]); what >> nwhat;        
        }
        if ( argc > 2 ) {
                std::istringstream what(argv[2]); what >> number;
        }       
        switch( nwhat ) {
                case 1:
                        TestFIO_0_1();
                        break;
                case 2:
                        TestFIO_0_2();
                        break;
                case 3:
                        TestFIO_1_2();
                        break;                  
                default:
                        std::cout << " Unknown test number " << nwhat << std::endl;     
        }
        
        return 0;       
}
#endif