io.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.
 */

#include <type_traits>
#include <typeinfo>

#ifndef _H_GRB_IO_BASE
#define _H_GRB_IO_BASE

#include <graphblas/rc.hpp>
#include <graphblas/phase.hpp>
#include <graphblas/iomode.hpp>
#include <graphblas/synchronizedNonzeroIterator.hpp>
#include <graphblas/utils/iterators/type_traits.hpp>

#include "matrix.hpp"
#include "vector.hpp"

#include <assert.h>


namespace grb {

    template<
        typename ElementType, typename Coords,
        Backend implementation = config::default_backend
    >
    uintptr_t getID(
        const Vector< ElementType, implementation, Coords > &x
    ) {
        (void) x;
#ifndef NDEBUG
        const bool this_is_an_invalid_default_implementation = false;
#endif
        assert( this_is_an_invalid_default_implementation );
        return static_cast< uintptr_t >(-1);
    }

    template<
        typename ElementType, typename RIT, typename CIT, typename NIT,
        Backend implementation = config::default_backend
    >
    uintptr_t getID(
        const Matrix< ElementType, implementation, RIT, CIT, NIT > &x
    ) {
        (void) x;
#ifndef NDEBUG
        const bool this_is_an_invalid_default_implementation = false;
#endif
        assert( this_is_an_invalid_default_implementation );
        return static_cast< uintptr_t >(-1);
    }

    template<
        typename DataType,
        Backend backend, typename Coords
    >
    size_t size( const Vector< DataType, backend, Coords > &x ) noexcept {
#ifndef NDEBUG
        const bool may_not_call_base_size = false;
#endif
        (void) x;
        assert( may_not_call_base_size );
        return SIZE_MAX;
    }

    template<
        typename InputType, Backend backend,
        typename RIT, typename CIT, typename NIT
    >
    size_t nrows(
        const Matrix< InputType, backend, RIT, CIT, NIT > &A
    ) noexcept {
#ifndef NDEBUG
        const bool may_not_call_base_nrows = false;
#endif
        (void) A;
        assert( may_not_call_base_nrows );
        return SIZE_MAX;
    }

    template<
        typename InputType, Backend backend,
        typename RIT, typename CIT, typename NIT
    >
    size_t ncols(
        const Matrix< InputType, backend, RIT, CIT, NIT > &A
    ) noexcept {
#ifndef NDEBUG
        const bool may_not_call_base_ncols = false;
#endif
        (void) A;
        assert( may_not_call_base_ncols );
        return SIZE_MAX;
    }

    template<
        typename InputType, Backend backend, typename Coords
    >
    size_t capacity( const Vector< InputType, backend, Coords > &x ) noexcept {
#ifndef NDEBUG
        const bool should_not_call_base_vector_capacity = false;
#endif
        assert( should_not_call_base_vector_capacity );
        (void) x;
        return SIZE_MAX;
    }

    template<
        typename InputType, Backend backend,
        typename RIT, typename CIT, typename NIT
    >
    size_t capacity(
        const Matrix< InputType, backend, RIT, CIT, NIT > &A
    ) noexcept {
#ifndef NDEBUG
        const bool should_not_call_base_matrix_capacity = false;
#endif
        assert( should_not_call_base_matrix_capacity );
        (void) A;
        return SIZE_MAX;
    }

    template< typename DataType, Backend backend, typename Coords >
    size_t nnz( const Vector< DataType, backend, Coords > &x ) noexcept {
#ifndef NDEBUG
        const bool should_not_call_base_vector_nnz = false;
#endif
        (void) x;
        assert( should_not_call_base_vector_nnz );
        return SIZE_MAX;
    }

    template<
        typename InputType, Backend backend,
        typename RIT, typename CIT, typename NIT
    >
    size_t nnz(
        const Matrix< InputType, backend, RIT, CIT, NIT > &A
    ) noexcept {
#ifndef NDEBUG
        const bool should_not_call_base_matrix_nnz = false;
#endif
        (void) A;
        assert( should_not_call_base_matrix_nnz );
        return SIZE_MAX;
    }

    template< typename DataType, Backend backend, typename Coords >
    RC clear( Vector< DataType, backend, Coords > &x ) noexcept {
#ifndef NDEBUG
        const bool should_not_call_base_vector_clear = false;
#endif
        (void) x;
        assert( should_not_call_base_vector_clear );
        return UNSUPPORTED;
    }

    template<
        typename InputType, Backend backend,
        typename RIT, typename CIT, typename NIT
    >
    RC clear(
        Matrix< InputType, backend, RIT, CIT, NIT > &A
    ) noexcept {
#ifndef NDEBUG
        const bool should_not_call_base_matrix_clear = false;
#endif
        (void) A;
        assert( should_not_call_base_matrix_clear );
        return UNSUPPORTED;
    }

    template<
        typename InputType,
        Backend backend, typename Coords
    >
    RC resize(
        Vector< InputType, backend, Coords > &x,
        const size_t new_nz
    ) noexcept {
#ifndef NDEBUG
        const bool should_not_call_base_vector_resize = false;
#endif
        (void) x;
        (void) new_nz;
        assert( should_not_call_base_vector_resize );
        return UNSUPPORTED;
    }

    template<
        typename InputType, Backend backend,
        typename RIT, typename CIT, typename NIT
    >
    RC resize(
        Matrix< InputType, backend, RIT, CIT, NIT > &A,
        const size_t new_nz
    ) noexcept {
#ifndef NDEBUG
        const bool should_not_call_base_matrix_resize = false;
#endif
        (void) A;
        (void) new_nz;
        assert( should_not_call_base_matrix_resize );
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        typename DataType, typename T,
        typename Coords, Backend backend
    >
    RC set(
        Vector< DataType, backend, Coords > &x, const T val,
        const Phase &phase = EXECUTE,
        const typename std::enable_if<
            !grb::is_object< DataType >::value &&
            !grb::is_object< T >::value,
        void >::type * const = nullptr
    ) noexcept {
#ifndef NDEBUG
        const bool should_not_call_base_vector_set = false;
        assert( should_not_call_base_vector_set );
#endif
        (void) x;
        (void) val;
        (void) phase;
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        typename DataType, typename MaskType, typename T,
        Backend backend, typename Coords
    >
    RC set(
        Vector< DataType, reference, Coords > &x,
        const Vector< MaskType, backend, Coords > &mask,
        const T val,
        const Phase &phase = EXECUTE,
        const typename std::enable_if<
            !grb::is_object< DataType >::value && !grb::is_object< T >::value,
        void >::type * const = nullptr
    ) {
#ifndef NDEBUG
        const bool should_not_call_base_masked_vector_set = false;
        assert( should_not_call_base_masked_vector_set );
#endif
        (void) x;
        (void) mask;
        (void) val;
        (void) phase;
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        typename OutputType, typename InputType,
        Backend backend, typename Coords
    >
    RC set(
        Vector< OutputType, backend, Coords > &x,
        const Vector< InputType, backend, Coords > &y,
        const Phase &phase = EXECUTE
    ) {
#ifndef NDEBUG
        const bool should_not_call_base_vector_set_copy = false;
        assert( should_not_call_base_vector_set_copy );
#endif
        (void) x;
        (void) y;
        (void) phase;
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        typename OutputType, typename MaskType, typename InputType,
        Backend backend, typename Coords
    >
    RC set(
        Vector< OutputType, backend, Coords > &x,
        const Vector< MaskType, backend, Coords > &mask,
        const Vector< InputType, backend, Coords > &y,
        const Phase &phase = EXECUTE,
        const typename std::enable_if< !grb::is_object< OutputType >::value &&
            !grb::is_object< MaskType >::value &&
            !grb::is_object< InputType >::value,
        void >::type * const = nullptr
    ) {
#ifndef NDEBUG
        const bool should_not_call_base_vector_set_copy_masked = false;
        assert( should_not_call_base_vector_set_copy_masked );
#endif
        (void) x;
        (void) mask;
        (void) y;
        (void) phase;
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        typename DataType, typename T,
        Backend backend, typename Coords
    >
    RC setElement(
        Vector< DataType, backend, Coords > &x,
        const T val,
        const size_t i,
        const Phase &phase = EXECUTE,
        const typename std::enable_if< !grb::is_object< DataType >::value &&
            !grb::is_object< T >::value, void >::type * const = nullptr
    ) {
#ifndef NDEBUG
        const bool should_not_call_base_setElement = false;
        assert( should_not_call_base_setElement );
#endif
        (void) x;
        (void) val;
        (void) i;
        (void) phase;
        return UNSUPPORTED;
    }

    template<
        Descriptor descr = descriptors::no_operation,
        typename InputType, typename fwd_iterator,
        Backend backend, typename Coords
    >
    RC buildVector(
        Vector< InputType, backend, Coords > &x,
        fwd_iterator start, const fwd_iterator end,
        const IOMode mode
    ) {
        operators::right_assign< InputType > accum;
        return buildVector< descr >( x, accum, start, end, mode );
    }

    template< Descriptor descr = descriptors::no_operation,
        typename InputType,
        class Merger = operators::right_assign< InputType >,
        typename fwd_iterator1, typename fwd_iterator2,
        Backend backend, typename Coords
    >
    RC buildVector( Vector< InputType, backend, Coords > &x,
        fwd_iterator1 ind_start, const fwd_iterator1 ind_end,
        fwd_iterator2 val_start, const fwd_iterator2 val_end,
        const IOMode mode, const Merger & merger = Merger()
    ) {
        operators::right_assign< InputType > accum;
        return buildVector< descr >( x, accum, ind_start, ind_end, val_start, val_end,
            mode, merger );
    }

    template<
        Descriptor descr = descriptors::no_operation,
        typename InputType,
        class Merger = operators::right_assign< InputType >,
        typename fwd_iterator1, typename fwd_iterator2,
        Backend backend, typename Coords
    >
    RC buildVectorUnique(
        Vector< InputType, backend, Coords > &x,
        fwd_iterator1 ind_start, const fwd_iterator1 ind_end,
        fwd_iterator2 val_start, const fwd_iterator2 val_end,
        const IOMode mode
    ) {
        return buildVector< descr | descriptors::no_duplicates >(
            x,
            ind_start, ind_end,
            val_start, val_end,
            mode
        );
    }

    template<
        Descriptor descr = descriptors::no_operation,
        typename InputType, typename RIT, typename CIT, typename NIT,
        typename fwd_iterator1 = const RIT * __restrict__,
        typename fwd_iterator2 = const CIT * __restrict__,
        typename fwd_iterator3 = const InputType * __restrict__,
        Backend implementation = config::default_backend
    >
    RC buildMatrixUnique(
        Matrix< InputType, implementation, RIT, CIT, NIT > &A,
        fwd_iterator1 I, const fwd_iterator1 I_end,
        fwd_iterator2 J, const fwd_iterator2 J_end,
        fwd_iterator3 V, const fwd_iterator3 V_end,
        const IOMode mode
    ) {
        // derive synchronized iterator
        auto start = internal::makeSynchronized(
            I, J, V,
            I_end, J_end, V_end
        );
        const auto end = internal::makeSynchronized(
            I_end, J_end, V_end,
            I_end, J_end, V_end
        );
        // defer to other signature
        return buildMatrixUnique< descr >( A, start, end, mode );
    }

    template<
        Descriptor descr = descriptors::no_operation,
        typename InputType, typename RIT, typename CIT, typename NIT,
        typename fwd_iterator1 = const RIT * __restrict__,
        typename fwd_iterator2 = const CIT * __restrict__,
        typename fwd_iterator3 = const InputType * __restrict__,
        Backend implementation = config::default_backend
    >
    RC buildMatrixUnique(
        Matrix< InputType, implementation, RIT, CIT, NIT > &A,
        fwd_iterator1 I, fwd_iterator2 J, fwd_iterator3 V,
        const size_t nz, const IOMode mode
    ) {
        return buildMatrixUnique< descr >(
            A,
            I, I + nz,
            J, J + nz,
            V, V + nz,
            mode
        );
    }

    template<
        Descriptor descr = descriptors::no_operation,
        typename InputType, typename RIT, typename CIT, typename NIT,
        typename fwd_iterator1 = const RIT * __restrict__,
        typename fwd_iterator2 = const CIT * __restrict__,
        typename length_type = size_t,
        Backend implementation = config::default_backend
    >
    RC buildMatrixUnique(
        Matrix< InputType, implementation, RIT, CIT, NIT > &A,
        fwd_iterator1 I, fwd_iterator2 J,
        const length_type nz, const IOMode mode
    ) {
        // derive synchronized iterator
        auto start = internal::makeSynchronized( I, J, I + nz, J + nz );
        const auto end = internal::makeSynchronized( I + nz, J + nz, I + nz, J + nz );
        // defer to other signature
        return buildMatrixUnique< descr >( A, start, end, mode );
    }

    template<
        Descriptor descr = descriptors::no_operation,
        typename InputType, typename RIT, typename CIT, typename NIT,
        typename fwd_iterator1 = const RIT * __restrict__,
        typename fwd_iterator2 = const CIT * __restrict__,
        Backend implementation = config::default_backend
    >
    RC buildMatrixUnique(
        Matrix< InputType, implementation, RIT, CIT, NIT > &A,
        fwd_iterator1 I, const fwd_iterator1 I_end,
        fwd_iterator2 J, const fwd_iterator2 J_end,
        const IOMode mode
    ) {
        // derive synchronized iterator
        auto start = internal::makeSynchronized( I, J, I_end, J_end );
        const auto end = internal::makeSynchronized( I_end, J_end, I_end, J_end );
        // defer to other signature
        return buildMatrixUnique< descr >( A, start, end, mode );
    }

    template<
        Descriptor descr = descriptors::no_operation,
        typename InputType, typename RIT, typename CIT, typename NIT,
        typename fwd_iterator,
        Backend implementation = config::default_backend
    >
    RC buildMatrixUnique(
        Matrix< InputType, implementation, RIT, CIT, NIT > &A,
        fwd_iterator start, const fwd_iterator end,
        const IOMode mode
    ) {
        (void) A;
        (void) start;
        (void) end;
        (void) mode;
#ifndef NDEBUG
        std::cerr << "Should not call base grb::buildMatrixUnique" << std::endl;
        const bool should_not_call_base_buildMatrixUnique = false;
        assert( should_not_call_base_buildMatrixUnique );
#endif
        return PANIC;
    }

    template< Backend backend = config::default_backend >
    RC wait() {
#ifndef NDEBUG
        const bool should_not_call_base_wait = false;
        assert( should_not_call_base_wait );
#endif
        return UNSUPPORTED;
    }

    template<
        Backend backend, typename InputType, typename Coords,
        typename... Args
    >
    RC wait(
        const Vector< InputType, backend, Coords > &x,
        const Args &... args
    ) {
#ifndef NDEBUG
        const bool should_not_call_base_vector_wait = false;
        assert( should_not_call_base_vector_wait );
#endif
        (void) x;
        return wait( args... );
    }

    template<
        Backend backend,
        typename InputType, typename RIT, typename CIT, typename NIT,
        typename... Args
    >
    RC wait(
        const Matrix< InputType, backend, RIT, CIT, NIT > &A,
        const Args &... args
    ) {
#ifndef NDEBUG
        const bool should_not_call_base_matrix_wait = false;
        assert( should_not_call_base_matrix_wait );
#endif
        (void) A;
        return wait( args... );
    }

} // namespace grb

#endif // end _H_GRB_IO_BASE