src/base/allocators.hh

/*
 * Copyright (c) 2017 ARM Limited
 * All rights reserved
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met: redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer;
 * redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the distribution;
 * neither the name of the copyright holders nor the names of its
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * Authors: Rekai Gonzalez-Alberquilla
 *
 */

#ifndef __BASE_ALLOCATORS_HH__
#define __BASE_ALLOCATORS_HH__

#include <memory>

/** Allocator class with arguments.
 * As the current implementation of the Stats does not allow to copy-construct
 * stats, objects with stats cannot be constructed. This imposes a limitation
 * to the use of stl containers to hold such objects. The way to work around
 * that is using a custom allocator that will construct each of the allocated
 * objects with the particulars parameters specified in the definition of the
 * allocator.
 *
 * E.g.: If we want to have an allocator for the LSQUnit that receives the LQ
 * and SQ sizes, so when building the O3 model LSQ, we can have the LSQUnits
 * be a std::vector<LSQUnit> instead of a LSQUnit*, we define:
 *  using LSQUnitAllocator = ArgAllocator<LSQUnit, uint32_t, uint32_t>
 *  std::vector<LSQUnit, LSQUnitAllocator> threads;
 *
 * And later, in the constructor we do:
 * LSQ(LSQParams* params) :
 *      ..., threads(params->numThreads,
 *                   LSQUnitAllocator(params->LQEntries, params->SQEntries)),
 *      ...
 *  {}
 *
 * This way the LSQUnits are build in-place with the appropriate parameters.
 *
 */
template <typename T, typename ... Args>
struct ArgAllocator;

template <typename T>
struct ArgAllocator<T> : std::allocator<T>
{
    /** Convenience alias to the parent class. */
    using Base = std::allocator<T>;

    /** Traits. */
    /** @{ */
    using value_type = T;
    using pointer = T*;
    using const_pointer = const T*;
    /** @} */

    /** Rebinding. */
    template <typename U>
    struct rebind { using other = ArgAllocator<U>; };

    /** Use the default memory allocation/deallocation functions. */
    /** @{ */
    using Base::allocate;
    using Base::deallocate;
    /** @} */

    /** Equality operator. */
    bool operator==(const ArgAllocator& that) { return true; }

    /** Inequality operator. */
    bool operator!=(const ArgAllocator& that) { return false; }

    /** Custom T constructor.
     * Ignore whatever arguments we may get, and just call with the args the
     * allocator was constructed with. This is required because the stl
     * implementation may be tempted to pass a T& in case we feel like
     * copy-constructing.
     */
    template <typename ... Args>
    void construct(T* p, Args&& ... aas) { helper(p); }

    /** Utility function to pass the args to the constructor of T. */
    template <typename ... Args>
    void helper(T* p, Args ... args) { ::new ((void*)p) T(args...); }
};

template <typename T, typename A, typename ... As>
struct ArgAllocator<T, A, As...> : ArgAllocator<T, As...>
{
    /** Convenience alias to the parent class. */
    using Base = ArgAllocator<T, As...>;

    /** Argument value. */
    A _arg;

    /** Traits. */
    /** @{ */
    using Base::value_type;
    using Base::pointer;
    using Base::const_pointer;
    /** @} */

    /** Rebinding. */
    template <typename U>
    struct rebind { using other = ArgAllocator<U, A, As...>; };

    /** Use the base memory allocation/deallocation functions. */
    /** @{ */
    using Base::allocate;
    using Base::deallocate;
    /** @} */

    /** Constructor.
     * Store the first arg, and pass on the rest to the parent.
     */
    ArgAllocator(const typename A::value_type& arg,
            const typename As::value_type ... args)
        : Base(args...), _arg(arg) { }

    /** Equality operator. */
    bool operator==(const ArgAllocator& that) {
        return _arg == that._arg && Base::operator==(that);
    }

    /** Inequality operator. */
    bool operator!=(const ArgAllocator& that) {
        return _arg != that._arg || Base::operator==(that);
    }

    /** Custom T constructor.
     * Ignore whatever arguments we may get, and just call with the args the
     * allocator was constructed with. This is required because the stl
     * implementation may be tempted to pass a T& in case we feel like
     * copy-constructing.
     */
    template <typename ... Args>
    void construct(T* p, Args&& ... aas) { helper(p); }

    /** Utility function to pass the args to the constructor of T. */
    template <typename ... Args>
    void helper(T* p, Args ... args) {
        Base::helper(p, args..., _arg.value());
    }
};

/** To provide more generality, we use two wrappers for arguments: FixedArg<T>
 * and IndexedArg<T>. FixedArg<T> is constructed with a T value that will be
 * used in every call to the construct function. IndexedArg<T> is constructed
 * with an initial value. In each call to construct, the current value is used
 * and post-incremented, allowing the creation of objects with consecutive ids.
 */
/** @{ */
/** Fixed argument wrapper.
 * This struct takes a fixed argument to be passed to each invocation of the
 * target type constructor performed by an ArgAllocator::construct invocation
 */
template <typename T>
struct FixedArg
{
    using value_type = T;
    T _arg;
    FixedArg(const T& arg) : _arg(arg) {}
    T value() { return _arg; }
};

/** Fixed argument wrapper.
 * This struct takes a an initial value for an argument to be passed to each
 * invocation of the target type constructor performed by an
 * ArgAllocator::construct invocation, and that is incremented afterwards.
 */
template <typename T>
struct IndexedArg
{
    using value_type = T;
    T _arg;
    IndexedArg(const T& arg) : _arg(arg) {}
    T value() { return _arg++; }
};
/** @} */

#endif /* __BASE_ALLOCATORS_HH__ */