smp.h

Go to the documentation of this file.

#include "basics.h"

#ifndef TBCI_SMP_H
#define TBCI_SMP_H

// libc5 hack 
//#define _POSIX_THREAD_PRIO_INHERIT  

// Check for _POSIX_THREADS, give up otherwise
#if defined(SMP) && defined(HAVE_PTHREADS)

//#warning SMP

#include <signal.h>
#ifndef HAVE_NO_NEW_HEADERS_BUG
# include <cstdlib>
# include <cstdarg>
#else
# include <stdlib.h>
# include <stdarg.h>
#endif
#include <sys/types.h>
//#include <unistd.h>
//#define __need_sig_atomic_t
#define __need_sigset_t  
#ifdef BUGGY_PTHREAD
# include <sigset.h>
 typedef __sigset_t sigset_t;
#endif
// We need pthread spinlocks (XOPEN2K/XPG6 stuff)
#undef _POSIX_C_SOURCE
#define _POSIX_C_SOURCE 200112L
#include <pthread.h>

#ifndef CACHELINE_SZ
# define CACHELINE_SZ 32
#endif

NAMESPACE_TBCI

#ifdef __GNUC__
# define smp_barrier() asm ("": : :"memory")
#else
// Oops! No barrier?
# define smp_barrier()  
#endif

extern pid_t main_thread_pid;
#define MAIN_PID (main_thread_pid)
extern bool bound_main;
#endif

#if defined(NEED_SMP_DECLS) || defined(SMP)
#ifdef HAVE_PTHREADS
#include <pthread.h>
#else
#error NEED pthread.h if NEED_SMP_DECLS is set
#endif

typedef void  (*thr_job_t) (struct thr_ctrl*);
typedef void* (*useful_job_t) (void*);

#define THREAD_MAX_ARGS 5
#define THREAD_MAX_RES_LN 16

struct thr_ctrl {
        /* MutEx variables for synchronization */
        pthread_mutex_t t_setup;                //< modify setup variables
        pthread_cond_t  t_setup_cond;           //< setup done cond
        thr_job_t t_job;                        //< Function pointer (0 => quit, lina_err => notready)
        unsigned long t_size;                   //< size
        unsigned long t_off;                    //< offset
        void* t_par[THREAD_MAX_ARGS];           //< Space for 8 more pointer args
        
        volatile int t_setup_done, t_done_done; //< conditions
        pthread_mutex_t t_done;                 //< modify done variables
        pthread_cond_t  t_done_cond;            //< job done cond
        long t_retval;                          //< return value
        /* Now the variables controlling the job to be done */
        /* The owner of t_setup may change the following members of this struct */
        union {
                volatile char t_res_dummy[16];  //< 16 byte space for results
                LONG_DOUBLE t_res;
                long t_res_l;
        };
        /* The owner of t_done may change the following members of this struct */
        pid_t t_pid;                            //< thread_pid
        int t_no;                               //< thread_no 
        pthread_t t_id;                         //< thread_id 
} ALIGN(64);
#endif

#if defined(SMP) && defined(HAVE_PTHREADS)

int init_threads  (const int thr = 0);
void free_threads ();
int threads_avail (const int = 0);
void disable_threads ();
void reenable_threads ();
void bind_threads (bool bind_main = false);

//
void thread_start (const int thr_no, thr_job_t job, const unsigned long sz, ...);
void thread_start_off (const int thr_no , thr_job_t job, 
                       const unsigned long offset, const unsigned long sz, ...);
void thread_wait  (const int);
void* thread_wait_useful (const int, useful_job_t = 0, void* = 0);
/* wait for a thread to finish and return the double t_res */
LONG_DOUBLE thread_wait_result (const int);

/* Helper to slice things into cache aligned tiles */
template <typename T>
static inline unsigned long slice_offset(int thr, int no_thr, unsigned long dim, T* ptr){
        if (thr == no_thr)
                return dim;
        else if (thr == 0)
                return 0;
        BCHK(thr < 0 || thr > no_thr, NumErr, Illegal thread in slice_offset, thr, 0);
        const unsigned step = dim/no_thr;
        unsigned long offs = thr*dim/no_thr + (128/sizeof(T) > step-1? step-1: 128/sizeof(T));
        unsigned long misalign = (unsigned long)(ptr+offs)%64 / sizeof(T);
        //fprintf(stderr, "Slice %i (base %p): %li(%li) (@%p)\n",
        //         thr, ptr, offs-misalign, offs, ptr+(offs-misalign)); 
        return offs - misalign;
}


//extern thr_ctrl master_thr;
extern int num_threads;
extern struct thr_ctrl *threads;
extern THREAD__ int ismainthread;
extern THREAD__ int thrno;
extern THREAD__ struct thr_ctrl *this_thread;

/* callbacks */
typedef void cbackfn(void *ptr, const int thr);
void thread_reg_callback(cbackfn ctor, cbackfn dtor, void *parm);
void thread_dereg_callback(cbackfn ctor, cbackfn dtor, void *parm);

NAMESPACE_END

#if defined(SMP) && (!defined(_REENTRANT) && !defined(_THREAD_SAFE))
# warning "Define _REENTRANT and/or _THREAD_SAFE for multithreaded (SMP) compilation!"
#endif
        
#else /* _POSIX_THREADS */
# define MAIN_PID (getpid())
# undef SMP
# define num_threads (0)
# define thrno (0)
# define ismainthread (1)
#endif /* _POSIX_THREADS */

#endif /* TBCI_SMP_H */

---