Diff coverage report for

//

//

// Copyright (c) 2019 Vinnie Falco (vinnie.falco@gmail.com)

// Copyright (c) 2019 Vinnie Falco (vinnie.falco@gmail.com)

// Copyright (c) 2020 Krystian Stasiowski (sdkrystian@gmail.com)

// Copyright (c) 2020 Krystian Stasiowski (sdkrystian@gmail.com)

//

//

// Distributed under the Boost Software License, Version 1.0. (See accompanying

// 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)

// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//

//

// Official repository: https://github.com/boostorg/json

// Official repository: https://github.com/boostorg/json

//

//

#ifndef BOOST_JSON_MONOTONIC_RESOURCE_HPP

#ifndef BOOST_JSON_MONOTONIC_RESOURCE_HPP

#define BOOST_JSON_MONOTONIC_RESOURCE_HPP

#define BOOST_JSON_MONOTONIC_RESOURCE_HPP

#include <boost/container/pmr/memory_resource.hpp>

#include <boost/container/pmr/memory_resource.hpp>

#include <boost/json/detail/config.hpp>

#include <boost/json/detail/config.hpp>

#include <boost/json/storage_ptr.hpp>

#include <boost/json/storage_ptr.hpp>

#include <cstddef>

#include <cstddef>

#include <utility>

#include <utility>

namespace boost {

namespace boost {

namespace json {

namespace json {

#ifdef _MSC_VER

#ifdef _MSC_VER

#pragma warning(push)

#pragma warning(push)

#pragma warning(disable: 4251) // class needs to have dll-interface to be used by clients of class

#pragma warning(disable: 4251) // class needs to have dll-interface to be used by clients of class

#pragma warning(disable: 4275) // non dll-interface class used as base for dll-interface class

#pragma warning(disable: 4275) // non dll-interface class used as base for dll-interface class

#endif

#endif

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

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

/** A dynamically allocating resource with a trivial deallocate.

/** A dynamically allocating resource with a trivial deallocate.

    This memory resource is a special-purpose resource that releases allocated

    This memory resource is a special-purpose resource that releases allocated

    memory only when the resource is destroyed (or when @ref release is

    memory only when the resource is destroyed (or when @ref release is

    called). It has a trivial deallocate function; that is, the metafunction

    called). It has a trivial deallocate function; that is, the metafunction

    @ref is_deallocate_trivial returns `true`.

    @ref is_deallocate_trivial returns `true`.

    The resource can be constructed with an initial buffer. If there is no

    The resource can be constructed with an initial buffer. If there is no

    initial buffer, or if the buffer is exhausted, subsequent dynamic

    initial buffer, or if the buffer is exhausted, subsequent dynamic

    allocations are made from the system heap. The size of buffers obtained in

    allocations are made from the system heap. The size of buffers obtained in

    this fashion follow a geometric progression.

    this fashion follow a geometric progression.

    The purpose of this resource is to optimize the use case for performing

    The purpose of this resource is to optimize the use case for performing

    many allocations, followed by deallocating everything at once. This is

    many allocations, followed by deallocating everything at once. This is

    precisely the pattern of memory allocation which occurs when parsing:

    precisely the pattern of memory allocation which occurs when parsing:

    allocation is performed for each parsed element, and when the the resulting

    allocation is performed for each parsed element, and when the the resulting

    @ref value is no longer needed, the entire structure is destroyed. However,

    @ref value is no longer needed, the entire structure is destroyed. However,

    it is not suited for modifying the value after parsing is complete;

    it is not suited for modifying the value after parsing is complete;

    reallocations waste memory, since the older buffer is not reclaimed until

    reallocations waste memory, since the older buffer is not reclaimed until

    the resource is destroyed.

    the resource is destroyed.

    @par Example

    @par Example

    This parses a JSON text into a value which uses a local stack buffer, then

    This parses a JSON text into a value which uses a local stack buffer, then

    prints the result.

    prints the result.

    @code

    @code

    unsigned char buf[ 4000 ];

    unsigned char buf[ 4000 ];

    monotonic_resource mr( buf );

    monotonic_resource mr( buf );

    // Parse the string, using our memory resource

    // Parse the string, using our memory resource

    auto const jv = parse( "[1,2,3]", &mr );

    auto const jv = parse( "[1,2,3]", &mr );

    // Print the JSON

    // Print the JSON

    std::cout << jv;

    std::cout << jv;

    @endcode

    @endcode

    @note The total amount of memory dynamically allocated is monotonically

    @note The total amount of memory dynamically allocated is monotonically

    increasing; That is, it never decreases.

    increasing; That is, it never decreases.

    @par Thread Safety

    @par Thread Safety

    Members of the same instance may not be

    Members of the same instance may not be

    called concurrently.

    called concurrently.

    @see

    @see

        https://en.wikipedia.org/wiki/Region-based_memory_management

        https://en.wikipedia.org/wiki/Region-based_memory_management

*/

*/

class

class

    BOOST_JSON_DECL

    BOOST_JSON_DECL

    BOOST_SYMBOL_VISIBLE

    BOOST_SYMBOL_VISIBLE

monotonic_resource final

monotonic_resource final

    : public container::pmr::memory_resource

    : public container::pmr::memory_resource

{

{

    struct block;

    struct block;

    struct block_base

    struct block_base

    {

    {

        void* p;

        void* p;

        std::size_t avail;

        std::size_t avail;

        std::size_t size;

        std::size_t size;

        block_base* next;

        block_base* next;

    };

    };

    block_base buffer_;

    block_base buffer_;

    block_base* head_ = &buffer_;

    block_base* head_ = &buffer_;

    std::size_t next_size_ = 1024;

    std::size_t next_size_ = 1024;

    storage_ptr upstream_;

    storage_ptr upstream_;

    static constexpr std::size_t min_size_ = 1024;

    static constexpr std::size_t min_size_ = 1024;

    inline static constexpr std::size_t max_size();

    inline static constexpr std::size_t max_size();

    inline static std::size_t round_pow2(

    inline static std::size_t round_pow2(

        std::size_t n) noexcept;

        std::size_t n) noexcept;

    inline static std::size_t next_pow2(

    inline static std::size_t next_pow2(

        std::size_t n) noexcept;

        std::size_t n) noexcept;

public:

public:

    /** Assignment operator.

    /** Assignment operator.

        Copy assignment operator is deleted. This type is not copyable or

        Copy assignment operator is deleted. This type is not copyable or

        movable.

        movable.

    */

    */

    monotonic_resource& operator=(

    monotonic_resource& operator=(

        monotonic_resource const&) = delete;

        monotonic_resource const&) = delete;

    /** Destructor.

    /** Destructor.

        Deallocates all the memory owned by this resource.

        Deallocates all the memory owned by this resource.

        @par Effects

        @par Effects

        @code

        @code

        release();

        release();

        @endcode

        @endcode

        @par Complexity

        @par Complexity

        Linear in the number of deallocations performed.

        Linear in the number of deallocations performed.

        @par Exception Safety

        @par Exception Safety

        No-throw guarantee.

        No-throw guarantee.

    */

    */

    ~monotonic_resource();

    ~monotonic_resource();

    /** Constructors.

    /** Constructors.

        Construct the resource.

        Construct the resource.

        @li **(1)** indicates that the first internal dynamic allocation shall

        @li **(1)** indicates that the first internal dynamic allocation shall

            be at least `initial_size` bytes.

            be at least `initial_size` bytes.

        @li **(2)**--**(5)** indicate that subsequent allocations should use

        @li **(2)**--**(5)** indicate that subsequent allocations should use

            the specified caller-owned buffer. When this buffer is exhausted,

            the specified caller-owned buffer. When this buffer is exhausted,

            dynamic allocations from the upstream resource are made.

            dynamic allocations from the upstream resource are made.

        @li **(6)** copy constructor is deleted. This type is not copyable or

        @li **(6)** copy constructor is deleted. This type is not copyable or

            movable.

            movable.

        None of the constructors performs any dynamic allocations.

        None of the constructors performs any dynamic allocations.

        @par Complexity

        @par Complexity

        Constant.

        Constant.

        @par Exception Safety

        @par Exception Safety

        No-throw guarantee.

        No-throw guarantee.

        @param initial_size The size of the first internal dynamic allocation.

        @param initial_size The size of the first internal dynamic allocation.

               If this is lower than the implementation-defined lower limit,

               If this is lower than the implementation-defined lower limit,

               then the lower limit is used instead.

               then the lower limit is used instead.

        @param upstream An optional upstream memory resource to use for

        @param upstream An optional upstream memory resource to use for

               performing internal dynamic allocations. If this parameter is

               performing internal dynamic allocations. If this parameter is

               omitted, the \<\<default_memory_resource,default resource\>\> is

               omitted, the \<\<default_memory_resource,default resource\>\> is

               used.

               used.

        @{

        @{

    */

    */

    explicit

    explicit

    monotonic_resource(

    monotonic_resource(

        std::size_t initial_size = 1024,

        std::size_t initial_size = 1024,

        storage_ptr upstream = {}) noexcept;

        storage_ptr upstream = {}) noexcept;

    /** Overload

    /** Overload

        @param buffer The buffer to use. Ownership is not transferred; the

        @param buffer The buffer to use. Ownership is not transferred; the

               caller is responsible for ensuring that the lifetime of the

               caller is responsible for ensuring that the lifetime of the

               buffer extends until the resource is destroyed.

               buffer extends until the resource is destroyed.

        @param size The number of valid bytes pointed to by `buffer`.

        @param size The number of valid bytes pointed to by `buffer`.

        @param upstream

        @param upstream

    */

    */

    monotonic_resource(

    monotonic_resource(

        unsigned char* buffer,

        unsigned char* buffer,

        std::size_t size,

        std::size_t size,

        storage_ptr upstream = {}) noexcept;

        storage_ptr upstream = {}) noexcept;

#if defined(__cpp_lib_byte) || defined(BOOST_JSON_DOCS)

#if defined(__cpp_lib_byte) || defined(BOOST_JSON_DOCS)

    /// Overload

    /// Overload

    monotonic_resource(

    monotonic_resource(

        std::byte* buffer,

        std::byte* buffer,

        std::size_t size,

        std::size_t size,

        storage_ptr upstream) noexcept

        storage_ptr upstream) noexcept

        : monotonic_resource(reinterpret_cast<

        : monotonic_resource(reinterpret_cast<

            unsigned char*>(buffer), size,

            unsigned char*>(buffer), size,

                std::move(upstream))

                std::move(upstream))

    {

    {

    }

    }

#endif

#endif

    /// Overload

    /// Overload

    template<std::size_t N>

    template<std::size_t N>

    explicit

    explicit

        unsigned char(&buffer)[N],

        unsigned char(&buffer)[N],

        storage_ptr upstream = {}) noexcept

        storage_ptr upstream = {}) noexcept

        : monotonic_resource(&buffer[0],

        : monotonic_resource(&buffer[0],

    {

    {

#if defined(__cpp_lib_byte) || defined(BOOST_JSON_DOCS)

#if defined(__cpp_lib_byte) || defined(BOOST_JSON_DOCS)

    /// Overload

    /// Overload

    template<std::size_t N>

    template<std::size_t N>

    explicit

    explicit

    monotonic_resource(

    monotonic_resource(

        std::byte(&buffer)[N],

        std::byte(&buffer)[N],

        storage_ptr upstream = {}) noexcept

        storage_ptr upstream = {}) noexcept

        : monotonic_resource(&buffer[0],

        : monotonic_resource(&buffer[0],

            N, std::move(upstream))

            N, std::move(upstream))

    {

    {

    }

    }

#endif

#endif

#ifndef BOOST_JSON_DOCS

#ifndef BOOST_JSON_DOCS

    // Safety net for accidental buffer overflows

    // Safety net for accidental buffer overflows

    template<std::size_t N>

    template<std::size_t N>

    monotonic_resource(

    monotonic_resource(

        unsigned char(&buffer)[N],

        unsigned char(&buffer)[N],

        std::size_t n,

        std::size_t n,

        storage_ptr upstream = {}) noexcept

        storage_ptr upstream = {}) noexcept

        : monotonic_resource(&buffer[0],

        : monotonic_resource(&buffer[0],

            n, std::move(upstream))

            n, std::move(upstream))

    {

    {

        // If this goes off, check your parameters

        // If this goes off, check your parameters

        // closely, chances are you passed an array

        // closely, chances are you passed an array

        // thinking it was a pointer.

        // thinking it was a pointer.

        BOOST_ASSERT(n <= N);

        BOOST_ASSERT(n <= N);

    }

    }

#ifdef __cpp_lib_byte

#ifdef __cpp_lib_byte

    // Safety net for accidental buffer overflows

    // Safety net for accidental buffer overflows

    template<std::size_t N>

    template<std::size_t N>

    monotonic_resource(

    monotonic_resource(

        std::byte(&buffer)[N],

        std::byte(&buffer)[N],

        std::size_t n,

        std::size_t n,

        storage_ptr upstream = {}) noexcept

        storage_ptr upstream = {}) noexcept

        : monotonic_resource(&buffer[0],

        : monotonic_resource(&buffer[0],

            n, std::move(upstream))

            n, std::move(upstream))

    {

    {

        // If this goes off, check your parameters

        // If this goes off, check your parameters

        // closely, chances are you passed an array

        // closely, chances are you passed an array

        // thinking it was a pointer.

        // thinking it was a pointer.

        BOOST_ASSERT(n <= N);

        BOOST_ASSERT(n <= N);

    }

    }

#endif

#endif

#endif

#endif

    /// Overload

    /// Overload

    monotonic_resource(

    monotonic_resource(

        monotonic_resource const&) = delete;

        monotonic_resource const&) = delete;

    /// @}

    /// @}

    /** Release all allocated memory.

    /** Release all allocated memory.

        This function deallocates all allocated memory.

        This function deallocates all allocated memory.

        If an initial buffer was provided upon construction,

        If an initial buffer was provided upon construction,

        then all of the bytes will be available again for

        then all of the bytes will be available again for

        allocation. Allocated memory is deallocated even

        allocation. Allocated memory is deallocated even

        if deallocate has not been called for some of

        if deallocate has not been called for some of

        the allocated blocks.

        the allocated blocks.

        @par Complexity

        @par Complexity

        Linear in the number of deallocations performed.

        Linear in the number of deallocations performed.

        @par Exception Safety

        @par Exception Safety

        No-throw guarantee.

        No-throw guarantee.

    */

    */

    void

    void

    release() noexcept;

    release() noexcept;

protected:

protected:

#ifndef BOOST_JSON_DOCS

#ifndef BOOST_JSON_DOCS

    void*

    void*

    do_allocate(

    do_allocate(

        std::size_t n,

        std::size_t n,

        std::size_t align) override;

        std::size_t align) override;

    void

    void

    do_deallocate(

    do_deallocate(

        void* p,

        void* p,

        std::size_t n,

        std::size_t n,

        std::size_t align) override;

        std::size_t align) override;

    bool

    bool

    do_is_equal(

    do_is_equal(

        memory_resource const& mr) const noexcept override;

        memory_resource const& mr) const noexcept override;

#endif

#endif

};

};

#ifdef _MSC_VER

#ifdef _MSC_VER

#pragma warning(pop)

#pragma warning(pop)

#endif

#endif

template<>

template<>

struct is_deallocate_trivial<

struct is_deallocate_trivial<

    monotonic_resource>

    monotonic_resource>

{

{

    static constexpr bool value = true;

    static constexpr bool value = true;

};

};

} // namespace json

} // namespace json

} // namespace boost

} // namespace boost

#endif

#endif