PacketImpl.cci

Go to the documentation of this file.

//
// Copyright (c) 2020 Fraunhofer Institute for Applied Information Technology (FIT)
//                    Network Research Group (NET)
//                    Schloss Birlinghoven, 53754 Sankt Augustin, GERMANY
//                    Contact: support@wiback.org
//
// This file is part of the SENF code tree.
// It is licensed under the 3-clause BSD License (aka New BSD License).
// See LICENSE.txt in the top level directory for details or visit
// https://opensource.org/licenses/BSD-3-Clause
//


/** \file
    \brief PacketImpl inline non-template implementation */

// Custom includes

#define prefix_ inline
//-/////////////////////////////////////////////////////////////////////////////////////////////////

//-/////////////////////////////////////////////////////////////////////////////////////////////////
// senf::detail::AnnotationRegistry

prefix_ std::string senf::detail::AnnotationRegistry::name(key_type key)
    const
{
    Registry::const_iterator i (registry_.find(key));
    return i == registry_.end() ? "" : i->second->v_name();
}

prefix_ bool senf::detail::AnnotationRegistry::isComplex(key_type key)
    const
{
    Registry::const_iterator i (registry_.find(key));
    return i != registry_.end() && i->second->v_isComplex();
}

prefix_ unsigned senf::detail::AnnotationRegistry::size(key_type key)
    const
{
    Registry::const_iterator i (registry_.find(key));
    return i == registry_.end() ? 0 : i->second->v_size();
}

prefix_ senf::detail::AnnotationRegistry::iterator senf::detail::AnnotationRegistry::begin()
    const
{
    return boost::make_transform_iterator(index_.begin(),
                                          __gnu_cxx::select2nd<Index::value_type>());
}

prefix_ senf::detail::AnnotationRegistry::iterator senf::detail::AnnotationRegistry::end()
    const
{
    return boost::make_transform_iterator(index_.end(),
                                          __gnu_cxx::select2nd<Index::value_type>());
}

prefix_ senf::detail::AnnotationRegistry::AnnotationRegistry()
    : simpleAnnotationCount_ (0)
#ifndef SENF_PACKET_NO_COMPLEX_ANNOTATIONS
    , complexAnnotationCount_ (0)
#endif
{}

//-/////////////////////////////////////////////////////////////////////////////////////////////////

// Memory management:
//
// * The PacketImpl destructor will *explicitly* clean-up the interpreters_ list by removing
//   each element from the list and deleting it if it's (intrusive) refcount is 0
// * The PacketInterpreters use safe hooks -> they know whether they are part of a list or not
// * PacketHandle has an intrusive_ptr to PacketInterpreterBase. The intrusive_ptr_add_ref
//   will refcount both the PacketImpl as well as the PacketInterpreterBase
// * intrusive_ptr_remove will only delete the object if it's not in a container
// * removing an object from the list will decrement the PacketImpl refcount accordingly
// * inserting an object into the list will increment the PacketImpl refcount accordingly
// * each PacketInterpreterBase instance holds a *raw* pointer to the PacketImpl
//
// The following operations change refcounts:
//
// * intrusive_ptr_add_ref(PacketInterpreterBase *);
// * intrusive_ptr_remove(PacketInterpreterBase *);
// * PacketImpl::appendInterpreter();
// * PacketImpl::prependInterpreter();
// * PacketImpl::truncateInterpreters();
//
// The last three also modify the impl_ member accordingly by calling
// PacketInterpreterBase::assign/release

//-/////////////////////////////////////////////////////////////////////////////////////////////////
// senf::detail::PacketImpl

prefix_ senf::detail::PacketImpl::PacketImpl()
    : refcount_(0)
#ifdef SENF_PACKET_ALTERNATIVE_PREALLOC
    , preallocHigh_(0), preallocFree_(0)
#else
    , preallocFree_(prealloc_)
#endif
#ifndef SENF_PACKET_NO_HEAP_INTERPRETERS
    , preallocHeapcount_(0)
#endif
{
    ::memset(simpleAnnotations_, 0, sizeof(simpleAnnotations_));
#ifndef SENF_PACKET_ALTERNATIVE_PREALLOC
    ::memset(prealloc_, 0, sizeof(prealloc_));
#endif
}

prefix_ senf::detail::PacketImpl::PacketImpl(size_type size, byte initValue)
    : refcount_(0), data_(size,initValue)
#ifdef SENF_PACKET_ALTERNATIVE_PREALLOC
    , preallocHigh_(0), preallocFree_(0)
#else
    , preallocFree_(prealloc_)
#endif
#ifndef SENF_PACKET_NO_HEAP_INTERPRETERS
    , preallocHeapcount_(0)
#endif
{
    ::memset(simpleAnnotations_, 0, sizeof(simpleAnnotations_));
#ifndef SENF_PACKET_ALTERNATIVE_PREALLOC
    ::memset(prealloc_, 0, sizeof(prealloc_));
#endif
}

prefix_ senf::detail::PacketImpl::PacketImpl(byte * data, size_type size, size_type chunkSize,
                                             size_type offset)
    : refcount_(0)
#ifndef SENF_PACKET_STD_CONTAINER
    , data_(data, size, chunkSize, offset)
#else
    , data_(data + offset, data + offset + size)
#endif
#ifdef SENF_PACKET_ALTERNATIVE_PREALLOC
    , preallocHigh_(0), preallocFree_(0)
#else
    , preallocFree_(prealloc_)
#endif
#ifndef SENF_PACKET_NO_HEAP_INTERPRETERS
    , preallocHeapcount_(0)
#endif
{
    ::memset(simpleAnnotations_, 0, sizeof(simpleAnnotations_));
#ifndef SENF_PACKET_ALTERNATIVE_PREALLOC
    ::memset(prealloc_, 0, sizeof(prealloc_));
#endif
}

prefix_ senf::detail::PacketImpl::~PacketImpl()
{
#ifndef SENF_PACKET_NO_HEAP_INTERPRETERS
    if (preallocHeapcount_)
        destroySelf();
#endif
}

// reference/memory management

prefix_ void senf::detail::PacketImpl::add_ref()
{
    ++ refcount_;
}

prefix_ senf::detail::PacketImpl::refcount_t senf::detail::PacketImpl::refcount()
    const
{
    return refcount_;
}

prefix_ void senf::detail::intrusive_ptr_add_ref(PacketImpl * impl)
{
    impl->add_ref();
}

prefix_ void senf::detail::intrusive_ptr_release(PacketImpl * impl)
{
    impl->release();
}

#ifndef SENF_PACKET_ALTERNATIVE_PREALLOC

prefix_ void * senf::detail::PacketImpl::allocateInterpreter()
{
#   ifndef SENF_PACKET_NO_HEAP_INTERPRETERS
        if (preallocFree_ != prealloc_ + SENF_PACKET_PREALLOC_INTERPRETERS) {
#   endif
            void * rv (preallocFree_);
            SENF_ASSERT(rv >= prealloc_ && rv < prealloc_ + SENF_PACKET_PREALLOC_INTERPRETERS,
                        "Prealloc array exceeded");
#ifdef SENF_DEBUG
            if (size_type(static_cast<PreallocSlot *>(rv) - prealloc_) > maxPreallocHigh_)
                maxPreallocHigh_ = static_cast<PreallocSlot *>(rv) - prealloc_;
#endif
            preallocFree_ += preallocFree_->nextOffset_ + 1;
            return rv;
#   ifndef SENF_PACKET_NO_HEAP_INTERPRETERS
        }
        else {
            ++ preallocHeapcount_;
#           ifdef SENF_DEBUG
                if (maxPreallocHeapcount_ < preallocHeapcount_)
                    maxPreallocHeapcount_ = preallocHeapcount_;
#           endif
            return new PreallocSlot;
        }
#   endif
}

#else /* SENF_PACKET_ALTERNATIVE_PREALLOC */

prefix_ void * senf::detail::PacketImpl::allocateInterpreter()

{
    if (preallocFree_) {
        void * rv (preallocFree_);
        SENF_ASSERT(rv >= prealloc_ && rv < prealloc_ + SENF_PACKET_PREALLOC_INTERPRETERS,
                    "Internal failure: preallocFree_ points outside of prealloc_ array");
        preallocFree_ = preallocFree_ -> nextFree_;
        return rv;
    }
    else
#ifndef SENF_PACKET_NO_HEAP_INTERPRETERS
        if (preallocHigh_ < SENF_PACKET_PREALLOC_INTERPRETERS)
#endif
        {
            SENF_ASSERT( preallocHigh_ < SENF_PACKET_PREALLOC_INTERPRETERS,
                         "Number of interpreters > SENF_PREALLOC_INTERPRETERS" );
            ++ preallocHigh_;
#ifdef SENF_DEBUG
            if (maxPreallocHigh_ < preallocHigh_)
                maxPreallocHigh_ = preallocHigh_;
#endif
            return & prealloc_[preallocHigh_ - 1];
        }
#ifndef SENF_PACKET_NO_HEAP_INTERPRETERS
    else {
        ++ preallocHeapcount_;
#ifdef SENF_DEBUG
        if (maxPreallocHeapcount_ < preallocHeapcount_)
            maxPreallocHeapcount_ = preallocHeapcount_;
#endif
        return new PreallocSlot;
    }
#endif
}

#endif /* SENF_PACKET_ALTERNATIVE_PREALLOC */

prefix_ void senf::detail::PacketImpl::deallocateInterpreter(void * address)
{
#ifndef SENF_PACKET_NO_HEAP_INTERPRETERS
    if (preallocHeapcount_ > 0 &&
        (address < prealloc_ || address > prealloc_ + SENF_PACKET_PREALLOC_INTERPRETERS)) {
        -- preallocHeapcount_;
        delete static_cast<PreallocSlot *>(address);
    }
    else {
#endif
        SENF_ASSERT(address >= prealloc_ && address < prealloc_ + SENF_PACKET_PREALLOC_INTERPRETERS,
                    "Internal failure: PacketInterpreter outside prealloc array but heapcount == 0");
#ifdef SENF_PACKET_ALTERNATIVE_PREALLOC
        static_cast<PreallocSlot *>(address)->nextFree_ = preallocFree_;
#else
        static_cast<PreallocSlot *>(address)->nextOffset_ = (preallocFree_ - static_cast<PreallocSlot *>(address)) - 1;
#endif
        preallocFree_ = static_cast<PreallocSlot *>(address);
#ifndef SENF_PACKET_NO_HEAP_INTERPRETERS
    }
#endif
}

#ifndef SENF_PACKET_STD_CONTAINER

prefix_ bool senf::detail::PacketImpl::usingExternalMemory()
    const
{
    return data_.external();
}

prefix_ void senf::detail::PacketImpl::releaseExternalMemory()
{
    data_.releaseExternal();
}

#else

prefix_ bool senf::detail::PacketImpl::usingExternalMemory()
    const
{
    return false;
}

prefix_ void senf::detail::PacketImpl::releaseExternalMemory()
{}

#endif

// Interpreter chain

prefix_ senf::PacketInterpreterBase * senf::detail::PacketImpl::first()
{
    return interpreters_.empty() ? nullptr : & interpreters_.front();
}

prefix_ senf::PacketInterpreterBase * senf::detail::PacketImpl::last()
{
    return interpreters_.empty() ? nullptr : & interpreters_.back();
}

prefix_ senf::PacketInterpreterBase * senf::detail::PacketImpl::next(PacketInterpreterBase * p)
{
    interpreter_list::iterator i (interpreter_list::s_iterator_to(*p));
    return (++i == interpreters_.end()) ? nullptr : &*i;
}

prefix_ senf::PacketInterpreterBase * senf::detail::PacketImpl::prev(PacketInterpreterBase * p)
{
    interpreter_list::iterator i (interpreter_list::s_iterator_to(*p));
    return (i == interpreters_.begin()) ? nullptr : &*(--i);
}

prefix_ void senf::detail::PacketImpl::truncateInterpreters(PacketInterpreterBase * p)
{
    Guard guard (this);
    eraseInterpreters(interpreter_list::s_iterator_to(*p),interpreters_.end());
}

prefix_ void senf::detail::PacketImpl::truncateInterpretersBackwards(PacketInterpreterBase * p)
{
    Guard guard (this);
    eraseInterpreters(interpreters_.begin(),boost::next(interpreter_list::s_iterator_to(*p)));
}

prefix_ void senf::detail::PacketImpl::clearInterpreters()
{
    interpreters_.clear();
}

// Data container

prefix_ senf::detail::PacketImpl::iterator senf::detail::PacketImpl::begin()
{
    return data_.begin();
}

prefix_ senf::detail::PacketImpl::iterator senf::detail::PacketImpl::end()
{
    return data_.end();
}

prefix_ senf::detail::PacketImpl::size_type senf::detail::PacketImpl::size()
{
    return data_.size();
}

prefix_ void senf::detail::PacketImpl::insert(PacketData * self, iterator pos, byte v)
{
    difference_type ix (std::distance(begin(),pos));
    data_.insert(pos,v);
    updateIterators(self,ix,1);
}

prefix_ void senf::detail::PacketImpl::insert(PacketData * self, iterator pos, size_type n,
                                              byte v)
{
    difference_type ix (std::distance(begin(),pos));
    data_.insert(pos,n,v);
    updateIterators(self,ix,n);
}

prefix_ void senf::detail::PacketImpl::erase(PacketData * self, iterator pos)
{
    difference_type ix (std::distance(begin(),pos));
    data_.erase(pos);
    updateIterators(self,ix,-1);
}

prefix_ void senf::detail::PacketImpl::erase(PacketData * self, iterator first, iterator last)
{
    difference_type ix (std::distance(begin(),first));
    difference_type delta (std::distance(first,last));
    data_.erase(first,last);
    updateIterators(self,ix,-delta);
}

#ifdef SENF_PACKET_STD_CONTAINER

prefix_ void senf::detail::PacketImpl::truncateDataBackwards(PacketData * self, iterator pos)
{
    erase(self, begin(), pos);
}

prefix_ senf::detail::PacketImpl::iterator
senf::detail::PacketImpl::truncateRawDataBackwards(iterator pos)
{
    SENF_ASSERT( interpreters_.empty(),
                 "truncateRawDataBackwards called with non-empty interpreter chain" );
    data_.erase(data_.begin(), pos);
    return data_.begin();
}

prefix_ void senf::detail::PacketImpl::truncateRawDataForward(iterator pos)
{
    data_.erase(pos, data_.end());
}

#else

prefix_ void senf::detail::PacketImpl::truncateDataBackwards(PacketData * self, iterator pos)
{
    difference_type delta (std::distance(begin(),pos));
    data_.truncateFront(pos);
    updateIterators(self,0,-delta);
}

prefix_ senf::detail::PacketImpl::iterator
senf::detail::PacketImpl::truncateRawDataBackwards(iterator pos)
{
    SENF_ASSERT( interpreters_.empty(),
                 "truncateRawDataBackwards called with non-empty interpreter chain" );
    data_.truncateFront(pos);
    return pos;
}

prefix_ void senf::detail::PacketImpl::truncateRawDataForward(iterator pos)
{
    data_.truncateBack(pos);
}

#endif

// Annotations

prefix_ void * senf::detail::PacketImpl::annotation(AnnotationRegistry::key_type key)
{
#ifndef SENF_PACKET_NO_COMPLEX_ANNOTATIONS
    return key >= 0 ? & simpleAnnotations_[key] : complexAnnotation(key);
#else
    return & simpleAnnotations_[key];
#endif
}

prefix_ senf::detail::PacketImpl::size_type senf::detail::PacketImpl::maxPreallocHigh()
{
#if defined(SENF_DEBUG)
    return maxPreallocHigh_;
#else
    return -1;
#endif
}

prefix_ senf::detail::PacketImpl::size_type senf::detail::PacketImpl::maxPreallocHeapcount()
{
#if defined(SENF_DEBUG) && ! defined(SENF_PACKET_NO_HEAP_INTERPRETERS)
    return maxPreallocHeapcount_;
#else
    return -1;
#endif
}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
// senf::detail::PacketImpl::Guard

prefix_ senf::detail::PacketImpl::Guard::Guard(PacketImpl * impl)
    : p (impl)
{
    p->add_ref();
}

prefix_ senf::detail::PacketImpl::Guard::~Guard()
{
    p->release();
}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
#undef prefix_


// Local Variables:
// mode: c++
// fill-column: 100
// c-file-style: "senf"
// indent-tabs-mode: nil
// ispell-local-dictionary: "american"
// compile-command: "scons -u test"
// comment-column: 40
// End: