// // 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. // // kernel -- // // Author : Thierry Delisle // Created On : Tue Jan 17 12:27:26 2017 // Last Modified By : Peter A. Buhr // Last Modified On : Tue Feb 4 12:29:26 2020 // Update Count : 22 // #pragma once #include #include "invoke.h" #include "time_t.hfa" #include "coroutine.hfa" extern "C" { #include #include } //----------------------------------------------------------------------------- // Locks struct semaphore { __spinlock_t lock; int count; __queue_t($thread) waiting; }; void ?{}(semaphore & this, int count = 1); void ^?{}(semaphore & this); void P (semaphore & this); bool V (semaphore & this); //----------------------------------------------------------------------------- // Processor extern struct cluster * mainCluster; // Processor coroutine processorCtx_t { struct processor * proc; }; // Wrapper around kernel threads struct processor { // Main state // Coroutine ctx who does keeps the state of the processor struct processorCtx_t runner; // Cluster from which to get threads struct cluster * cltr; // Name of the processor const char * name; // Handle to pthreads pthread_t kernel_thread; // RunThread data // Action to do after a thread is ran $thread * destroyer; // Preemption data // Node which is added in the discrete event simulaiton struct alarm_node_t * preemption_alarm; // If true, a preemption was triggered in an unsafe region, the processor must preempt as soon as possible bool pending_preemption; // Idle lock __bin_sem_t idleLock; // Termination // Set to true to notify the processor should terminate volatile bool do_terminate; // Termination synchronisation semaphore terminated; // pthread Stack void * stack; // Link lists fields struct __dbg_node_proc { struct processor * next; struct processor * prev; } node; #ifdef __CFA_DEBUG__ // Last function to enable preemption on this processor const char * last_enable; #endif }; void ?{}(processor & this, const char name[], struct cluster & cltr); void ^?{}(processor & this); static inline void ?{}(processor & this) { this{ "Anonymous Processor", *mainCluster}; } static inline void ?{}(processor & this, struct cluster & cltr) { this{ "Anonymous Processor", cltr}; } static inline void ?{}(processor & this, const char name[]) { this{name, *mainCluster }; } static inline [processor *&, processor *& ] __get( processor & this ) __attribute__((const)) { return this.node.[next, prev]; } //----------------------------------------------------------------------------- // Cluster struct cluster { // Ready queue locks __spinlock_t ready_queue_lock; // Ready queue for threads __queue_t($thread) ready_queue; // Name of the cluster const char * name; // Preemption rate on this cluster Duration preemption_rate; // List of processors __spinlock_t proc_list_lock; __dllist_t(struct processor) procs; __dllist_t(struct processor) idles; unsigned int nprocessors; // List of threads __spinlock_t thread_list_lock; __dllist_t(struct $thread) threads; unsigned int nthreads; // Link lists fields struct __dbg_node_cltr { cluster * next; cluster * prev; } node; }; extern Duration default_preemption(); void ?{} (cluster & this, const char name[], Duration preemption_rate); void ^?{}(cluster & this); static inline void ?{} (cluster & this) { this{"Anonymous Cluster", default_preemption()}; } static inline void ?{} (cluster & this, Duration preemption_rate) { this{"Anonymous Cluster", preemption_rate}; } static inline void ?{} (cluster & this, const char name[]) { this{name, default_preemption()}; } static inline [cluster *&, cluster *& ] __get( cluster & this ) __attribute__((const)) { return this.node.[next, prev]; } static inline struct processor * active_processor() { return TL_GET( this_processor ); } // UNSAFE static inline struct cluster * active_cluster () { return TL_GET( this_processor )->cltr; } // Local Variables: // // mode: c // // tab-width: 4 // // End: //