exec.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_EXEC_BASE
#define _H_GRB_EXEC_BASE

#include <stdexcept>
#include <string>

#include <graphblas/backends.hpp>
#include <graphblas/rc.hpp>

#ifndef _GRB_NO_STDIO
 #include <iostream>
#endif


namespace grb {

    template< typename InputType, typename OutputType >
    using AlpTypedFunc = void ( * )( const InputType &, OutputType & );

    template< typename OutputType >
    using AlpUntypedFunc = void ( * )( const void *, size_t, OutputType & );

    enum EXEC_MODE {

        AUTOMATIC = 0,

        MANUAL,

        FROM_MPI

    };

    template< enum EXEC_MODE mode, enum Backend backend >
    class Launcher {

        public :

            Launcher(
                const size_t process_id = 0,
                const size_t nprocs = 1,
                const std::string hostname = "localhost",
                const std::string port = "0"
            ) {
                // spec does not specify any constrants on hostname and port
                // so accept (and ignore) anything
                (void) hostname;
                (void) port;

#ifndef _GRB_NO_EXCEPTIONS
                // sanity checks on process_id and nprocs
                if( nprocs == 0 ) {
                    throw std::invalid_argument( "Total number of user processes must be "
                        "strictly larger than zero." );
                }
                if( process_id >= nprocs ) {
                    throw std::invalid_argument( "Process ID must be strictly smaller than "
                        "total number of user processes." );
                }
#endif
            }

            template< typename T, typename U >
            RC exec(
                AlpTypedFunc< T, U > alp_program,
                const T &data_in,
                U &data_out,
                const bool broadcast = false
            ) const {
                (void) alp_program;
                (void) data_in;
                (void) data_out;
                (void) broadcast;
                // stub implementation, should be overridden by specialised backend,
                // so return error code
                return PANIC;
            }

            template< typename U >
            RC exec(
                AlpUntypedFunc< U > alp_program,
                const void * data_in,
                const size_t in_size,
                U &data_out,
                const bool broadcast = false
            ) const {
                (void) alp_program;
                (void) data_in;
                (void) in_size;
                (void) data_out;
                (void) broadcast;
                return PANIC;
            }

            static RC finalize() {
                return PANIC;
            }

    }; // end class `Launcher'

} // end namespace ``grb''

#endif // end _H_GRB_EXEC_BASE