CuaConcurrent.h

Veure la documentació d'aquest fitxer.

#if !defined(_CUA_CONCURRENT_H_)
#define _CUA_CONCURRENT_H_

/*
 * Copyright (c) 2012 Toni Corvera
 *
 * This file is part of TFCWeb.
 *
 * TFCWeb 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 3 of the License, or
 * (at your option) any later version.
 *
 * TFCWeb 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 TFCWeb. If not, see <http://www.gnu.org/licenses/>.
 */

#include "portabilitat.h"

#include <algorithm>
#include <deque>
#include <boost/thread.hpp>

namespace tfc {

// Nota: boost::unique_lock<boost::mutex> i boost::mutex::scoped_lock són equivalents

// A diferència de la majoria del projecte es fan servir noms en anglès per
// apropar-se a la STL
// Altres fonts d'informació:
//  - Implementació de cua concurrent sense locks: http://www.drdobbs.com/parallel/211601363
template<typename T, typename TContenidor = std::deque<T> >
class CuaConcurrent {
private:
    // Drecera
    typedef boost::unique_lock<boost::mutex> scope_lock;
public:
    // Tipus definits per els contenidors de la STL (només els que es fan servir)
    typedef T value_type; 
    typedef T & reference; 
    typedef const T & const_reference; 
    typedef typename TContenidor::size_type size_type; 

    typedef boost::posix_time::milliseconds milliseconds; // Drecera

    CuaConcurrent() {
        // buit
    }

    CuaConcurrent(const CuaConcurrent & c)
    {
        //impl_.reserve(c.impl_.size());
        scope_lock lock(c.mtx_);
        // No cal blocar `this`
        std::copy(c.impl_.begin(), c.impl_.end(), impl_.begin());
    }

    virtual ~CuaConcurrent() {}

    bool pop(reference desti, const milliseconds & ms)
        throw (boost::thread_exception, boost::thread_interrupted)
    {
        // Seria millor utilitzar scoped_timed_lock?
        scope_lock lock(mtx_);
        while (impl_.empty()) {
            // Esperar notificació, desbloca mutex fins que retorni
            const bool ok = cond_.timed_wait(lock, ms);
            if (!ok) {
                return false;
            }
        }
        desti = impl_.front();
        impl_.pop_front();
        return true;
    }

    void pop(reference desti)
        throw (boost::thread_exception, boost::thread_interrupted)
    {
        scope_lock lock(mtx_);
        while (impl_.empty()) {
            cond_.wait(lock); // Esperar notificació, desbloca mutex fins que retorni
        }
        boost::posix_time::millisec(1);
        desti = impl_.front();
        impl_.pop_front();
    }

    void push(const_reference element) {
        scope_lock lock(mtx_);
        const bool cal_notificar = impl_.empty();
        impl_.push_back(element);
        // alliberar assegura que el thread notificat pot accedir immediatament
        lock.unlock();
        if (cal_notificar) {
            cond_.notify_one();
        }
    }

    bool try_pop(reference desti) {
        boost::try_mutex::scoped_try_lock lock(mtx_);
        if (!lock || impl_.empty()) {
            return false;
        }
        desti = impl_.front();
        impl_.pop_front();
        return true;
    }

    bool try_push(const_reference element) {
        boost::try_mutex::scoped_try_lock lock(mtx_);
        if (!lock) {
            return false;
        }
        impl_.push_back(element);
        return true;
    }

    bool empty() const {
        boost::mutex::scoped_lock lock(mtx_);
        return impl_.empty();
    }

    size_type size() const {
        boost::mutex::scoped_lock lock(mtx_);
        return impl_.size();
    }

    // Degut a les "race conditions" no és recomanable utilitzar front() i back()
#if 0

    reference front() {
        UNUSED boost::mutex::scoped_lock lock(mtx_);
        return impl_.front();
    }

    const_reference front() const {
        // Cal blocar?
        UNUSED boost::mutex::scoped_lock lock(mtx_);
        return impl_.front();
    }

    const_reference back() const {
        UNUSED boost::mutex::scoped_lock lock(mtx_);
        return impl_.back();
    }

    reference back() {
        UNUSED boost::mutex::scoped_lock lock(mtx_);
        return impl_.back();
    }
#endif
private:
    TContenidor impl_; 
    boost::condition_variable cond_; 
    mutable boost::mutex mtx_; 
};

} // ns tfc

#endif // _CUA_CONCURRENT_H_

// vim:set ts=4 et ai: //