blas0.hpp

Go to the documentation of this file.

/*
 *   Copyright 2021 Huawei Technologies Co., Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef _H_GRB_BLAS0
#define _H_GRB_BLAS0

#include <functional>
#include <stdexcept>
#include <type_traits> //enable_if

#include "graphblas/descriptors.hpp"
#include "graphblas/rc.hpp"
#include "graphblas/type_traits.hpp"

#define NO_CAST_ASSERT( x, y, z )                                                  \
    static_assert( x,                                                              \
        "\n\n"                                                                     \
        "************************************************************************" \
        "************************************************************************" \
        "**********************\n"                                                 \
        "*     ERROR      | " y " " z ".\n"                                        \
        "************************************************************************" \
        "************************************************************************" \
        "**********************\n"                                                 \
        "* Possible fix 1 | Remove no_casting from the template parameters in "    \
        "this call to " y ".\n"                                                    \
        "* Possible fix 2 | Provide a left-hand side input value of the same "     \
        "type as the first domain of the given operator.\n"                        \
        "* Possible fix 3 | Provide a right-hand side input value of the same "    \
        "type as the second domain of the given operator.\n"                       \
        "* Possible fix 4 | Provide an output value of the same type as the "      \
        "third domain of the given operator.\n"                                    \
        "* Note that in case of in-place operators the left-hand side input or "   \
        "right-hand side input also play the role of the output value.\n"          \
        "************************************************************************" \
        "************************************************************************" \
        "**********************\n" );


namespace grb {

    template<
        Descriptor descr = descriptors::no_operation,
        class OP,
        typename InputType1, typename InputType2, typename OutputType
    >
    static enum RC apply(
        OutputType &out,
        const InputType1 &x,
        const InputType2 &y,
        const OP &op = OP(),
        const typename std::enable_if<
            grb::is_operator< OP >::value &&
            !grb::is_object< InputType1 >::value &&
            !grb::is_object< InputType2 >::value &&
            !grb::is_object< OutputType >::value,
        void >::type * = nullptr
    ) {
        // static sanity check
        NO_CAST_ASSERT( ( !( descr & descriptors::no_casting ) || (
                std::is_same< InputType1, typename OP::D1 >::value &&
                std::is_same< InputType2, typename OP::D2 >::value &&
                std::is_same< OutputType, typename OP::D3 >::value
            ) ),
            "grb::apply (BLAS level 0)",
            "Argument value types do not match operator domains while no_casting "
            "descriptor was set"
        );

        // call apply
        const typename OP::D1 left = static_cast< typename OP::D1 >( x );
        const typename OP::D2 right = static_cast< typename OP::D2 >( y );
        typename OP::D3 output = static_cast< typename OP::D3 >( out );
        op.apply( left, right, output );
        out = static_cast< OutputType >( output );

        // done
        return SUCCESS;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        class OP, typename InputType, typename IOType
    >
    static RC foldr(
        const InputType &x,
        IOType &y,
        const OP &op = OP(),
        const typename std::enable_if<
            grb::is_operator< OP >::value &&
            !grb::is_object< InputType >::value &&
            !grb::is_object< IOType >::value, void
        >::type * = nullptr
    ) {
        // static sanity check
        NO_CAST_ASSERT( ( !(descr & descriptors::no_casting) || (
                std::is_same< InputType, typename OP::D1 >::value &&
                std::is_same< IOType, typename OP::D2 >::value &&
                std::is_same< IOType, typename OP::D3 >::value
            ) ), "grb::foldr (BLAS level 0)",
            "Argument value types do not match operator domains while no_casting "
            "descriptor was set" );

        // call foldr
        const typename OP::D1 left = static_cast< typename OP::D1 >( x );
        typename OP::D3 right = static_cast< typename OP::D3 >( y );
        op.foldr( left, right );
        y = static_cast< IOType >( right );

        // done
        return SUCCESS;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        class OP,
        typename InputType, typename IOType
    >
    static RC foldl(
        IOType &x,
        const InputType &y,
        const OP &op = OP(),
        const typename std::enable_if< grb::is_operator< OP >::value &&
            !grb::is_object< InputType >::value &&
            !grb::is_object< IOType >::value, void
        >::type * = nullptr
    ) {
        // static sanity check
        NO_CAST_ASSERT( ( !(descr & descriptors::no_casting) || (
                std::is_same< IOType, typename OP::D1 >::value &&
                std::is_same< InputType, typename OP::D2 >::value &&
                std::is_same< IOType, typename OP::D3 >::value
            ) ), "grb::foldl (BLAS level 0)",
            "Argument value types do not match operator domains while no_casting "
            "descriptor was set" );

        // call foldl
        typename OP::D1 left = static_cast< typename OP::D1 >( x );
        const typename OP::D3 right = static_cast< typename OP::D3 >( y );
        op.foldl( left, right );
        x = static_cast< IOType >( left );

        // done
        return SUCCESS;
    }

    namespace internal {

        template<
            grb::Descriptor descr,
            typename OutputType, typename D,
            typename Enabled = void
        >
        class ValueOrIndex;

        /* Version where use_index is allowed. */
        template< grb::Descriptor descr, typename OutputType, typename D >
        class ValueOrIndex<
            descr,
            OutputType, D,
            typename std::enable_if<
                std::is_arithmetic< OutputType >::value &&
                !std::is_same< D, void >::value
            >::type
        > {

            private:

                static constexpr const bool use_index = descr & grb::descriptors::use_index;

                static_assert( use_index || std::is_convertible< D, OutputType >::value,
                    "Cannot convert to the requested output type" );


            public:

                static OutputType getFromArray(
                    const D * __restrict__ const x,
                    const std::function< size_t( size_t ) > &src_local_to_global,
                    const size_t index
                ) noexcept {
                    if( use_index ) {
                        return static_cast< OutputType >( src_local_to_global( index ) );
                    } else {
                        return static_cast< OutputType >( x[ index ] );
                    }
                }

                static OutputType getFromScalar( const D &x, const size_t index ) noexcept {
                    if( use_index ) {
                        return static_cast< OutputType >( index );
                    } else {
                        return static_cast< OutputType >( x );
                    }
                }

        };

        /* Version where use_index is not allowed. */
        template< grb::Descriptor descr, typename OutputType, typename D >
        class ValueOrIndex<
            descr,
            OutputType, D,
            typename std::enable_if<
                !std::is_arithmetic< OutputType >::value &&
                !std::is_same< OutputType, void >::value
            >::type
        > {

            static_assert( !(descr & descriptors::use_index),
                "use_index descriptor given while output type is not numeric" );

            static_assert( std::is_convertible< D, OutputType >::value,
                "Cannot convert input to the given output type" );

            public:

                static OutputType getFromArray(
                    const D * __restrict__ const x,
                    const std::function< size_t( size_t ) > &,
                    const size_t index
                ) noexcept {
                    return static_cast< OutputType >( x[ index ] );
                }

                static OutputType getFromScalar(
                    const D &x, const size_t
                ) noexcept {
                    return static_cast< OutputType >( x );
                }

        };

        template<
            bool identity_left,
            typename OutputType, typename InputType,
            template< typename > class Identity,
            typename Enabled = void
        >
        class CopyOrApplyWithIdentity;

        /* The cast-and-assign version */
        template<
            bool identity_left,
            typename OutputType, typename InputType,
            template< typename > class Identity
        >
        class CopyOrApplyWithIdentity<
            identity_left,
            OutputType, InputType,
            Identity,
            typename std::enable_if<
                std::is_convertible< InputType, OutputType >::value
            >::type
        > {

            public:

                template< typename Operator >
                static void set( OutputType &out, const InputType &in, const Operator & ) {
                    out = static_cast< OutputType >( in );
                }

        };

        /* The operator with identity version */
        template<
            bool identity_left,
            typename OutputType, typename InputType,
            template< typename > class Identity
        >
        class CopyOrApplyWithIdentity<
            identity_left,
            OutputType, InputType,
            Identity,
            typename std::enable_if<
                !std::is_convertible< InputType, OutputType >::value
            >::type
        > {

            public:

                template< typename Operator >
                static void set(
                    OutputType &out, const InputType &in, const Operator &op
                ) {
                    const auto identity = identity_left ?
                        Identity< typename Operator::D1 >::value() :
                        Identity< typename Operator::D2 >::value();
                    if( identity_left ) {
                        (void) grb::apply( out, identity, in, op );
                    } else {
                        (void) grb::apply( out, in, identity, op );
                    }
                }

        };

    } // namespace internal

} // namespace grb

#undef NO_CAST_ASSERT

#endif // end ``_H_GRB_BLAS0''