Changeset 1452 for branches

Show
Ignore:
Timestamp:
11/22/08 08:29:16 (12 years ago)
Author:
ppalmers
Message:

implement a port cache to increase efficiency (saves nports * 4 * 2 iterations over the port vector on every period)

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • branches/libffado-2.0/src/devicemanager.cpp

    r1373 r1452  
    768768            getSyncSource()); 
    769769    } 
     770 
    770771    return true; 
    771772} 
  • branches/libffado-2.0/src/libstreaming/generic/PortManager.cpp

    r876 r1452  
    3535IMPL_DEBUG_MODULE( PortManager, PortManager, DEBUG_LEVEL_NORMAL ); 
    3636 
    37 PortManager::PortManager() { 
    38 
    39  
    40 PortManager::~PortManager() { 
     37PortManager::PortManager() 
     38
     39
     40 
     41PortManager::~PortManager() 
     42
    4143    flushDebugOutput(); 
    4244    // delete all ports that are still registered to the manager 
     
    4648      delete m_Ports.front(); 
    4749    } 
    48 
    49  
    50 bool PortManager::makeNameUnique(Port *port) 
    51 
    52     bool done=false; 
    53     int idx=0; 
    54     std::string portname_orig=port->getName(); 
    55      
    56     while(!done && idx<10000) { 
     50    for ( Util::FunctorVectorIterator it = m_UpdateHandlers.begin(); 
     51          it != m_UpdateHandlers.end(); 
     52          ++it ) 
     53    { 
     54        Util::Functor* func = *it; 
     55        delete func; 
     56    } 
     57
     58 
     59bool 
     60PortManager::makeNameUnique(Port *port) 
     61
     62    bool done = false; 
     63    int idx = 0; 
     64    std::string portname_orig = port->getName(); 
     65 
     66    while(!done && idx < 10000) { 
    5767        bool is_unique=true; 
    58          
     68 
    5969        for ( PortVectorIterator it = m_Ports.begin(); 
    6070        it != m_Ports.end(); 
     
    6373            is_unique &= !((*it)->getName() == port->getName()); 
    6474        } 
    65          
     75 
    6676        if (is_unique) { 
    67             done=true; 
     77            done = true; 
    6878        } else { 
    6979            std::ostringstream portname; 
    7080            portname << portname_orig << idx++; 
    71              
    7281            port->setName(portname.str()); 
    7382        } 
    7483    } 
    75      
    76     if(idx<10000) return true; 
     84 
     85    if(idx < 10000) return true; 
    7786    else return false; 
    7887} 
     
    8392 * @return 
    8493 */ 
    85 bool PortManager::registerPort(Port *port) 
     94bool 
     95PortManager::registerPort(Port *port) 
    8696{ 
    8797    assert(port); 
     
    94104    if (makeNameUnique(port)) { 
    95105        m_Ports.push_back(port); 
     106        callUpdateHandlers(); 
    96107        return true; 
    97108    } else { 
     
    100111} 
    101112 
    102 bool PortManager::unregisterPort(Port *port) 
     113bool 
     114PortManager::unregisterPort(Port *port) 
    103115{ 
    104116    assert(port); 
     
    111123        if(*it == port) { 
    112124            m_Ports.erase(it); 
     125            callUpdateHandlers(); 
    113126            return true; 
    114127        } 
     
    118131 
    119132    return false; //not found 
    120  
    121 
    122  
    123 int PortManager::getPortCount(enum Port::E_PortType type) { 
     133
     134 
     135int 
     136PortManager::getPortCount(enum Port::E_PortType type) 
     137
    124138    int count=0; 
    125139 
     
    135149} 
    136150 
    137 int PortManager::getPortCount() { 
    138     int count=0; 
    139  
    140     count+=m_Ports.size(); 
     151int 
     152PortManager::getPortCount() 
     153
     154    int count = 0; 
     155 
     156    count += m_Ports.size(); 
    141157 
    142158    return count; 
    143159} 
    144160 
    145 Port * PortManager::getPortAtIdx(unsigned int index) { 
     161Port * 
     162PortManager::getPortAtIdx(unsigned int index) 
     163
    146164 
    147165    return m_Ports.at(index); 
     
    149167} 
    150168 
    151 void PortManager::setVerboseLevel(int i) { 
     169void 
     170PortManager::setVerboseLevel(int i) 
     171
    152172    setDebugLevel(i); 
    153173    for ( PortVectorIterator it = m_Ports.begin(); 
     
    160180 
    161181 
    162 bool PortManager::resetPorts() { 
     182bool 
     183PortManager::resetPorts() 
     184
    163185    debugOutput( DEBUG_LEVEL_VERBOSE, "reset ports\n"); 
    164186 
     
    175197} 
    176198 
    177 bool PortManager::initPorts() { 
     199bool 
     200PortManager::initPorts() 
     201
    178202    debugOutput( DEBUG_LEVEL_VERBOSE, "init ports\n"); 
    179203 
     
    190214} 
    191215 
    192 bool PortManager::preparePorts() { 
     216bool 
     217PortManager::preparePorts() 
     218
    193219    debugOutput( DEBUG_LEVEL_VERBOSE, "preparing ports\n"); 
    194220 
     
    201227            return false; 
    202228        } 
    203  
    204     } 
    205     return true; 
    206 
    207  
    208 
     229    } 
     230    return true; 
     231
     232 
     233bool 
     234PortManager::addPortManagerUpdateHandler( Util::Functor* functor ) 
     235
     236    debugOutput(DEBUG_LEVEL_VERBOSE, "Adding PortManagerUpdate handler (%p)\n", functor); 
     237    m_UpdateHandlers.push_back( functor ); 
     238    return true; 
     239
     240 
     241bool 
     242PortManager::remPortManagerUpdateHandler( Util::Functor* functor ) 
     243
     244    debugOutput(DEBUG_LEVEL_VERBOSE, "Removing PortManagerUpdate handler (%p)\n", functor); 
     245 
     246    for ( Util::FunctorVectorIterator it = m_UpdateHandlers.begin(); 
     247          it != m_UpdateHandlers.end(); 
     248          ++it ) 
     249    { 
     250        if ( *it == functor ) { 
     251            debugOutput(DEBUG_LEVEL_VERBOSE, " found\n"); 
     252            m_UpdateHandlers.erase( it ); 
     253            return true; 
     254        } 
     255    } 
     256    debugOutput(DEBUG_LEVEL_VERBOSE, " not found\n"); 
     257    return false; 
     258
     259 
     260Util::Functor* 
     261PortManager::getUpdateHandlerForPtr(void *ptr) 
     262
     263    for ( Util::FunctorVectorIterator it = m_UpdateHandlers.begin(); 
     264          it != m_UpdateHandlers.end(); 
     265          ++it ) 
     266    { 
     267        if ( (*it)->matchCallee(ptr) ) { 
     268            debugOutput(DEBUG_LEVEL_VERBOSE, " found\n"); 
     269            return *it; 
     270        } 
     271    } 
     272    return NULL; 
     273
     274 
     275void 
     276PortManager::callUpdateHandlers() 
     277
     278    for ( Util::FunctorVectorIterator it = m_UpdateHandlers.begin(); 
     279          it != m_UpdateHandlers.end(); 
     280          ++it ) 
     281    { 
     282        Util::Functor* func = *it; 
     283        debugOutput(DEBUG_LEVEL_VERBOSE, "Calling PortManagerUpdate handler (%p)\n", func); 
     284        ( *func )(); 
     285    } 
     286
     287 
     288
  • branches/libffado-2.0/src/libstreaming/generic/PortManager.h

    r864 r1452  
    2727#include "Port.h" 
    2828 
     29#include "libutil/Functors.h" 
    2930#include "debugmodule/debugmodule.h" 
    3031 
     
    6162    virtual bool preparePorts(); 
    6263 
    63      virtual void setVerboseLevel(int l); 
     64    virtual void setVerboseLevel(int l); 
     65 
     66    bool addPortManagerUpdateHandler( Util::Functor* functor ); 
     67    bool remPortManagerUpdateHandler( Util::Functor* functor ); 
     68    Util::Functor* getUpdateHandlerForPtr(void *ptr); // ugly!! 
    6469 
    6570protected: 
     71    void callUpdateHandlers(); 
    6672    PortVector m_Ports; 
    6773 
     74    Util::FunctorVector m_UpdateHandlers; 
    6875    DECLARE_DEBUG_MODULE; 
    6976}; 
  • branches/libffado-2.0/src/libstreaming/StreamProcessorManager.cpp

    r1449 r1452  
    216216        processor->setVerboseLevel(getDebugLevel()); // inherit debug level 
    217217        m_ReceiveProcessors.push_back(processor); 
     218        Util::Functor* f = new Util::MemberFunctor0< StreamProcessorManager*, void (StreamProcessorManager::*)() > 
     219                    ( this, &StreamProcessorManager::updateShadowLists, false ); 
     220        processor->addPortManagerUpdateHandler(f); 
     221        updateShadowLists(); 
    218222        return true; 
    219223    } 
    220  
    221224    if (processor->getType() == StreamProcessor::ePT_Transmit) { 
    222225        processor->setVerboseLevel(getDebugLevel()); // inherit debug level 
    223226        m_TransmitProcessors.push_back(processor); 
     227        Util::Functor* f = new Util::MemberFunctor0< StreamProcessorManager*, void (StreamProcessorManager::*)() > 
     228                    ( this, &StreamProcessorManager::updateShadowLists, false ); 
     229        processor->addPortManagerUpdateHandler(f); 
     230        updateShadowLists(); 
    224231        return true; 
    225232    } 
     
    246253                } 
    247254                m_ReceiveProcessors.erase(it); 
     255                // remove the functor 
     256                Util::Functor * f = processor->getUpdateHandlerForPtr(this); 
     257                if(f) { 
     258                    processor->remPortManagerUpdateHandler(f); 
     259                    delete f; 
     260                } 
     261                updateShadowLists(); 
    248262                return true; 
    249263            } 
     
    262276                } 
    263277                m_TransmitProcessors.erase(it); 
     278                // remove the functor 
     279                Util::Functor * f = processor->getUpdateHandlerForPtr(this); 
     280                if(f) { 
     281                    processor->remPortManagerUpdateHandler(f); 
     282                    delete f; 
     283                } 
     284                updateShadowLists(); 
    264285                return true; 
    265286            } 
     
    273294bool StreamProcessorManager::setSyncSource(StreamProcessor *s) { 
    274295    debugOutput( DEBUG_LEVEL_VERBOSE, "Setting sync source to (%p)\n", s); 
    275     m_SyncSource=s; 
     296    m_SyncSource = s; 
    276297    return true; 
    277298} 
     
    353374    debugOutput(DEBUG_LEVEL_VERBOSE, "setting activity timeout to %d\n", timeout_usec); 
    354375    setActivityWaitTimeoutUsec(timeout_usec); 
     376 
     377    updateShadowLists(); 
    355378 
    356379    return true; 
     
    14111434} 
    14121435 
    1413 // TODO: implement a port map here, instead of the loop 
     1436void 
     1437StreamProcessorManager::updateShadowLists() 
     1438
     1439    debugOutput( DEBUG_LEVEL_VERBOSE, "Updating port shadow lists...\n"); 
     1440    m_CapturePorts_shadow.clear(); 
     1441    m_PlaybackPorts_shadow.clear(); 
     1442 
     1443    for ( StreamProcessorVectorIterator it = m_ReceiveProcessors.begin(); 
     1444        it != m_ReceiveProcessors.end(); 
     1445        ++it ) { 
     1446        PortManager *pm = *it; 
     1447        for (int i=0; i < pm->getPortCount(); i++) { 
     1448            Port *p = pm->getPortAtIdx(i); 
     1449            if (!p) { 
     1450                debugError("getPortAtIdx(%d) returned NULL\n", i); 
     1451                continue; 
     1452            } 
     1453            if(p->getDirection() != Port::E_Capture) { 
     1454                debugError("port at idx %d for receive SP is not a capture port!\n", i); 
     1455                continue; 
     1456            } 
     1457            m_CapturePorts_shadow.push_back(p); 
     1458        } 
     1459    } 
     1460    for ( StreamProcessorVectorIterator it = m_TransmitProcessors.begin(); 
     1461        it != m_TransmitProcessors.end(); 
     1462        ++it ) { 
     1463        PortManager *pm = *it; 
     1464        for (int i=0; i < pm->getPortCount(); i++) { 
     1465            Port *p = pm->getPortAtIdx(i); 
     1466            if (!p) { 
     1467                debugError("getPortAtIdx(%d) returned NULL\n", i); 
     1468                continue; 
     1469            } 
     1470            if(p->getDirection() != Port::E_Playback) { 
     1471                debugError("port at idx %d for transmit SP is not a playback port!\n", i); 
     1472                continue; 
     1473            } 
     1474            m_PlaybackPorts_shadow.push_back(p); 
     1475        } 
     1476    } 
     1477
     1478 
    14141479Port* StreamProcessorManager::getPortByIndex(int idx, enum Port::E_Direction direction) { 
    1415     int count=0; 
    1416     int prevcount=0; 
    1417  
     1480    debugOutputExtreme( DEBUG_LEVEL_ULTRA_VERBOSE, "getPortByIndex(%d, %d)...\n", idx, direction); 
    14181481    if (direction == Port::E_Capture) { 
    1419         for ( StreamProcessorVectorIterator it = m_ReceiveProcessors.begin(); 
    1420             it != m_ReceiveProcessors.end(); 
    1421             ++it ) { 
    1422             count += (*it)->getPortCount(); 
    1423             if (count > idx) { 
    1424                 return (*it)->getPortAtIdx(idx-prevcount); 
    1425             } 
    1426             prevcount=count; 
    1427         } 
     1482        #ifdef DEBUG 
     1483        if(idx >= (int)m_CapturePorts_shadow.size()) { 
     1484            debugError("Capture port %d out of range (%d)\n", idx, m_CapturePorts_shadow.size()); 
     1485            return NULL; 
     1486        } 
     1487        #endif 
     1488        return m_CapturePorts_shadow.at(idx); 
    14281489    } else { 
    1429         for ( StreamProcessorVectorIterator it = m_TransmitProcessors.begin(); 
    1430             it != m_TransmitProcessors.end(); 
    1431             ++it ) { 
    1432             count += (*it)->getPortCount(); 
    1433             if (count > idx) { 
    1434                 return (*it)->getPortAtIdx(idx-prevcount); 
    1435             } 
    1436             prevcount=count; 
    1437         } 
     1490        #ifdef DEBUG 
     1491        if(idx >= (int)m_PlaybackPorts_shadow.size()) { 
     1492            debugError("Playback port %d out of range (%d)\n", idx, m_PlaybackPorts_shadow.size()); 
     1493            return NULL; 
     1494        } 
     1495        #endif 
     1496        return m_PlaybackPorts_shadow.at(idx); 
    14381497    } 
    14391498    return NULL; 
  • branches/libffado-2.0/src/libstreaming/StreamProcessorManager.h

    r1373 r1452  
    2525#define __FFADO_STREAMPROCESSORMANAGER__ 
    2626 
     27#include "generic/PortManager.h" 
    2728#include "generic/Port.h" 
    2829#include "generic/StreamProcessor.h" 
     
    179180    StreamProcessorVector m_TransmitProcessors; 
    180181 
     182    // port shadow lists 
     183    PortVector m_CapturePorts_shadow; 
     184    PortVector m_PlaybackPorts_shadow; 
     185    void updateShadowLists(); 
     186 
    181187    unsigned int m_nb_buffers; 
    182188    unsigned int m_period; 
  • branches/libffado-2.0/src/libutil/Functors.h

    r960 r1452  
    2626 
    2727#include <semaphore.h> 
     28#include <vector> 
    2829 
    2930namespace Util { 
     
    3637 
    3738    virtual void operator() () = 0; 
     39    virtual bool matchCallee(void *) = 0; 
    3840}; 
     41 
     42typedef std::vector<Functor *> FunctorVector; 
     43typedef std::vector<Functor *>::iterator FunctorVectorIterator; 
    3944 
    4045//////////////////////////////////////////////////////////////////////// 
     
    7479            } 
    7580            if (m_bDelete) { 
    76             delete this; 
     81                delete this; 
     82            } 
    7783        } 
    78     } 
     84    virtual bool matchCallee(void *p) 
     85        { 
     86            return p == (void *)m_pCallee; 
     87        } 
    7988 
    8089private: 
     
    126135    } 
    127136 
     137    virtual bool matchCallee(void *p) 
     138        { 
     139            return p == (void *)m_pCallee; 
     140        } 
     141 
    128142private: 
    129143    CalleePtr  m_pCallee; 
     
    167181            } 
    168182        } 
     183    virtual bool matchCallee(void *p) 
     184        { 
     185            return false; 
     186        } 
    169187 
    170188private: