block_adjacent_difference.hpp

/******************************************************************************
* Copyright (c) 2011, Duane Merrill.  All rights reserved.
* Copyright (c) 2011-2018, NVIDIA CORPORATION.  All rights reserved.
* Modifications Copyright (c) 2022, Advanced Micro Devices, Inc.  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 NVIDIA CORPORATION 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 NVIDIA CORPORATION 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.
*
******************************************************************************/

#ifndef ROCPRIM_BLOCK_BLOCK_ADJACENT_DIFFERENCE_HPP_
#define ROCPRIM_BLOCK_BLOCK_ADJACENT_DIFFERENCE_HPP_


#include "detail/block_adjacent_difference_impl.hpp"

#include "../config.hpp"
#include "../detail/various.hpp"




BEGIN_ROCPRIM_NAMESPACE

template<
    class T,
    unsigned int BlockSizeX,
    unsigned int BlockSizeY = 1,
    unsigned int BlockSizeZ = 1
>
class block_adjacent_difference
#ifndef DOXYGEN_SHOULD_SKIP_THIS // hide implementation detail from documentation
    : private detail::block_adjacent_difference_impl<T, BlockSizeX, BlockSizeY, BlockSizeZ>
#endif // DOXYGEN_SHOULD_SKIP_THIS
{
    using base_type = detail::block_adjacent_difference_impl<T, BlockSizeX, BlockSizeY, BlockSizeZ>;

    static constexpr unsigned BlockSize = base_type::BlockSize;
    // Struct used for creating a raw_storage object for this primitive's temporary storage.
    struct storage_type_
    {
        typename base_type::storage_type left;
        typename base_type::storage_type right;
    };

public:

    #ifndef DOXYGEN_SHOULD_SKIP_THIS // hides storage_type implementation for Doxygen
    using storage_type = detail::raw_storage<storage_type_>;
    #else
    using storage_type = storage_type_;
    #endif

    template<unsigned int ItemsPerThread, class Flag, class FlagOp>
    [[deprecated("The flags API of block_adjacent_difference is deprecated."
                 "Use subtract_left or block_discontinuity.flag_heads instead.")]]
    ROCPRIM_DEVICE ROCPRIM_INLINE
    void flag_heads(Flag (&head_flags)[ItemsPerThread],
                    const T (&input)[ItemsPerThread],
                    FlagOp flag_op,
                    storage_type& storage)
    {
        static constexpr auto as_flags         = true;
        static constexpr auto reversed         = true;
        static constexpr auto with_predecessor = false;
        base_type::template apply_left<as_flags, reversed, with_predecessor>(
            input, head_flags, flag_op, input[0] /* predecessor */, storage.get().left);
    }

    template<unsigned int ItemsPerThread, class Flag, class FlagOp>
    [[deprecated("The flags API of block_adjacent_difference is deprecated."
                 "Use subtract_left or block_discontinuity.flag_heads instead.")]]
    ROCPRIM_DEVICE ROCPRIM_FORCE_INLINE
    void flag_heads(Flag (&head_flags)[ItemsPerThread],
                    const T (&input)[ItemsPerThread],
                    FlagOp flag_op)
    {
        ROCPRIM_SHARED_MEMORY storage_type storage;
        flag_heads(head_flags, input, flag_op, storage);
    }

    template<unsigned int ItemsPerThread, class Flag, class FlagOp>
    [[deprecated("The flags API of block_adjacent_difference is deprecated."
                 "Use subtract_left or block_discontinuity.flag_heads instead.")]]
    ROCPRIM_DEVICE ROCPRIM_INLINE
    void flag_heads(Flag (&head_flags)[ItemsPerThread],
                    T tile_predecessor_item,
                    const T (&input)[ItemsPerThread],
                    FlagOp flag_op,
                    storage_type& storage)
    {
        static constexpr auto as_flags         = true;
        static constexpr auto reversed         = true;
        static constexpr auto with_predecessor = true;
        base_type::template apply_left<as_flags, reversed, with_predecessor>(
            input, head_flags, flag_op, tile_predecessor_item, storage.get().left);
    }

    template<unsigned int ItemsPerThread, class Flag, class FlagOp>
    [[deprecated("The flags API of block_adjacent_difference is deprecated."
                 "Use subtract_left or block_discontinuity.flag_heads instead.")]]
    ROCPRIM_DEVICE ROCPRIM_FORCE_INLINE
    void flag_heads(Flag (&head_flags)[ItemsPerThread],
                    T tile_predecessor_item,
                    const T (&input)[ItemsPerThread],
                    FlagOp flag_op)
    {
        ROCPRIM_SHARED_MEMORY storage_type storage;
        flag_heads(head_flags, tile_predecessor_item, input, flag_op, storage);
    }

    template<unsigned int ItemsPerThread, class Flag, class FlagOp>
    [[deprecated("The flags API of block_adjacent_difference is deprecated."
                 "Use subtract_right or block_discontinuity.flag_tails instead.")]]
    ROCPRIM_DEVICE ROCPRIM_INLINE
    void flag_tails(Flag (&tail_flags)[ItemsPerThread],
                    const T (&input)[ItemsPerThread],
                    FlagOp flag_op,
                    storage_type& storage)
    {
        static constexpr auto as_flags       = true;
        static constexpr auto reversed         = true;
        static constexpr auto with_successor = false;
        base_type::template apply_right<as_flags, reversed, with_successor>(
            input, tail_flags, flag_op, input[0] /* successor */, storage.get().right);
    }

    template<unsigned int ItemsPerThread, class Flag, class FlagOp>
    [[deprecated("The flags API of block_adjacent_difference is deprecated."
                 "Use subtract_right or block_discontinuity.flag_tails instead.")]]
    ROCPRIM_DEVICE ROCPRIM_FORCE_INLINE
    void flag_tails(Flag (&tail_flags)[ItemsPerThread],
                    const T (&input)[ItemsPerThread],
                    FlagOp flag_op)
    {
        ROCPRIM_SHARED_MEMORY storage_type storage;
        flag_tails(tail_flags, input, flag_op, storage);
    }

    template<unsigned int ItemsPerThread, class Flag, class FlagOp>
    [[deprecated("The flags API of block_adjacent_difference is deprecated."
                 "Use subtract_right or block_discontinuity.flag_tails instead.")]]
    ROCPRIM_DEVICE ROCPRIM_INLINE
    void flag_tails(Flag (&tail_flags)[ItemsPerThread],
                    T tile_successor_item,
                    const T (&input)[ItemsPerThread],
                    FlagOp flag_op,
                    storage_type& storage)
    {
        static constexpr auto as_flags       = true;
        static constexpr auto reversed         = true;
        static constexpr auto with_successor = true;
        base_type::template apply_right<as_flags, reversed, with_successor>(
            input, tail_flags, flag_op, tile_successor_item, storage.get().right);
    }

    template<unsigned int ItemsPerThread, class Flag, class FlagOp>
    [[deprecated("The flags API of block_adjacent_difference is deprecated."
                 "Use subtract_right or block_discontinuity.flag_tails instead.")]]
    ROCPRIM_DEVICE ROCPRIM_FORCE_INLINE
    void flag_tails(Flag (&tail_flags)[ItemsPerThread],
                    T tile_successor_item,
                    const T (&input)[ItemsPerThread],
                    FlagOp flag_op)
    {
        ROCPRIM_SHARED_MEMORY storage_type storage;
        flag_tails(tail_flags, tile_successor_item, input, flag_op, storage);
    }

    template<unsigned int ItemsPerThread, class Flag, class FlagOp>
    [[deprecated("The flags API of block_adjacent_difference is deprecated."
                 "Use block_discontinuity.flag_heads_and_tails instead.")]]
    ROCPRIM_DEVICE ROCPRIM_INLINE
    void flag_heads_and_tails(Flag (&head_flags)[ItemsPerThread],
                              Flag (&tail_flags)[ItemsPerThread],
                              const T (&input)[ItemsPerThread],
                              FlagOp flag_op,
                              storage_type& storage)
    {
        static constexpr auto as_flags         = true;
        static constexpr auto reversed         = true;
        static constexpr auto with_predecessor = false;
        static constexpr auto with_successor   = false;

        // Copy items in case head_flags is aliased with input
        T items[ItemsPerThread];

        ROCPRIM_UNROLL
        for(unsigned int i = 0; i < ItemsPerThread; ++i) {
            items[i] = input[i];
        }

        base_type::template apply_left<as_flags, reversed, with_predecessor>(
            items, head_flags, flag_op, items[0] /*predecessor*/, storage.get().left);

        base_type::template apply_right<as_flags, reversed, with_successor>(
            items, tail_flags, flag_op, items[0] /*successor*/, storage.get().right);
    }

    template<unsigned int ItemsPerThread, class Flag, class FlagOp>
    [[deprecated("The flags API of block_adjacent_difference is deprecated."
                 "Use block_discontinuity.flag_heads_and_tails instead.")]]
    ROCPRIM_DEVICE ROCPRIM_FORCE_INLINE
    void flag_heads_and_tails(Flag (&head_flags)[ItemsPerThread],
                              Flag (&tail_flags)[ItemsPerThread],
                              const T (&input)[ItemsPerThread],
                              FlagOp flag_op)
    {
        ROCPRIM_SHARED_MEMORY storage_type storage;
        flag_heads_and_tails(head_flags, tail_flags, input, flag_op, storage);
    }

    template<unsigned int ItemsPerThread, class Flag, class FlagOp>
    [[deprecated("The flags API of block_adjacent_difference is deprecated."
                 "Use block_discontinuity.flag_heads_and_tails instead.")]]
    ROCPRIM_DEVICE ROCPRIM_INLINE
    void flag_heads_and_tails(Flag (&head_flags)[ItemsPerThread],
                              Flag (&tail_flags)[ItemsPerThread],
                              T tile_successor_item,
                              const T (&input)[ItemsPerThread],
                              FlagOp flag_op,
                              storage_type& storage)
    {
        static constexpr auto as_flags         = true;
        static constexpr auto reversed         = true;
        static constexpr auto with_predecessor = false;
        static constexpr auto with_successor   = true;

        // Copy items in case head_flags is aliased with input
        T items[ItemsPerThread];

        ROCPRIM_UNROLL
        for(unsigned int i = 0; i < ItemsPerThread; ++i) {
            items[i] = input[i];
        }

        base_type::template apply_left<as_flags, reversed, with_predecessor>(
            items, head_flags, flag_op, items[0] /*predecessor*/, storage.get().left);

        base_type::template apply_right<as_flags, reversed, with_successor>(
            items, tail_flags, flag_op, tile_successor_item, storage.get().right);
    }

    template<unsigned int ItemsPerThread, class Flag, class FlagOp>
    [[deprecated("The flags API of block_adjacent_difference is deprecated."
                 "Use block_discontinuity.flag_heads_and_tails instead.")]]
    ROCPRIM_DEVICE ROCPRIM_FORCE_INLINE
    void flag_heads_and_tails(Flag (&head_flags)[ItemsPerThread],
                              Flag (&tail_flags)[ItemsPerThread],
                              T tile_successor_item,
                              const T (&input)[ItemsPerThread],
                              FlagOp flag_op)
    {
        ROCPRIM_SHARED_MEMORY storage_type storage;
        flag_heads_and_tails(head_flags, tail_flags, tile_successor_item, input, flag_op, storage);
    }

    template<unsigned int ItemsPerThread, class Flag, class FlagOp>
    [[deprecated("The flags API of block_adjacent_difference is deprecated."
                 "Use block_discontinuity.flag_heads_and_tails instead.")]]
    ROCPRIM_DEVICE ROCPRIM_INLINE
    void flag_heads_and_tails(Flag (&head_flags)[ItemsPerThread],
                              T tile_predecessor_item,
                              Flag (&tail_flags)[ItemsPerThread],
                              const T (&input)[ItemsPerThread],
                              FlagOp flag_op,
                              storage_type& storage)
    {
        static constexpr auto as_flags         = true;
        static constexpr auto reversed         = true;
        static constexpr auto with_predecessor = true;
        static constexpr auto with_successor   = false;

        // Copy items in case head_flags is aliased with input
        T items[ItemsPerThread];

        ROCPRIM_UNROLL
        for(unsigned int i = 0; i < ItemsPerThread; ++i) {
            items[i] = input[i];
        }

        base_type::template apply_left<as_flags, reversed, with_predecessor>(
            items, head_flags, flag_op, tile_predecessor_item, storage.get().left);

        base_type::template apply_right<as_flags, reversed, with_successor>(
            items, tail_flags, flag_op, items[0] /*successor*/, storage.get().right);
    }

    template<unsigned int ItemsPerThread, class Flag, class FlagOp>
    [[deprecated("The flags API of block_adjacent_difference is deprecated."
                 "Use block_discontinuity.flag_heads_and_tails instead.")]]
    ROCPRIM_DEVICE ROCPRIM_FORCE_INLINE
    void flag_heads_and_tails(Flag (&head_flags)[ItemsPerThread],
                              T tile_predecessor_item,
                              Flag (&tail_flags)[ItemsPerThread],
                              const T (&input)[ItemsPerThread],
                              FlagOp flag_op)
    {
        ROCPRIM_SHARED_MEMORY storage_type storage;
        flag_heads_and_tails(head_flags, tile_predecessor_item, tail_flags, input, flag_op, storage);
    }

    template<unsigned int ItemsPerThread, class Flag, class FlagOp>
    [[deprecated("The flags API of block_adjacent_difference is deprecated."
                 "Use block_discontinuity.flag_heads_and_tails instead.")]]
    ROCPRIM_DEVICE ROCPRIM_INLINE
    void flag_heads_and_tails(Flag (&head_flags)[ItemsPerThread],
                              T tile_predecessor_item,
                              Flag (&tail_flags)[ItemsPerThread],
                              T tile_successor_item,
                              const T (&input)[ItemsPerThread],
                              FlagOp flag_op,
                              storage_type& storage)
    {
        static constexpr auto as_flags         = true;
        static constexpr auto reversed         = true;
        static constexpr auto with_predecessor = true;
        static constexpr auto with_successor   = true;

        // Copy items in case head_flags is aliased with input
        T items[ItemsPerThread];

        ROCPRIM_UNROLL
        for(unsigned int i = 0; i < ItemsPerThread; ++i) {
            items[i] = input[i];
        }

        base_type::template apply_left<as_flags, reversed, with_predecessor>(
            items, head_flags, flag_op, tile_predecessor_item, storage.get().left);

        base_type::template apply_right<as_flags, reversed, with_successor>(
            items, tail_flags, flag_op, tile_successor_item, storage.get().right);
    }

    template<unsigned int ItemsPerThread, class Flag, class FlagOp>
    [[deprecated("The flags API of block_adjacent_difference is deprecated."
                 "Use block_discontinuity.flag_heads_and_tails instead.")]]
    ROCPRIM_DEVICE ROCPRIM_FORCE_INLINE
    void flag_heads_and_tails(Flag (&head_flags)[ItemsPerThread],
                              T tile_predecessor_item,
                              Flag (&tail_flags)[ItemsPerThread],
                              T tile_successor_item,
                              const T (&input)[ItemsPerThread],
                              FlagOp flag_op)
    {
        ROCPRIM_SHARED_MEMORY storage_type storage;
        flag_heads_and_tails(
            head_flags, tile_predecessor_item, tail_flags, tile_successor_item,
            input, flag_op, storage
        );
    }

    template <typename Output, unsigned int ItemsPerThread, typename BinaryFunction>
    ROCPRIM_DEVICE ROCPRIM_INLINE void subtract_left(const T (&input)[ItemsPerThread],
                                                     Output (&output)[ItemsPerThread],
                                                     const BinaryFunction op,
                                                     storage_type&        storage)
    {
        static constexpr auto as_flags         = false;
        static constexpr auto reversed         = true;
        static constexpr auto with_predecessor = false;

        base_type::template apply_left<as_flags, reversed, with_predecessor>(
            input, output, op, input[0] /* predecessor */, storage.get().left);
    }

    template <typename Output, unsigned int ItemsPerThread, typename BinaryFunction>
    ROCPRIM_DEVICE ROCPRIM_INLINE void subtract_left(const T (&input)[ItemsPerThread],
                                                     Output (&output)[ItemsPerThread],
                                                     const BinaryFunction op,
                                                     const T              tile_predecessor,
                                                     storage_type&        storage)
    {
        static constexpr auto as_flags         = false;
        static constexpr auto reversed         = true;
        static constexpr auto with_predecessor = true;

        base_type::template apply_left<as_flags, reversed, with_predecessor>(
            input, output, op, tile_predecessor, storage.get().left);
    }

    template <typename Output, unsigned int ItemsPerThread, typename BinaryFunction>
    ROCPRIM_DEVICE ROCPRIM_INLINE void subtract_left_partial(const T (&input)[ItemsPerThread],
                                                             Output (&output)[ItemsPerThread],
                                                             const BinaryFunction op,
                                                             const unsigned int   valid_items,
                                                             storage_type&        storage)
    {
        static constexpr auto as_flags         = false;
        static constexpr auto reversed         = true;
        static constexpr auto with_predecessor = false;

        base_type::template apply_left_partial<as_flags, reversed, with_predecessor>(
            input, output, op, input[0] /* predecessor */, valid_items, storage.get().left);
    }

    template <typename Output, unsigned int ItemsPerThread, typename BinaryFunction>
    ROCPRIM_DEVICE ROCPRIM_INLINE void subtract_left_partial(const T (&input)[ItemsPerThread],
                                                             Output (&output)[ItemsPerThread],
                                                             const BinaryFunction op,
                                                             const T              tile_predecessor,
                                                             const unsigned int   valid_items,
                                                             storage_type&        storage)
    {
        static constexpr auto as_flags         = false;
        static constexpr auto reversed         = true;
        static constexpr auto with_predecessor = true;

        base_type::template apply_left_partial<as_flags, reversed, with_predecessor>(
            input, output, op, tile_predecessor, valid_items, storage.get().left);
    }

    template <typename Output, unsigned int ItemsPerThread, typename BinaryFunction>
    ROCPRIM_DEVICE ROCPRIM_INLINE void subtract_right(const T (&input)[ItemsPerThread],
                                                      Output (&output)[ItemsPerThread],
                                                      const BinaryFunction op,
                                                      storage_type&        storage)
    {
        static constexpr auto as_flags       = false;
        static constexpr auto reversed       = false;
        static constexpr auto with_successor = false;

        base_type::template apply_right<as_flags, reversed, with_successor>(
            input, output, op, input[0] /* successor */, storage.get().right);
    }

    template <typename Output, unsigned int ItemsPerThread, typename BinaryFunction>
    ROCPRIM_DEVICE ROCPRIM_INLINE void subtract_right(const T (&input)[ItemsPerThread],
                                                      Output (&output)[ItemsPerThread],
                                                      const BinaryFunction op,
                                                      const T              tile_successor,
                                                      storage_type&        storage)
    {
        static constexpr auto as_flags       = false;
        static constexpr auto reversed       = false;
        static constexpr auto with_successor = true;

        base_type::template apply_right<as_flags, reversed, with_successor>(
            input, output, op, tile_successor, storage.get().right);
    }

    template <typename Output, unsigned int ItemsPerThread, typename BinaryFunction>
    ROCPRIM_DEVICE ROCPRIM_INLINE void subtract_right_partial(const T (&input)[ItemsPerThread],
                                                              Output (&output)[ItemsPerThread],
                                                              const BinaryFunction op,
                                                              const unsigned int   valid_items,
                                                              storage_type&        storage)
    {
        static constexpr auto as_flags = false;
        static constexpr auto reversed = false;

        base_type::template apply_right_partial<as_flags, reversed>(
            input, output, op, valid_items, storage.get().right);
    }
};

END_ROCPRIM_NAMESPACE

// end of group blockmodule

#endif // ROCPRIM_BLOCK_BLOCK_ADJACENT_DIFFERENCE_HPP_