source: libcfa/src/concurrency/thread.hfa @ b0c7419

//
// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
//
// The contents of this file are covered under the licence agreement in the
// file "LICENCE" distributed with Cforall.
//
// thread --
//
// Author           : Thierry Delisle
// Created On       : Tue Jan 17 12:27:26 2017
// Last Modified By : Peter A. Buhr
// Last Modified On : Wed Dec  4 09:18:14 2019
// Update Count     : 6
//

#pragma once

#include <assert.h>
#include "invoke.h"

#include "coroutine.hfa"
#include "kernel.hfa"
#include "monitor.hfa"

//-----------------------------------------------------------------------------
// thread trait
trait is_thread(dtype T) {
      void ^?{}(T& mutex this);
      void main(T& this);
      thread_desc* get_thread(T& this);
};

#define DECL_THREAD(X) thread_desc* get_thread(X& this) { return &this.__thrd; } void main(X& this)

forall( dtype T | is_thread(T) )
static inline coroutine_desc* get_coroutine(T & this) {
        return &get_thread(this)->self_cor;
}

forall( dtype T | is_thread(T) )
static inline monitor_desc* get_monitor(T & this) {
        return &get_thread(this)->self_mon;
}

static inline coroutine_desc* get_coroutine(thread_desc * this) {
        return &this->self_cor;
}

static inline monitor_desc* get_monitor(thread_desc * this) {
        return &this->self_mon;
}

extern struct cluster * mainCluster;

forall( dtype T | is_thread(T) )
void __thrd_start( T & this, void (*)(T &) );

//-----------------------------------------------------------------------------
// Ctors and dtors
void ?{}(thread_desc & this, const char * const name, struct cluster & cl, void * storage, size_t storageSize );
void ^?{}(thread_desc & this);

static inline void ?{}(thread_desc & this)                                                                  { this{ "Anonymous Thread", *mainCluster, 0p, 65000 }; }
static inline void ?{}(thread_desc & this, size_t stackSize )                                               { this{ "Anonymous Thread", *mainCluster, 0p, stackSize }; }
static inline void ?{}(thread_desc & this, void * storage, size_t storageSize )                             { this{ "Anonymous Thread", *mainCluster, storage, storageSize }; }
static inline void ?{}(thread_desc & this, struct cluster & cl )                                            { this{ "Anonymous Thread", cl, 0p, 65000 }; }
static inline void ?{}(thread_desc & this, struct cluster & cl, size_t stackSize )                          { this{ "Anonymous Thread", cl, 0p, stackSize }; }
static inline void ?{}(thread_desc & this, struct cluster & cl, void * storage, size_t storageSize )        { this{ "Anonymous Thread", cl, storage, storageSize }; }
static inline void ?{}(thread_desc & this, const char * const name)                                         { this{ name, *mainCluster, 0p, 65000 }; }
static inline void ?{}(thread_desc & this, const char * const name, struct cluster & cl )                   { this{ name, cl, 0p, 65000 }; }
static inline void ?{}(thread_desc & this, const char * const name, struct cluster & cl, size_t stackSize ) { this{ name, cl, 0p, stackSize }; }

//-----------------------------------------------------------------------------
// thread runner
// Structure that actually start and stop threads
forall( dtype T | sized(T) | is_thread(T) )
struct scoped {
        T handle;
};

forall( dtype T | sized(T) | is_thread(T) | { void ?{}(T&); } )
void ?{}( scoped(T)& this );

forall( dtype T, ttype P | sized(T) | is_thread(T) | { void ?{}(T&, P); } )
void ?{}( scoped(T)& this, P params );

forall( dtype T | sized(T) | is_thread(T) )
void ^?{}( scoped(T)& this );

//-----------------------------------------------------------------------------
// Thread getters
static inline struct thread_desc * active_thread () { return TL_GET( this_thread ); }

//-----------------------------------------------------------------------------
// Scheduler API

//----------
// Park thread: block until corresponding call to unpark, won't block if unpark is already called
void park( void );

//----------
// Unpark a thread, if the thread is already blocked, schedule it
//                  if the thread is not yet block, signal that it should rerun immediately
void unpark( thread_desc * this );

forall( dtype T | is_thread(T) )
static inline void unpark( T & this ) { if(!&this) return; unpark( get_thread( this ) );}

//----------
// Yield: force thread to block and be rescheduled
bool force_yield( enum __Preemption_Reason );

static inline void yield() {
        force_yield(__MANUAL_PREEMPTION);
}

// Yield: yield N times
static inline void yield( unsigned times ) {
        for( times ) {
                yield();
        }
}

// Local Variables: //
// mode: c //
// tab-width: 4 //
// End: //