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 {
 
    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(
                void ( *alp_program )( const T &, U & ),
                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(
                void ( *alp_program )( const void *, const size_t, U & ),
                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