read_write_pool.h

/***************************************************************************
 *  include/stxxl/bits/mng/read_write_pool.h
 *
 *  Part of the STXXL. See http://stxxl.sourceforge.net
 *
 *  Copyright (C) 2009 Andreas Beckmann <[email protected]>
 *
 *  Distributed under the Boost Software License, Version 1.0.
 *  (See accompanying file LICENSE_1_0.txt or copy at
 *  http://www.boost.org/LICENSE_1_0.txt)
 **************************************************************************/

#ifndef STXXL_MNG_READ_WRITE_POOL_H
#define STXXL_MNG_READ_WRITE_POOL_H

#include <stxxl/bits/mng/write_pool.h>
#include <stxxl/bits/mng/prefetch_pool.h>


__STXXL_BEGIN_NAMESPACE



template <typename BlockType>
class read_write_pool : private noncopyable
{
public:
    typedef BlockType block_type;
    typedef typename block_type::bid_type bid_type;
    typedef unsigned_type size_type;

protected:
    typedef write_pool<block_type> write_pool_type;
    typedef prefetch_pool<block_type> prefetch_pool_type;

    write_pool_type * w_pool;
    prefetch_pool_type * p_pool;
    bool delete_pools;

public:
    explicit read_write_pool(size_type init_size_prefetch = 1, size_type init_size_write = 1) :
        delete_pools(true)
    {
        w_pool = new write_pool_type(init_size_write);
        p_pool = new prefetch_pool_type(init_size_prefetch);
    }

    _STXXL_DEPRECATED(read_write_pool(prefetch_pool_type & p_pool, write_pool_type & w_pool)) :
        w_pool(&w_pool), p_pool(&p_pool), delete_pools(false)
    { }

    void swap(read_write_pool & obj)
    {
        std::swap(w_pool, obj.w_pool);
        std::swap(p_pool, obj.p_pool);
        std::swap(delete_pools, obj.delete_pools);
    }

    virtual ~read_write_pool()
    {
        if (delete_pools) {
            delete w_pool;
            delete p_pool;
        }
    }

    size_type size_write() const { return w_pool->size(); }

    size_type size_prefetch() const { return p_pool->size(); }

    void resize_write(size_type new_size)
    {
        w_pool->resize(new_size);
    }

    void resize_prefetch(size_type new_size)
    {
        p_pool->resize(new_size);
    }

    // WRITE POOL METHODS

    request_ptr write(block_type * & block, bid_type bid)
    {
        request_ptr result = w_pool->write(block, bid);

        // if there is a copy of this block in the prefetch pool,
        // it is now a stale copy, so invalidate it and re-hint the block
        if (p_pool->invalidate(bid))
            p_pool->hint(bid, *w_pool);

        return result;
    }

    block_type * steal()
    {
        return w_pool->steal();
    }

    void add(block_type * & block)
    {
        w_pool->add(block);
    }

    // PREFETCH POOL METHODS

    bool hint(bid_type bid)
    {
        return p_pool->hint(bid, *w_pool);
    }

    bool invalidate(bid_type bid)
    {
        return p_pool->invalidate(bid);
    }

    request_ptr read(block_type * & block, bid_type bid)
    {
        return p_pool->read(block, bid, *w_pool);
    }
};


__STXXL_END_NAMESPACE


namespace std
{
    template <class BlockType>
    void swap(stxxl::read_write_pool<BlockType> & a,
              stxxl::read_write_pool<BlockType> & b)
    {
        a.swap(b);
    }
}

#endif // !STXXL_MNG_READ_WRITE_POOL_H
// vim: et:ts=4:sw=4