mcutil.h

Go to the documentation of this file.

/*
 * Copyright (c) 2012
 *
 * File created by A. N. Yzelman, 2007-2012.
 * 
 * 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_MCUTIL
#define _H_MCUTIL

#include "mcbsp-internal-macros.h"
#include "mcbsp-affinity.h"
#include "mcbsp-resiliency.h"

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <limits.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdint.h>
#include <stdlib.h>
#include <pthread.h>
#include <stdbool.h>

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


struct mcbsp_util_machine_partition {

        size_t start;

        size_t stride;

        size_t end;

};

struct mcbsp_util_machine_info {

        bool Tset;

        bool Aset;

        bool Cset;

        bool TpCset;

        bool TNset;

        bool Pset;

        bool Rset;

        bool UTset;

        bool CPFset;

        bool SCFset;

        size_t threads;

        enum mcbsp_affinity_mode affinity;

        size_t cores;

        size_t threads_per_core;
        
        enum mcbsp_thread_numbering thread_numbering;

        size_t *manual_affinity;

        size_t num_reserved_cores;

        size_t *reserved_cores;

        size_t unused_threads_per_core;

        size_t cp_f;

        size_t safe_cp_f;
};

struct mcbsp_util_address_map {

        size_t cap;

        size_t size;

        void * * keys;

        size_t * values;

};

struct mcbsp_util_address_table_entry {

        void * address;

        size_t size;

};

struct mcbsp_util_stack {

        size_t cap;

        size_t top;

        size_t size;

        void * array;

};

struct mcbsp_util_address_table {
        
        pthread_mutex_t mutex;

        size_t cap;

        size_t P;

#ifdef MCBSP_ALLOW_MULTIPLE_REGS
        struct mcbsp_util_stack ** table;
#else
        struct mcbsp_util_address_table_entry ** table;
#endif
};

struct mcbsp_util_pinning_info {

        size_t *pinning;

        struct mcbsp_util_stack partition;
};

extern const struct mcbsp_util_address_map MCBSP_UTIL_EMPTY_ADDRESS_MAP;

void mcbsp_util_stack_initialize( struct mcbsp_util_stack * const stack, const size_t elementSize );

void mcbsp_util_stack_grow( struct mcbsp_util_stack * const stack, const size_t target_size );

bool mcbsp_util_stack_empty( const struct mcbsp_util_stack * const stack );

void * mcbsp_util_stack_pop( struct mcbsp_util_stack * const stack );

void * mcbsp_util_stack_peek( const struct mcbsp_util_stack * const stack );

void mcbsp_util_stack_push( struct mcbsp_util_stack * const stack, const void * const item );

void mcbsp_util_stack_destroy( struct mcbsp_util_stack * const stack );

void mcbsp_util_varstack_grow( struct mcbsp_util_stack * const stack, const size_t requested_size );

void * mcbsp_util_varstack_pop( struct mcbsp_util_stack * const stack, const size_t size );

inline void * mcbsp_util_varstack_regpop( struct mcbsp_util_stack * const stack ) {
        return mcbsp_util_varstack_pop( stack, stack->size );
}

void * mcbsp_util_varstack_peek( const struct mcbsp_util_stack * const stack, const size_t size );

inline void * mcbsp_util_varstack_regpeek( const struct mcbsp_util_stack * const stack ) {
        return mcbsp_util_varstack_peek( stack, stack->size );
}

void mcbsp_util_varstack_push( struct mcbsp_util_stack * const stack, const void * const item, const size_t size );

inline void mcbsp_util_varstack_regpush( struct mcbsp_util_stack * const stack, const void * const item ) {
        mcbsp_util_varstack_push( stack, item, stack->size );
}

void mcbsp_util_address_table_initialize( struct mcbsp_util_address_table * const table, const size_t P );

void mcbsp_util_address_table_grow( struct mcbsp_util_address_table * const table, const size_t target_size );

void mcbsp_util_address_table_setsize( struct mcbsp_util_address_table * const table, const size_t target_size );

void mcbsp_util_address_table_destroy( struct mcbsp_util_address_table * const table );

void mcbsp_util_address_table_set(
        struct mcbsp_util_address_table * const table,
        const size_t key,
        const size_t version,
        void * const value,
        const size_t size
);

const struct mcbsp_util_address_table_entry * mcbsp_util_address_table_get(
        const struct mcbsp_util_address_table * const table,
        const size_t key,
        const size_t version
);

bool mcbsp_util_address_table_delete( struct mcbsp_util_address_table * const table, const size_t key, const size_t version );

void mcbsp_util_address_map_initialize( struct mcbsp_util_address_map * const address_map );

void mcbsp_util_address_map_grow( struct mcbsp_util_address_map * const address_map );

void mcbsp_util_address_map_destroy( struct mcbsp_util_address_map * const address_map );

size_t mcbsp_util_address_map_get( const struct mcbsp_util_address_map * const address_map, const void * const key );

void mcbsp_util_address_map_insert( struct mcbsp_util_address_map * const address_map, void * const key, const size_t value );

void mcbsp_util_address_map_remove( struct mcbsp_util_address_map * const address_map, void * const key );

size_t mcbsp_util_address_map_binsearch( const struct mcbsp_util_address_map * const address_map, const void * const key, size_t lo, size_t hi );

size_t mcbsp_util_detect_hardware_threads( void );

struct mcbsp_util_machine_info *mcbsp_util_createMachineInfo( void );

void mcbsp_util_destroyMachineInfo( void * machine_info );

int mcbsp_util_integer_compare( const void * a, const void * b );

size_t mcbsp_util_log2( size_t x );

size_t mcbsp_util_sort_unique_integers( size_t * const array, const size_t length, const size_t lower_bound, const size_t upper_bound );

bool mcbsp_util_contains( const size_t * const array, const size_t value, const size_t lo, const size_t hi );

struct mcbsp_util_pinning_info  mcbsp_util_pinning( const size_t P, struct mcbsp_util_machine_info * const machine, const struct mcbsp_util_machine_partition * const super_machine );

void mcbsp_util_fatal( void );

void mcbsp_util_check_machine_info( struct mcbsp_util_machine_info * const machine );

struct mcbsp_util_machine_partition mcbsp_util_derive_partition( const struct mcbsp_util_machine_info * const info );

struct mcbsp_util_stack mcbsp_util_partition( const struct mcbsp_util_machine_partition subpart, const size_t P, const enum mcbsp_affinity_mode affinity );

size_t * mcbsp_util_derive_standard_pinning( const struct mcbsp_util_machine_partition * iterator, const size_t size );

void mcbsp_util_filter_standard_pinning( const struct mcbsp_util_machine_info * const info, size_t * const array, const size_t P );

void mcbsp_util_translate_standard_pinning( const struct mcbsp_util_machine_info * const info, size_t * const array, const size_t P );

size_t mcbsp_util_array_sizet_lbound( const size_t * const array, const size_t key, size_t lo, size_t hi );

#ifdef MCBSP_CPLUSPLUS
  void mcbsp_util_memcpy( void * const __restrict__ dest, const void * const __restrict__ src, const size_t size );
#else
  void mcbsp_util_memcpy( void * const restrict dest, const void * const restrict src, const size_t size );
#endif

void * mcbsp_util_malloc( const size_t size, const char * const name );

#endif