ChunkManagerImpl.h

Go to the documentation of this file.

// -*- lsst-c++ -*-

/* 
 * LSST Data Management System
 * Copyright 2008, 2009, 2010 LSST Corporation.
 * 
 * This product includes software developed by the
 * LSST Project (http://www.lsst.org/).
 *
 * 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 3 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 LSST License Statement and 
 * the GNU General Public License along with this program.  If not, 
 * see <http://www.lsstcorp.org/LegalNotices/>.
 */
 

#ifndef LSST_AP_CHUNK_MANAGER_IMPL_H
#define LSST_AP_CHUNK_MANAGER_IMPL_H

#include <climits>
#include <iosfwd>

#include "boost/noncopyable.hpp"
#include "boost/static_assert.hpp"
//#include "boost/type_traits/has_nothrow_constructor.hpp"
//#include "boost/type_traits/has_trivial_destructor.hpp"

#include "Common.h"
#include "Bitset.h"
#include "Mutex.h"
#include "Condition.h"
#include "Chunk.h"
#include "DataTraits.h"
#include "Time.h"


namespace lsst { namespace ap { namespace detail {

template <typename EntryT, int NumEntries>
class HashedSet : private boost::noncopyable {
    BOOST_STATIC_ASSERT(NumEntries > 0 && (NumEntries & (NumEntries - 1)) == 0);
    BOOST_STATIC_ASSERT(NumEntries < INT_MAX);
//    BOOST_STATIC_ASSERT(boost::has_nothrow_constructor<EntryT>::value);
//    BOOST_STATIC_ASSERT(boost::has_trivial_destructor<EntryT>::value);

public :
    HashedSet();

    EntryT * find(int const id) {
        return const_cast<EntryT *>(doFind(id));
    }

    EntryT const * find(int const id) const {
        return doFind(id);
    }

    EntryT * insert(int const id);

    std::pair<EntryT *, bool> findOrInsert(int const id);

    bool erase(int const id);

    int size() const {
        return _size;
    }

    int space() const {
        return NumEntries - _size;
    }

    EntryT * begin() {
        return _entries;
    }
    EntryT const * begin() const {
        return _entries;
    }

    EntryT * end() {
        return _entries + NumEntries;
    }
    EntryT const * end() const {
        return _entries + NumEntries;
    }

private :
    int _hashTable[2*NumEntries];
    int _free;
    int _size;
    EntryT _entries[NumEntries];

    EntryT const * doFind(int const id) const;
};


template <typename MutexT, typename DataT, typename TraitsT = DataTraits<DataT> >
class BlockAllocator : private boost::noncopyable {
public :
    BlockAllocator(unsigned char const * const ref, std::size_t const offset);

    std::size_t allocate();
    void allocate(std::size_t * const blockOffsets, int const n);
    void free(std::size_t const * const blockOffsets, int const n);

private :
    typedef Bitset<boost::uint64_t, TraitsT::NUM_BLOCKS> Allocator;

    BOOST_STATIC_ASSERT(TraitsT::ENTRIES_PER_BLOCK_LOG2 >= 9);

    static std::size_t const BLOCK_SIZE =
        (sizeof(DataT) + sizeof(ChunkEntryFlag)) << TraitsT::ENTRIES_PER_BLOCK_LOG2;

    MutexT _mutex;
    Allocator _allocator;
    std::size_t const _offset;
};


class Visit {
public :
    Visit() : _id(-1), _next(-1), _failed(false) {}

    bool failed() const {
        return _failed;
    }
    void setFailed() {
        _failed = true;
    }

    // HashedSet requirements
    int getId() const {
        return _id;
    }
    int getNextInChain() const {
        return _next;
    }
    void setId(int const id) {
        _id = id;
    }
    void setNextInChain(int const id) {
        _next = id;
    }

private :
    int _id;
    int _next;
    bool _failed;
};


class VisitTracker : public HashedSet<Visit, MAX_VISITS_IN_FLIGHT> {
public :
    bool isValid(int const visitId) const;
    void print(std::ostream & os) const;
    void print(int const visitId, std::ostream & os) const;
};


template <typename MutexT, typename DataT, typename TraitsT = DataTraits<DataT> >
class SubManager : private boost::noncopyable {
public :
    typedef BlockAllocator<MutexT, DataT, TraitsT> Allocator;
    typedef ChunkRef<Allocator, DataT, TraitsT> Chunk;
    typedef ChunkDescriptor<TraitsT::MAX_BLOCKS_PER_CHUNK> Descriptor;

    // -- fields ----------------

    static int const NUM_CHUNKS = TraitsT::MAX_CHUNKS_PER_FOV * MAX_VISITS_IN_FLIGHT;

    HashedSet<Descriptor, NUM_CHUNKS> _chunks;
    Allocator _allocator;

    // -- methods ----------------

    SubManager(unsigned char const * const ref, std::size_t const offset) : _allocator(ref, offset) {}

    int size()  const { return _chunks.size();  }
    int space() const { return _chunks.space(); }

    void createOrRegisterInterest(
        std::vector<Chunk> & toRead,
        std::vector<Chunk> & toWaitFor,
        int const visitId,
        std::vector<int> const & chunkIds
    );

    bool checkForOwnership(
        std::vector<Chunk> & toRead,
        std::vector<Chunk> & toWaitFor,
        int const visitId
    );

    void getChunks(
        std::vector<Chunk> & chunks,
        std::vector<int> const & chunkIds
    );

    bool relinquishOwnership(
        int const visitId,
        bool const rollback,
        VisitTracker const & tracker
    );

    void print(std::ostream & os) const;
    void print(int const chunkId, std::ostream & os) const;
    void printVisit(int const visitId, std::ostream & os) const;
};


template <
    typename MutexT,
    typename DataT,
    typename TraitsT = DataTraits<DataT>
>
class ChunkManagerImpl : private boost::noncopyable {
public :
    typedef SubManager<MutexT, DataT, TraitsT> Manager;
    typedef typename Manager::Chunk Chunk;

private :
    static std::size_t blocks() {
        return (sizeof(ChunkManagerImpl) + 511) & ~static_cast<size_t>(511);
    }

public :
    static std::size_t size() {
        return blocks() + Chunk::BLOCK_SIZE * TraitsT::NUM_BLOCKS;
    }

    ChunkManagerImpl();

    bool isVisitInFlight(int const visitId);
    void failVisit(int const visitId);
    void registerVisit(int const visitId);

    void startVisit(
        std::vector<Chunk> & toRead,
        std::vector<Chunk> & toWaitFor,
        int const visitId,
        std::vector<int> const & chunkIds
    );

    void waitForOwnership(
        std::vector<Chunk> & toRead,
        std::vector<Chunk> & toWaitFor,
        int const visitId,
        TimeSpec const & deadline
    );

    void getChunks(
        std::vector<Chunk> & chunks,
        std::vector<int> const & chunkIds
    );

    bool endVisit(int const visitId, bool const rollback);

    void printVisits(std::ostream & os) const;
    void printChunks(std::ostream & os) const;
    void printVisit(int const visitId, std::ostream & os) const;
    void printChunk(int const chunkId, std::ostream & os) const;

private :
    void rollbackAllExcept(int const visitId);

    mutable MutexT    _mutex;
    Condition<MutexT> _ownerCondition;
    VisitTracker      _visits;
    Manager           _data;
};


}}} // end of namespace lsst::ap::detail

#endif // LSST_AP_CHUNK_MANAGER_IMPL_H