bsp.h

Go to the documentation of this file.

/*
 * Copyright (c) 2007-2017
 *
 * File created Albert-Jan N. Yzelman, 2007-2009.
 * 
 * This file is part of MulticoreBSP in C --
 *        a port of the original Java-based MulticoreBSP.
 *
 * MulticoreBSP for C is distributed as part of the original
 * MulticoreBSP and is free software: you can redistribute
 * it and/or modify it under the terms of the GNU Lesser 
 * General Public License as published by the Free Software 
 * Foundation, either version 3 of the License, or 
 * (at your option) any later version.
 * MulticoreBSP is distributed in the hope that it will be
 * useful, but WITHOUT ANY WARRANTY; without even the 
 * implied warranty of MERCHANTABILITY or FITNESS FOR A 
 * PARTICULAR PURPOSE. See the GNU Lesser General Public 
 * License for more details.
 *
 * You should have received a copy of the GNU Lesser General 
 * Public License along with MulticoreBSP. If not, see
 * <http://www.gnu.org/licenses/>.
 */

#ifndef _H_MCBSP
#define _H_MCBSP

#include <stdarg.h>
#include <stddef.h>
#include <stdint.h>

//macros that control the interface follow first:

#ifdef MCBSP_ENABLE_HP_DIRECTIVES
 #ifdef MCBSP_ENABLE_FAKE_HP_DIRECTIVES
  #pragma message "Warning: MCBSP_ENABLE_HP_DIRECTIVES takes precedence over MCBSP_ENABLE_FAKE_HP_DIRECTIVES"
  #undef MCBSP_ENABLE_FAKE_HP_DIRECTIVES
 #endif
#else
 #ifndef MCBSP_ENABLE_FAKE_HP_DIRECTIVES
  #define MCBSP_ENABLE_HP_DIRECTIVES
 #endif
#endif

typedef unsigned int bsp_pid_t;
typedef unsigned int bsp_nprocs_t;
typedef size_t bsp_size_t;

//The public API is actually overriden by the use of macros in the below.
//This allows for per-unit mode switching, between, for instance,
//performance, debug, or profiling mode.
//Special modes are defined using the macro MCBSP_MODE, whose value
//contains the prefix to be used. For example:
//#define MCBSP_MODE bsp_profile
//will transform all BSP calls to bsp_begin to bsp_profile_begin, and
//similarly for all other BSP primitives. A special case is given by the
//MCBSP_COMPATIBILITY_MODE, which uses ANSI C99 style inlining in
//combination with macro-based aliases.
//A list of currently supported values for MCBSP_MODE follows:
//   -1: the default performance mode.
//   -2: a debugging mode that performs more sanity checks and
//       is friendly for use with debuggers such as gdb and
//       valgrind.
//   -3: a profile mode that collects statistics during the
//       SPMD run and report them after SPMD exit. 

#ifndef MCBSP_MODE

 #define MCBSP_MODE 1
#endif

#if MCBSP_MODE == 3
 #ifndef MCBSP_DISABLE_COMPILATION_MODE_WARNING
  #pragma message "Warning: compiling in profile mode"
 #endif
 #define MCBSP_FUNCTION_PREFIX(n) mcbsp_profile_##n
#elif MCBSP_MODE == 2
 #ifndef MCBSP_DISABLE_COMPILATION_MODE_WARNING
  #pragma message "Warning: compiling in debug mode"
 #endif
 #define MCBSP_FUNCTION_PREFIX(n) mcbsp_debug_##n
#else
 #if MCBSP_MODE != 1
  #pragma message "Warning: unknown MCBSP_MODE `" #MCBSP_MODE "'; defaulting to perf mode..."
 #endif
 #define MCBSP_FUNCTION_PREFIX(n) mcbsp_perf_##n
#endif

//the real library functions are prototyped here,
//and depend on which mode we are compiling for:
void MCBSP_FUNCTION_PREFIX(begin)( const bsp_pid_t P );
void MCBSP_FUNCTION_PREFIX(end)( void );
void MCBSP_FUNCTION_PREFIX(init)( void (*spmd)(void), int argc, char **argv );
void MCBSP_FUNCTION_PREFIX(abort)( const char * const error_message, ... );
void MCBSP_FUNCTION_PREFIX(vabort)( const char * const error_message, va_list args );
bsp_pid_t MCBSP_FUNCTION_PREFIX(nprocs)( void );
bsp_pid_t MCBSP_FUNCTION_PREFIX(pid)( void );
double MCBSP_FUNCTION_PREFIX(time)( void );
void MCBSP_FUNCTION_PREFIX(sync)( void );
void MCBSP_FUNCTION_PREFIX(push_reg)( void * const address, const bsp_size_t size );
void MCBSP_FUNCTION_PREFIX(pop_reg)( void * const address );
void MCBSP_FUNCTION_PREFIX(put)(
        const bsp_pid_t pid,
        const void * const source,
        const void * const destination,
        const bsp_size_t offset,
        const bsp_size_t size
);
void MCBSP_FUNCTION_PREFIX(get)(
        const bsp_pid_t pid,
        const void * const source,
        const bsp_size_t offset,
        void * const destination,
        const bsp_size_t size
);
void MCBSP_FUNCTION_PREFIX(direct_get)(
        const bsp_pid_t pid,
        const void * const source,
        const bsp_size_t offset,
        void * const destination,
        const bsp_size_t size
);
void MCBSP_FUNCTION_PREFIX(set_tagsize)( bsp_size_t * const size );
void MCBSP_FUNCTION_PREFIX(send)(
        const bsp_pid_t pid,
        const void * const tag,
        const void * const payload,
        const bsp_size_t size
);
void MCBSP_FUNCTION_PREFIX(qsize)(
        bsp_nprocs_t * const packets,
        bsp_size_t * const accumulated_size
);
void MCBSP_FUNCTION_PREFIX(get_tag)(
        bsp_size_t * const status,
        void * const tag
);
void MCBSP_FUNCTION_PREFIX(move)(
        void * const payload,
        const bsp_size_t max_copy_size
);
bsp_size_t MCBSP_FUNCTION_PREFIX(hpmove)(
        void* * const p_tag,
        void* * const p_payload
);
void MCBSP_FUNCTION_PREFIX(hpput)(
        const bsp_pid_t pid,
        const void * const source,
        const void * const destination,
        const bsp_size_t offset,
        const bsp_size_t size
);
void MCBSP_FUNCTION_PREFIX(hpget)(
        const bsp_pid_t pid,
        const void * const source,
        const bsp_size_t offset,
        void * const destination,
        const bsp_size_t size
);
#ifdef MCBSP_ENABLE_HP_DIRECTIVES
void MCBSP_FUNCTION_PREFIX(hpsend)(
        const bsp_pid_t pid,
        const void * const tag,
        const void * const payload,
        const bsp_size_t size
);
#endif

#if MCBSP_MODE == 2
 #define mcbsp_begin       mcbsp_debug_begin
 #define mcbsp_end         mcbsp_debug_end
 #define mcbsp_init        mcbsp_debug_init
 #define mcbsp_abort       mcbsp_debug_abort
 #define mcbsp_vabort      mcbsp_debug_vabort
 #define mcbsp_nprocs      mcbsp_debug_nprocs
 #define mcbsp_pid         mcbsp_debug_pid
 #define mcbsp_time        mcbsp_debug_time
 #define mcbsp_sync        mcbsp_debug_sync
 #define mcbsp_push_reg    mcbsp_debug_push_reg
 #define mcbsp_pop_reg     mcbsp_debug_pop_reg
 #define mcbsp_put         mcbsp_debug_put
 #define mcbsp_get         mcbsp_debug_get
 #define mcbsp_send        mcbsp_debug_send
 #define mcbsp_qsize       mcbsp_debug_qsize
 #define mcbsp_get_tag     mcbsp_debug_get_tag
 #define mcbsp_move        mcbsp_debug_move
 #define mcbsp_hpmove      mcbsp_debug_hpmove
 #define mcbsp_hpput       mcbsp_debug_hpput
 #define mcbsp_hpget       mcbsp_debug_hpget
 #define mcbsp_set_tagsize mcbsp_debug_set_tagsize

 #define mcbsp_hpsend      mcbsp_debug_hpsend
 #define mcbsp_direct_get  mcbsp_debug_direct_get
#elif MCBSP_MODE == 3
 #define mcbsp_begin       mcbsp_profile_begin
 #define mcbsp_end         mcbsp_profile_end
 #define mcbsp_init        mcbsp_profile_init
 #define mcbsp_abort       mcbsp_profile_abort
 #define mcbsp_vabort      mcbsp_profile_vabort
 #define mcbsp_nprocs      mcbsp_profile_nprocs
 #define mcbsp_pid         mcbsp_profile_pid
 #define mcbsp_time        mcbsp_profile_time
 #define mcbsp_sync        mcbsp_profile_sync
 #define mcbsp_push_reg    mcbsp_profile_push_reg
 #define mcbsp_pop_reg     mcbsp_profile_pop_reg
 #define mcbsp_put         mcbsp_profile_put
 #define mcbsp_get         mcbsp_profile_get
 #define mcbsp_send        mcbsp_profile_send
 #define mcbsp_qsize       mcbsp_profile_qsize
 #define mcbsp_get_tag     mcbsp_profile_get_tag
 #define mcbsp_move        mcbsp_profile_move
 #define mcbsp_hpmove      mcbsp_profile_hpmove
 #define mcbsp_hpput       mcbsp_profile_hpput
 #define mcbsp_hpget       mcbsp_profile_hpget
 #define mcbsp_set_tagsize mcbsp_profile_set_tagsize

 #define mcbsp_hpsend      mcbsp_profile_hpsend
 #define mcbsp_direct_get  mcbsp_profile_direct_get
#else
 #define mcbsp_begin       mcbsp_perf_begin
 #define mcbsp_end         mcbsp_perf_end
 #define mcbsp_init        mcbsp_perf_init
 #define mcbsp_abort       mcbsp_perf_abort
 #define mcbsp_vabort      mcbsp_perf_vabort
 #define mcbsp_nprocs      mcbsp_perf_nprocs
 #define mcbsp_pid         mcbsp_perf_pid
 #define mcbsp_time        mcbsp_perf_time
 #define mcbsp_sync        mcbsp_perf_sync
 #define mcbsp_push_reg    mcbsp_perf_push_reg
 #define mcbsp_pop_reg     mcbsp_perf_pop_reg
 #define mcbsp_put         mcbsp_perf_put
 #define mcbsp_get         mcbsp_perf_get
 #define mcbsp_send        mcbsp_perf_send
 #define mcbsp_qsize       mcbsp_perf_qsize
 #define mcbsp_get_tag     mcbsp_perf_get_tag
 #define mcbsp_move        mcbsp_perf_move
 #define mcbsp_hpmove      mcbsp_perf_hpmove
 #define mcbsp_hpput       mcbsp_perf_hpput
 #define mcbsp_hpget       mcbsp_perf_hpget
 #define mcbsp_set_tagsize mcbsp_perf_set_tagsize

 #define mcbsp_hpsend      mcbsp_perf_hpsend
 #define mcbsp_direct_get  mcbsp_perf_direct_get
#endif

//now account for possible compatibility mode translations
#ifdef MCBSP_COMPATIBILITY_MODE 
static inline void bsp_begin( const int P ) {
        mcbsp_begin( (bsp_nprocs_t)P );
}

static inline void bsp_end( void ) {
        mcbsp_end();
}

static inline void bsp_init( void (*spmd)(void), int argc, char **argv ) {
        mcbsp_init( spmd, argc, argv );
}

static inline void bsp_abort( const char * const error_message, ... ) {
        va_list args;
        va_start( args, error_message );
        mcbsp_vabort( error_message, args );
        va_end( args );
}

static inline void bsp_vabort( const char * const error_message, va_list args ) {
        mcbsp_vabort( error_message, args );
}

static inline int bsp_nprocs( void ) {
        return (int)mcbsp_nprocs();
}

static inline int bsp_pid( void ) {
        return (int)mcbsp_pid();
}

static inline double bsp_time( void ) {
        return mcbsp_time();
}

static inline void bsp_sync( void ) {
        mcbsp_sync();
}

static inline void bsp_push_reg( void * const address, const int size ) {
        mcbsp_push_reg( address, (bsp_size_t)size );
}

static inline void bsp_pop_reg( void * const address ) {
        mcbsp_pop_reg( address );
}

static inline void bsp_put(
        const int pid,
        const void * const source,
        const void * const destination,
        const int offset,
        const int size
) {
        mcbsp_put( (bsp_pid_t)pid, source, destination, (bsp_size_t)offset, (bsp_size_t)size );
}

static inline void bsp_get(
        const int pid,
        const void * const source,
        const int offset,
        void * const destination,
        const int size
) {
        mcbsp_get( (bsp_pid_t)pid, source, (bsp_size_t)offset, destination, (bsp_size_t)size );
}

static inline void bsp_set_tagsize( int * const size ) {
        size_t convert = (size_t) *size;
        mcbsp_set_tagsize( &convert );
        *size = (int)convert;
}

static inline void bsp_send(
        const int pid,
        const void * const tag,
        const void * const payload,
        const int size
) {
        mcbsp_send( (bsp_pid_t)pid, tag, payload, (bsp_size_t)size );
}

#ifdef MCBSP_ENABLE_HP_DIRECTIVES
static inline void bsp_hpsend(
        const int pid,
        const void * const tag,
        const void * const payload,
        const int size
) {
        mcbsp_hpsend( (bsp_pid_t)pid, tag, payload, (bsp_size_t)size );
}
#endif

static inline void bsp_qsize(
        int * const packets,
        int * const accumulated_size
) {
        bsp_nprocs_t conv_packets;
        if( accumulated_size == NULL ) {
                mcbsp_qsize( &conv_packets, NULL );
        } else {
                bsp_size_t conv_size;
                mcbsp_qsize( &conv_packets, &conv_size );
                *accumulated_size = (int)conv_size;
        }
        *packets = (int)conv_packets;
}

static inline void bsp_get_tag(
        int * const status,
        void * const tag
) {
        bsp_size_t converted;
        mcbsp_get_tag( &converted, tag );
        if( converted != SIZE_MAX ) {
                *status = (int)converted;
        } else {
                *status = -1;
        }
}

static inline void bsp_move( void * const payload, const int max_copy_size ) {
        mcbsp_move( payload, (const bsp_size_t)max_copy_size );
}

static inline int bsp_hpmove( void* * const p_tag, void* * const p_payload ) {
        return (int)mcbsp_hpmove( p_tag, p_payload );
}

static inline void bsp_hpput(
        const int pid,
        const void * const source,
        const void * const destination,
        const int offset,
        const int size
) {
        mcbsp_hpput( (const bsp_pid_t)pid, source, destination, (const bsp_size_t)offset, (const bsp_size_t)size );
}

static inline void bsp_hpget(
        const int pid,
        const void * const source,
        const int offset,
        void * const destination,
        const int size
) {
        mcbsp_hpget( (const bsp_pid_t)pid, source, (const bsp_size_t)offset, destination, (const bsp_size_t)size );
}
#else

static inline void bsp_begin( const bsp_pid_t P ) {
        mcbsp_begin( P );
}

static inline void bsp_end( void ) {
        mcbsp_end();
}

static inline void bsp_init( void (*spmd)(void), int argc, char **argv ) {
        mcbsp_init( spmd, argc, argv );
}

static inline void bsp_abort( const char * const error_message, ... ) {
        va_list args;
        va_start( args, error_message );
        mcbsp_vabort( error_message, args );
        va_end( args );
}

static inline void bsp_vabort( const char * const error_message, va_list args ) {
        mcbsp_vabort( error_message, args );
}

static inline bsp_pid_t bsp_nprocs( void ) {
        return mcbsp_nprocs();
}

static inline bsp_pid_t bsp_pid( void ) {
        return mcbsp_pid();
}

static inline double bsp_time( void ) {
        return mcbsp_time();
}

static inline void bsp_sync( void ) {
        mcbsp_sync();
}

static inline void bsp_push_reg( void * const address, const bsp_size_t size ) {
        mcbsp_push_reg( address, size );
}

static inline void bsp_pop_reg( void * const address ) {
        mcbsp_pop_reg( address );
}

static inline void bsp_put(
        const bsp_pid_t pid,
        const void * const source,
        const void * const destination,
        const bsp_size_t offset,
        const bsp_size_t size
) {
        mcbsp_put( pid, source, destination, offset, size );
}

static inline void bsp_get(
        const bsp_pid_t pid,
        const void * const source,
        const bsp_size_t offset,
        void * const destination,
        const bsp_size_t size
) {
        mcbsp_get( pid, source, offset, destination, size );
}

static inline void bsp_direct_get(
        const bsp_pid_t pid,
        const void * const source,
        const bsp_size_t offset,
        void * const destination,
        const bsp_size_t size
) {
        mcbsp_direct_get( pid, source, offset, destination, size );
}

static inline void bsp_set_tagsize( bsp_size_t * const size ) {
        mcbsp_set_tagsize( size );
}

static inline void bsp_send(
        const bsp_pid_t pid,
        const void * const tag,
        const void * const payload,
        const bsp_size_t size
) {
        mcbsp_send( pid, tag, payload, size );
}

#ifdef MCBSP_ENABLE_HP_DIRECTIVES

static inline void bsp_hpsend(
        const bsp_pid_t pid,
        const void * const tag,
        const void * const payload,
        const bsp_size_t size
) {
        mcbsp_hpsend( pid, tag, payload, size );
}
#endif

static inline void bsp_qsize(
        bsp_nprocs_t * const packets,
        bsp_size_t * const accumulated_size
) {
        mcbsp_qsize( packets, accumulated_size );
}

static inline void bsp_get_tag(
        bsp_size_t * const status,
        void * const tag
) {
        mcbsp_get_tag( status, tag );
}

static inline void bsp_move( void * const payload, const bsp_size_t max_copy_size ) {
        mcbsp_move( payload, max_copy_size );
}

static inline bsp_size_t bsp_hpmove( void* * const p_tag, void* * const p_payload ) {
        return mcbsp_hpmove( p_tag, p_payload );
}

static inline void bsp_hpput(
        const bsp_pid_t pid,
        const void * const source,
        const void * const destination,
        const bsp_size_t offset,
        const bsp_size_t size
) {
        mcbsp_hpput( pid, source, destination, offset, size );
}

static inline void bsp_hpget(
        const bsp_pid_t pid,
        const void * const source,
        const bsp_size_t offset,
        void * const destination,
        const bsp_size_t size
) {
        mcbsp_hpget( pid, source, offset, destination, size );
}
#endif

#endif