mcbsp.h

Go to the documentation of this file.

/*
 * Copyright (c) 2012
 *
 * File created 2012 by A. N. Yzelman by refactoring a much
 * older header file (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_MCINTERNAL
#define _H_MCINTERNAL

//this include has to come first,
//as it defines compilation modes
#include "mcbsp-internal-macros.h"

//public MulticoreBSP includes:
#include "bsp.h"
#include "mcbsp-affinity.h"
#include "mcbsp-profiling.h"
#include "mcbsp-resiliency.h"

//hidden includes (from library user's perspective):

//cross-platform includes:
#ifdef __MACH__
 #include <mach/mach.h>
 #include <mach/clock.h>
 #include <mach/mach_error.h>
 #include <mach/thread_policy.h>
#endif

#ifdef _WIN32
 #include <windows.h>
#endif

#ifdef MCBSP_WITH_DMTCP
 #include <dmtcp.h>
#endif

//common includes:
#include <time.h>
#include <stdio.h>
#include <errno.h>
#include <sched.h>
#include <stdlib.h>
#include <unistd.h>
#include <assert.h>
#include <signal.h>
#include <pthread.h>
#include <stdbool.h>

#include "mcutil.h"

#define MCBSP_SUPERSTEP_STATS_NAME_MAX 255


extern int main( int argc, char **argv );

struct mcbsp_superstep_stats {

        char name[ MCBSP_SUPERSTEP_STATS_NAME_MAX ];

        size_t put;

        size_t get;

        size_t hpput;

        size_t hpget;

        size_t send;

        size_t hpsend;

        size_t direct_get;

        size_t move;

        size_t hpmove;

        size_t bookkeeping;

        size_t non_communicating;

        size_t bytes_buffered;

        size_t direct_get_bytes;

        size_t bytes_sent;

        size_t bytes_received;

        size_t metabytes_sent;

        size_t metabytes_received;

        double buffering;

        double computation;

        double communication;

};

struct mcbsp_init_data {

        size_t P;

        size_t sync_entry_counter;

        size_t sync_exit_counter;

        size_t tagSize;

        size_t top_pid;

        size_t cp_f;

        size_t safe_cp_f;

        size_t skipped_checkpoints;

        size_t current_superstep;

        pthread_t *threads;

        struct mcbsp_thread_data * * threadData;

        unsigned char * sl_condition;

        unsigned char * sl_mid_condition;

        unsigned char * sl_end_condition;

        struct mcbsp_thread_data * prev_data;

        void (*spmd)(void);

        void *bsp_program;

        char **argv;

        struct mcbsp_util_address_table global2local;

        pthread_mutex_t mutex;

        pthread_cond_t condition;

        pthread_cond_t mid_condition;

        pthread_cond_t end_condition;

        int argc;

        volatile bool abort;

        bool ended;

        bool no_cp;

        bool safe_cp;
        
};

struct mcbsp_thread_data {

        size_t bsp_id;

        size_t newTagSize;

        size_t localC;

        double superstep_start_time;
        
        struct mcbsp_init_data * init;

        struct mcbsp_util_stack * request_queues;

        struct mcbsp_util_stack * queues;

        struct mcbsp_util_stack * hpsend_queues;

        struct mcbsp_util_address_map local2global;

        struct mcbsp_util_stack hpdrma_queue;

        struct mcbsp_util_stack bsmp;

        struct mcbsp_util_stack profile;

        struct mcbsp_util_stack removedGlobals;

        struct mcbsp_util_stack localsToRemove;

        struct mcbsp_util_stack localsToPush;

        struct mcbsp_util_stack globalsToPush;

        struct mcbsp_util_machine_partition machine_partition;

        struct mcbsp_superstep_stats superstep_stats;

#ifdef __MACH__

        clock_serv_t clock;

        mach_timespec_t start;
#elif defined _WIN32

        LARGE_INTEGER start;

        LARGE_INTEGER frequency;
#else

        struct timespec start;
#endif
};

struct mcbsp_get_request {

        void * source;

        void * destination;

        size_t length;

};

struct mcbsp_message {
        
        void * destination;

        size_t length;

};

struct mcbsp_hp_request {

        const void * source;

        void * destination;

        size_t length;

        bool source_is_remote;
};

struct mcbsp_hpsend_request {

        const void * payload;

        const void * tag;

        size_t payload_size;

};

struct mcbsp_push_request {

        void * address;

        size_t size;

};

extern pthread_key_t mcbsp_internal_init_data;

extern pthread_key_t mcbsp_internal_thread_data;

extern pthread_key_t mcbsp_local_machine_info;

extern pthread_key_t mcbsp_internal_init_data;

extern bool mcbsp_internal_keys_allocated;

extern pthread_mutex_t mcbsp_internal_keys_mutex;

//include the currently active hooks for accelerator support
#include "bsp-active-hooks.h"

void bsp_init_internal( struct mcbsp_init_data * const initialisationData );

struct mcbsp_util_machine_info *mcbsp_internal_getMachineInfo( void );

void mcbsp_internal_check_keys_allocated( void );

void* mcbsp_internal_spmd( void *p );

void mcbsp_internal_check_aborted( void );

void mcbsp_internal_spinlock( struct mcbsp_init_data * const init, unsigned char * const cond, const size_t bsp_id );

void mcbsp_internal_sync( struct mcbsp_init_data * const init, pthread_cond_t *cond );

const struct mcbsp_thread_data * mcbsp_internal_const_prefunction( void );

struct mcbsp_thread_data * mcbsp_internal_prefunction( void );

struct mcbsp_thread_data * mcbsp_internal_allocate_thread_data( struct mcbsp_init_data * const init, const size_t s );

struct mcbsp_thread_data * mcbsp_internal_initialize_thread_data( struct mcbsp_thread_data * const data );

void mcbsp_internal_destroy_thread_data( struct mcbsp_thread_data * const data );

int mcbsp_internal_call_checkpoint( void );

void mcbsp_internal_update_checkpointStats( struct mcbsp_init_data * const init );

void mcbsp_internal_print_profile( const struct mcbsp_init_data * const init );

void mcbsp_internal_init_superstep_stats( struct mcbsp_superstep_stats * const stats, const size_t superstep );

double mcbsp_internal_time( struct mcbsp_thread_data * const data );

#endif