BaseEmulator.cpp

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2004-2006 by Olivier Stezowski & Christian Finck        *
 *   stezow(AT)ipnl.in2p3.fr, cfinck(AT)ires.in2p3.fr                      *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#include "BaseEmulator.h"
#include <stdexcept>

using namespace Gw;

BaseEmulator::BaseEmulator(std::string name) : fLog(name.data()), fName(name), fGlobals(), fAllActors() , fAllConnections(), fTopology() 
{
        // some general path
        fGlobals.push_back ( new NamedItem<std::string> ("ConfDir",std::string("./")) ) ;
        fGlobals.push_back ( new NamedItem<std::string> ("ReadDir",std::string("./")) ) ;
        fGlobals.push_back ( new NamedItem<std::string> ("SaveDir",std::string("./")) ) ;
        // to be used in case of dynamic loading of libraries i.e. follows rigourusly Narval like way of doing
        fGlobals.push_back ( new NamedItem<std::string> ("LibDir", std::string("./")) ) ;
        fGlobals.push_back ( new NamedItem<std::string> ("LibName",std::string("lib.so")) ) ;
        // definition of the connection
        // if a new actor is linked with an existing actor, the following are used to define the connection
        // with C used if the new actor is a consumer regarding the old one, and P if it is the producer
        fGlobals.push_back ( new NamedItem<UInt_t> ("SizeDataBlockC",aMByte) ) ;
        fGlobals.push_back ( new NamedItem<std::string> ("TypeDataBlockC",std::string("")) ) ;
        fGlobals.push_back ( new NamedItem<UInt_t> ("SizeDataBlockP",aMByte) ) ;
        fGlobals.push_back ( new NamedItem<std::string> ("TypeDataBlockP",std::string("expand")) ) ;
        
        // option of the emulator
        fGlobals.push_back ( new NamedItem<std::string> ("InitSequence", std::string("config load init")) ) ;   
        fGlobals.push_back ( new NamedItem<Short_t> ("Generation",0) ) ;                
                // -2 is for almost-pure narval emulator (Joa's one) i.e. it get the configure / register from the C library. then other methods are called using the NarvalInterface::process_XXX methods
                // -1 femul like. actors are created directly. The real process::config method could be set during the emulator construction so that a direct call of the mother class could be done.  others are  NarvalInterface::process_XXX methods
                // 0 ADF's like, first generation. like femul except ProcessBlock(FrameBlock ....) is called instead of process_block
                // ---> all these generations can handle only producers, consumers and Filters. femul Builder cannot be called since they are not based on NarvalInterface.
                // 1 ADF new interface using ProcessBlocks() method. It allows to define the same interface for consumer, producer, filter and shunter (N input x M output)
                //
                // since once using the BaseEmulator.Add method the created loaded actor get a local copy of the Global of the emulator, in principle, generation can be mixed !
}

BaseEmulator::~BaseEmulator()
{
        fLog.SetProcessMethod("~BaseEmulator()");
        
        // delete all globals
        try {
                fLog << "deleting globals ... " ;
                for (size_t i = 0; i < fGlobals.size(); i++) {
                        delete fGlobals[i];
                }
                fLog << "deleting actors ... " ;                
                for (size_t i = 0; i < fAllActors.size(); i++) {
                        delete fAllActors[i];
                }
                fLog << "deleting connections ... " ;
                for (size_t i = 0; i < fAllConnections.size(); i++) {
                        delete fAllConnections[i];
                }
        }
        catch (std::exception &e) {
                fLog << error << e.what() << nline;
        }
        fLog << dolog;
}

void BaseEmulator::SetGlobal( const ANamedItem &global )
{
        Bool_t add_new = true;
        // 
        for (size_t j = 0; j < fGlobals.size(); j++) {
                // 
                if ( global.GetName() == fGlobals[j]->GetName() ) {
                        // change is possible means same name same type
                        if ( fGlobals[j]->Set(&global) ) {
                                add_new = false;
                                break;
                        }
                }
        }
        if ( add_new ) {
                fGlobals.push_back( global.MakeAClone() );
        }
}

void BaseEmulator::PrintTopology()
{
        BuildTopology();
        std::cout << "[+]============================= Topology of " << GetName() << " =============================" << std::endl; 
        std::cout << " List of registered actors : " ; 
        for (UInt_t i = 0; i < fAllActors.size(); i++ ) {
                std::cout << fAllActors[i]->GetName() << " ";
        }
        std::cout << std::endl << "Topology depth " << fTopology.size() << std::endl; 
        for (UInt_t i = 0; i < fTopology.size(); i++ ) {
                for (UInt_t k = 0; k < i ; k++ ) {
                        std::cout << " ";
                }
                std::cout << "Actors @ level " << i << std::endl;
                for (UInt_t j = 0; j < fTopology[i].size() ; j++) {
                        for (UInt_t k = 0; k < i+1 ; k++ ) {
                                std::cout << " ";
                        }
                        std::cout << fTopology[i][j]->GetName() << " has " 
                                                << fTopology[i][j]->GetNbInput() << " input(s) and " << fTopology[i][j]->GetNbOutput() << " output(s) " << std::endl ;
                } 
        }
        std::cout << "[c]============================= Topology of " << GetName() << " =============================" << std::endl; 
        std::cout << "Configured with : " << std::endl;
        for (size_t i = 0; i < fGlobals.size(); i++) {
                fGlobals[i]->Print();
                std::cout << std::endl;
        }       
        std::cout << "[-]============================= Topology of " << GetName() << " =============================" << std::endl; 

}

void BaseEmulator::BuildTopology()
{
        Int_t depth;
        
        // clear the topology
        fTopology.clear();
        
        // for all nodes, look for the max depth for all 
        for (UInt_t i = 0; i < fAllActors.size(); i++ ) {
                
                if ( fAllActors[i] == 0x0 )
                        continue;

                depth = 0;
                fAllActors[i]->ComputeDepth(depth);
                
                while ( depth >= Int_t(fTopology.size()) ) {
                        //
                        std::vector <ALoadedActor *> vv;
                        fTopology.push_back(vv);
                }
                fTopology[depth].push_back( fAllActors[i] ); fAllActors[i]->SetDepth(depth);
        }
}

void BaseEmulator::Init( const NamedItem<std::string> &init_sequence )
{ 
        UInt_t error = 0u; fLog.SetProcessMethod("Init"); std::string action; 
        
        // change InitSequence in globals with the new value and use it to really do the jo
        // NOTE : if sequential calls (Ex : Init( NamedItem<std::string>("InitSequence","config")),Init( NamedItem<std::string>("InitSequence","load")) ... ), only the last value is kept
        SetGlobal(init_sequence);
        
        // needed first to fix the topology
        BuildTopology(); 
        
        for (UInt_t i = 0; i < fAllActors.size(); i++ ) {
                
                // now do what is asked by the init_sequence
                std::istringstream actions( GetItem<std::string>("InitSequence",fGlobals)->Get() );
                actions.clear();
                
                while ( actions.good() ) {
                        actions >> action;
                        fLog << info << "Apply action " << action << " on " << fAllActors[i]->GetName() ;

                        Bool_t is_done = false; 
                        
                        if ( action == "config" ) {
                                is_done = true;
                                fAllActors[i]->SetLastError(0u);
                                fAllActors[i]->ConfigureActor();
                                if ( fAllActors[i]->GetLastError() != 0u ) {
                                        fLog << error << " : Cannot configure " << fAllActors[i]->GetName() << ". CODE ERROR is : " << fAllActors[i]->GetLastError() << dolog;
                                        throw std::runtime_error(std::string("Cannot configure"));;
                                }
                                else { fAllActors[i]->SetStatus(ALoadedActor::kConfigured); fLog << info << " --> done "  << nline; }
                        }
                        if ( action == "load" ) {
                                is_done = true;
                                fAllActors[i]->SetLastError(0u);
                                fAllActors[i]->RegisterActor();
                                if ( fAllActors[i]->GetLastError() != 0u ) {
                                        fLog << error << " : Cannot Register " << fAllActors[i]->GetName() << ". CODE ERROR is : " << fAllActors[i]->GetLastError() << dolog;
                                        throw std::runtime_error(std::string("Cannot Register"));;
                                }       
                                else  {
                                        // check whether or not the allocated actor supports the number of input/output asked
                                        if ( fAllActors[i]->GetNbInput()  > fAllActors[i]->GetActor()->GetMaxInput() )  {
                                                fLog << error << " : Cannot Register " << fAllActors[i]->GetName() << ", too much inputs " << fAllActors[i]->GetNbInput() << " asked while MAX is " << fAllActors[i]->GetActor()->GetMaxInput() << dolog;
                                                throw std::out_of_range("incompatible inputs");
                                        }
                                        if ( fAllActors[i]->GetNbOutput() > fAllActors[i]->GetActor()->GetMaxOutput() ) {
                                                fLog << error << " Cannot Register " << fAllActors[i]->GetName() << ", too much outputs " << fAllActors[i]->GetNbOutput() << " asked while MAX is " << fAllActors[i]->GetActor()->GetMaxOutput() << dolog;
                                                throw std::out_of_range("incompatible outputs");                                        
                                        }
                                        //
                                        fAllActors[i]->SetStatus(ALoadedActor::kLoaded);
                                        fLog << info << " --> done "  << nline;
                                }
                        }
                        if ( action == "init" ) {
                                is_done = true;
                                fAllActors[i]->SetLastError(0u);
                                fAllActors[i]->InitActor();
                                if ( fAllActors[i]->GetLastError() != 0u ) {
                                        fLog << error << " : Cannot initialise " << fAllActors[i]->GetName() << ". CODE ERROR is : " << fAllActors[i]->GetLastError() << dolog;
                                        throw std::runtime_error(std::string("Cannot initialise"));
                                }                       
                                else { fAllActors[i]->SetStatus(ALoadedActor::kInitialised); fLog << info << " --> done "  << nline;    }                       
                        }
                        if ( is_done == false ) 
                                fLog << warning << " : is NOT a valid action. Valid are config, load or init "  << nline;
                }
        }
        //
        fLog << dolog;
}

void BaseEmulator::Run(Int_t max_loop)
{
        fLog.SetProcessMethod("Run");
        
        UInt_t nb_loop = 0u, nb_run = 0u, nb_try = 0u, max_try = 3u; 
        
        // if there in principle all actors are initialised. so set them to kIdle 
        for (UInt_t i = 0u; i < fAllActors.size(); i++) {
                if ( fAllActors[i]->GetStatus() < ALoadedActor::kInitialised ) {
                        fLog << error << "Actor " << fAllActors[i]->GetName() << " is not in the expected state " <<  fAllActors[i]->GetStatus() << dolog;                                      
                        return;
                }
        }
        
        // now start the loop
        while ( nb_loop != (UInt_t)max_loop ) {
                // start from lowest level 
                nb_run = 0;
                for (UInt_t i = 0; i < fTopology.size(); i++ ) {
                        for (UInt_t j = 0; j < fTopology[i].size() ; j++) {
                                
                                if ( nb_try > 0 ) {
                                        if ( fTopology[i][j]->GetStatus() == ALoadedActor::kRunning )
                                        fTopology[i][j]->SetStatus(ALoadedActor::kDoRunning); 
                                        // at least one loop with no active actors, reste running into do running 
                                }
                                
                                switch (fTopology[i][j]->GetStatus()) {
                                        case ALoadedActor::kInitialised :       
                                        case ALoadedActor::kIdle :      
                                        case ALoadedActor::kDoRunning :                                                 
                                                fTopology[i][j]->SetStatus(ALoadedActor::kDoRunning);
                                                fTopology[i][j]->ProcessActor();        
                                                if ( fTopology[i][j]->GetStatus() == ALoadedActor::kHasRun ) {
                                                        nb_run++;
                                                        //fTopology[i][j]->SetStatus(ALoadedActor::kIdle);
                                                }       
                                                fTopology[i][j]->SetStatus(ALoadedActor::kIdle);

                                                break;
                                                
                                        default:
                                                break;
                                }
                                if ( fTopology[i][j]->GetLastError() > 0u ) {
                                        fLog << error << "Error " << fTopology[i][j]->GetLastError() << " during processing of actor " <<  fTopology[i][j]->GetName() << nline;
                                        fTopology[i][j]->SetStatus(ALoadedActor::kDead);
                                        break;
                                }
                        } 
                } // @ depth i 
                if ( nb_run == 0 ) {
                        if ( nb_try >= max_try ) 
                                break;
                        else 
                                nb_try++;
                        fLog << info << " No active actors ==> STOP emulator after " << max_try << " # of tries. nb_try = " << nb_try << " nb_loop "<< nb_loop << nline;
                }
                else nb_try = 0;
                
                nb_loop++;
        } // while
        
        fLog << dolog;
}

ALoadedActor *BaseEmulator::GetLoaderByName(const Char_t *name) const
{
        ALoadedActor *result = 0x0;
        
        for (UInt_t i = 0; i < fAllActors.size(); i++ ) {
                if  ( fAllActors[i]->GetName().compare(name) == 0 ) { 
                        result = fAllActors[i] ;
                        break;
                }                               
        }
        return result;
}

NarvalInterface *BaseEmulator::GetActorByName(const Char_t *name) const
{
        ALoadedActor *l_actor = GetLoaderByName(name); 
        if ( l_actor ) {
                return l_actor->GetActor();
        }
        else {
                return 0x0;
        }
}