Changeset 3ce0c915


Ignore:
Timestamp:
Feb 2, 2018, 4:00:09 PM (4 years ago)
Author:
Rob Schluntz <rschlunt@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, with_gc
Children:
d03fa6d
Parents:
11b7028 (diff), d7d4702 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' of plg.uwaterloo.ca:/u/cforall/software/cfa/cfa-cc

Files:
1 added
11 edited

Legend:

Unmodified
Added
Removed
  • configure

    r11b7028 r3ce0c915  
    678678CFA_INCDIR
    679679CFA_PREFIX
     680DOendif
     681DOifskipcompile
    680682BUILD_CONCURRENCY_FALSE
    681683BUILD_CONCURRENCY_TRUE
     
    33423344
    33433345
     3346DOifskipcompile='ifeq ($(skipcompile),yes)
     3347else'
     3348
     3349
     3350
     3351DOendif='endif'
     3352
     3353
     3354
    33443355if test "x$prefix" = "xNONE"; then
    33453356        cfa_prefix=${ac_default_prefix}
  • configure.ac

    r11b7028 r3ce0c915  
    130130AM_CONDITIONAL([BUILD_NO_LIB], [test "x$build_release$build_debug" = "xnono"])
    131131AM_CONDITIONAL([BUILD_CONCURRENCY], [test "x$build_threading" = "xyes"])
     132
     133DOifskipcompile='ifeq ($(skipcompile),yes)
     134else'
     135AC_SUBST([DOifskipcompile])
     136AM_SUBST_NOTMAKE([DOifskipcompile])
     137
     138DOendif='endif'
     139AC_SUBST([DOendif])
     140AM_SUBST_NOTMAKE([DOendif])
    132141
    133142if test "x$prefix" = "xNONE"; then
  • doc/papers/general/Paper.tex

    r11b7028 r3ce0c915  
    148148The C programming language is a foundational technology for modern computing with millions of lines of code implementing everything from commercial operating-systems to hobby projects.
    149149This installation base and the programmers producing it represent a massive software-engineering investment spanning decades and likely to continue for decades more.
    150 The \cite{TIOBE} ranks the top 5 most popular programming languages as: Java 16\%, \Textbf{C 7\%}, \Textbf{\CC 5\%}, \Csharp 4\%, Python 4\% = 36\%, where the next 50 languages are less than 3\% each with a long tail.
     150The TIOBE\cite{TIOBE} ranks the top 5 most popular programming languages as: Java 16\%, \Textbf{C 7\%}, \Textbf{\CC 5\%}, \Csharp 4\%, Python 4\% = 36\%, where the next 50 languages are less than 3\% each with a long tail.
    151151The top 3 rankings over the past 30 years are:
    152152\lstDeleteShortInline@%
     
    185185\label{sec:poly-fns}
    186186
    187 \CFA{}\hspace{1pt}'s polymorphism was originally formalized by \cite{Ditchfield92}, and first implemented by \cite{Bilson03}.
     187\CFA{}\hspace{1pt}'s polymorphism was originally formalized by Ditchfield\cite{Ditchfield92}, and first implemented by Bilson\cite{Bilson03}.
    188188The signature feature of \CFA is parametric-polymorphic functions~\cite{forceone:impl,Cormack90,Duggan96} with functions generalized using a @forall@ clause (giving the language its name):
    189189\begin{lstlisting}
     
    258258}
    259259\end{lstlisting}
    260 Within the block, the nested version of @<@ performs @>@ and this local version overrides the built-in @<@ so it is passed to @qsort@.
     260Within the block, the nested version of @?<?@ performs @?>?@ and this local version overrides the built-in @?<?@ so it is passed to @qsort@.
    261261Hence, programmers can easily form local environments, adding and modifying appropriate functions, to maximize reuse of other existing functions and types.
    262262
     
    337337% While a nominal-inheritance system with associated types could model one of those two relationships by making @El@ an associated type of @Ptr@ in the @pointer_like@ implementation, few such systems could model both relationships simultaneously.
    338338
    339 
    340339\section{Generic Types}
    341340
     
    466465However, the \CFA type-checker ensures matching types are used by all calls to @?+?@, preventing nonsensical computations like adding a length to a volume.
    467466
    468 
    469467\section{Tuples}
    470468\label{sec:tuples}
     
    544542p`->0` = 5;                                                                     $\C{// change quotient}$
    545543bar( qr`.1`, qr );                                                      $\C{// pass remainder and quotient/remainder}$
    546 rem = [42, div( 13, 5 )]`.0.1`;                         $\C{// access 2nd component of 1st component of tuple expression}$
     544rem = [div( 13, 5 ), 42]`.0.1`;                         $\C{// access 2nd component of 1st component of tuple expression}$
    547545\end{lstlisting}
    548546
     
    730728\end{lstlisting}
    731729Hence, function parameter and return lists are flattened for the purposes of type unification allowing the example to pass expression resolution.
    732 This relaxation is possible by extending the thunk scheme described by~\cite{Bilson03}.
     730This relaxation is possible by extending the thunk scheme described by Bilson\cite{Bilson03}.
    733731Whenever a candidate's parameter structure does not exactly match the formal parameter's structure, a thunk is generated to specialize calls to the actual function:
    734732\begin{lstlisting}
     
    901899\end{comment}
    902900
     901\section{Improved Procedural Paradigm}
     902
     903It is important to the design team that \CFA subjectively ``feel like'' C to user programmers.
     904An important part of this subjective feel is maintaining C's procedural programming paradigm, as opposed to the object-oriented paradigm of other systems languages such as \CC and Rust.
     905Maintaining this procedural paradigm means that coding patterns that work in C will remain not only functional but idiomatic in \CFA, reducing the mental burden of retraining C programmers and switching between C and \CFA development.
     906Nonetheless, some features of object-oriented languages are undeniably convienient, and the \CFA design team has attempted to adapt them to a procedural paradigm so as to incorporate their benefits into \CFA; two of these features are resource management and name scoping.
     907
     908\subsection{Constructors and Destructors}
     909
     910One of the strengths of C is the control over memory management it gives programmers, allowing resource release to be more consistent and precisely timed than is possible with garbage-collected memory management.
     911However, this manual approach to memory management is often verbose, and it is useful to manage resources other than memory (\eg file handles) using the same mechanism as memory.
     912\CC is well-known for an approach to manual memory management that addresses both these issues, Resource Allocation Is Initialization (RAII), implemented by means of special \emph{constructor} and \emph{destructor} functions; we have implemented a similar feature in \CFA.
     913
     914\TODO{Fill out section. Mention field-constructors and at-equal escape hatch to C-style initialization. Probably pull some text from Rob's thesis for first draft.}
     915
     916\subsection{with Statement}
     917
     918In any programming language, some functions have a naturally close relationship with a particular data type.
     919Object-oriented programming allows this close relationship to be codified in the language by making such functions \emph{class methods} of their related data type.
     920Class methods have certain privileges with respect to their associated data type, notably un-prefixed access to the fields of that data type.
     921When writing C functions in an object-oriented style, this un-prefixed access is swiftly missed, as access to fields of a @Foo* f@ requires an extra three characters @f->@ every time, which disrupts coding flow and clutters the produced code.
     922
     923\TODO{Fill out section. Be sure to mention arbitrary expressions in with-blocks, recent change driven by Thierry to prioritize field name over parameters.}
     924
     925\section{References}
     926
     927\TODO{Pull draft text from user manual; make sure to discuss nested references and rebind operator drawn from lvalue-addressof operator}
    903928
    904929\section{Evaluation}
     
    10131038In contrast, \CFA has a single facility for polymorphic code supporting type-safe separate-compilation of polymorphic functions and generic (opaque) types, which uniformly leverage the C procedural paradigm.
    10141039The key mechanism to support separate compilation is \CFA's \emph{explicit} use of assumed properties for a type.
    1015 Until \CC~\cite{C++Concepts} are standardized (anticipated for \CCtwenty), \CC provides no way to specify the requirements of a generic function in code beyond compilation errors during template expansion;
     1040Until \CC concepts~\cite{C++Concepts} are standardized (anticipated for \CCtwenty), \CC provides no way to specify the requirements of a generic function in code beyond compilation errors during template expansion;
    10161041furthermore, \CC concepts are restricted to template polymorphism.
    10171042
     
    10211046In \CFA terms, all Cyclone polymorphism must be dtype-static.
    10221047While the Cyclone design provides the efficiency benefits discussed in Section~\ref{sec:generic-apps} for dtype-static polymorphism, it is more restrictive than \CFA's general model.
    1023 \cite{Smith98} present Polymorphic C, an ML dialect with polymorphic functions and C-like syntax and pointer types; it lacks many of C's features, however, most notably structure types, and so is not a practical C replacement.
    1024 
    1025 \cite{obj-c-book} is an industrially successful extension to C.
     1048Smith and Volpano~\cite{Smith98} present Polymorphic C, an ML dialect with polymorphic functions, C-like syntax, and pointer types; it lacks many of C's features, however, most notably structure types, and so is not a practical C replacement.
     1049
     1050Objective-C~\cite{obj-c-book} is an industrially successful extension to C.
    10261051However, Objective-C is a radical departure from C, using an object-oriented model with message-passing.
    10271052Objective-C did not support type-checked generics until recently \cite{xcode7}, historically using less-efficient runtime checking of object types.
    1028 The~\cite{GObject} framework also adds object-oriented programming with runtime type-checking and reference-counting garbage-collection to C;
     1053The GObject~\cite{GObject} framework also adds object-oriented programming with runtime type-checking and reference-counting garbage-collection to C;
    10291054these features are more intrusive additions than those provided by \CFA, in addition to the runtime overhead of reference-counting.
    1030 \cite{Vala} compiles to GObject-based C, adding the burden of learning a separate language syntax to the aforementioned demerits of GObject as a modernization path for existing C code-bases.
     1055Vala~\cite{Vala} compiles to GObject-based C, adding the burden of learning a separate language syntax to the aforementioned demerits of GObject as a modernization path for existing C code-bases.
    10311056Java~\cite{Java8} included generic types in Java~5, which are type-checked at compilation and type-erased at runtime, similar to \CFA's.
    10321057However, in Java, each object carries its own table of method pointers, while \CFA passes the method pointers separately to maintain a C-compatible layout.
    10331058Java is also a garbage-collected, object-oriented language, with the associated resource usage and C-interoperability burdens.
    10341059
    1035 D~\cite{D}, Go, and~\cite{Rust} are modern, compiled languages with abstraction features similar to \CFA traits, \emph{interfaces} in D and Go and \emph{traits} in Rust.
     1060D~\cite{D}, Go, and Rust~\cite{Rust} are modern, compiled languages with abstraction features similar to \CFA traits, \emph{interfaces} in D and Go and \emph{traits} in Rust.
    10361061However, each language represents a significant departure from C in terms of language model, and none has the same level of compatibility with C as \CFA.
    10371062D and Go are garbage-collected languages, imposing the associated runtime overhead.
     
    10541079\CCeleven introduced @std::tuple@ as a library variadic template structure.
    10551080Tuples are a generalization of @std::pair@, in that they allow for arbitrary length, fixed-size aggregation of heterogeneous values.
    1056 Operations include @std::get<N>@ to extract vales, @std::tie@ to create a tuple of references used for assignment, and lexicographic comparisons.
     1081Operations include @std::get<N>@ to extract values, @std::tie@ to create a tuple of references used for assignment, and lexicographic comparisons.
    10571082\CCseventeen proposes \emph{structured bindings}~\cite{Sutter15} to eliminate pre-declaring variables and use of @std::tie@ for binding the results.
    10581083This extension requires the use of @auto@ to infer the types of the new variables, so complicated expressions with a non-obvious type must be documented with some other mechanism.
     
    10681093The goal of \CFA is to provide an evolutionary pathway for large C development-environments to be more productive and safer, while respecting the talent and skill of C programmers.
    10691094While other programming languages purport to be a better C, they are in fact new and interesting languages in their own right, but not C extensions.
    1070 The purpose of this paper is to introduce \CFA, and showcase two language features that illustrate the \CFA type-system and approaches taken to achieve the goal of evolutionary C extension.
     1095The purpose of this paper is to introduce \CFA, and showcase language features that illustrate the \CFA type-system and approaches taken to achieve the goal of evolutionary C extension.
    10711096The contributions are a powerful type-system using parametric polymorphism and overloading, generic types, and tuples, which all have complex interactions.
    10721097The work is a challenging design, engineering, and implementation exercise.
  • doc/theses/thierry_delisle/Makefile

    r11b7028 r3ce0c915  
    9898        fig2dev -L pstex_t -p ${Build}/$@ $< > ${Build}/$@_t
    9999
    100 %.tex: %.pstex
     100#-----------------------------------------------------------------------------------
     101# Tools to generate png files
     102# to create a png we create a pdf and convert it to png
     103%.png : build/%.pstex figures/%.tex
     104        echo ${basename $@}
     105        ${LaTeX} figures/${basename $@}.tex
     106        dvips build/${basename $@}.dvi -o build/${basename $@}.ps
     107        ps2pdf build/${basename $@}.ps
     108        convert -negate ${basename $@}.pdf $@
     109
     110# creating a pdf of a figure requires generating some latex that just includes the figure
     111figures/%.tex: build/%.pstex
    101112        echo -n         "\documentclass[preview]{standalone}\n"         \
    102113                        "\usepackage[T1]{fontenc}\n"                    \
     
    110121                        "\end{document}" > $@
    111122
    112 %.png : %.pstex %.tex
    113         echo ${basename $@}
    114         ${LaTeX} figures/${basename $@}.tex
    115         dvips build/${basename $@}.dvi -o build/${basename $@}.ps
    116         ps2pdf build/${basename $@}.ps
    117         convert -negate ${basename $@}.pdf $@
    118 
    119123# Local Variables: #
    120124# compile-command: "make" #
  • src/benchmark/Makefile.am

    r11b7028 r3ce0c915  
    2323STATS    = ${TOOLSDIR}stat.py
    2424repeats  = 30
     25skipcompile = no
    2526TIME_FORMAT = "%E"
    2627PRINT_FORMAT = %20s: #Comments needed for spacing
     
    4344%.runquiet :
    4445        @+make $(basename $@)
    45         @./a.out
     46        @taskset -c 1 ./a.out
    4647        @rm -f a.out
    4748
     
    5960        @echo -e '\t"githash": "'${githash}'",'
    6061        @echo -e '\t"arch": "'   ${arch}   '",'
     62@DOifskipcompile@
    6163        @echo -e '\t"compile": {'
    6264        @+make compile TIME_FORMAT='%e,' PRINT_FORMAT='\t\t\"%s\" :'
    6365        @echo -e '\t\t"dummy" : {}'
    6466        @echo -e '\t},'
     67@DOendif@
    6568        @echo -e '\t"ctxswitch": {'
    6669        @echo -en '\t\t"coroutine":'
  • src/benchmark/Makefile.in

    r11b7028 r3ce0c915  
    253253STATS = ${TOOLSDIR}stat.py
    254254repeats = 30
     255skipcompile = no
    255256TIME_FORMAT = "%E"
    256257PRINT_FORMAT = %20s: #Comments needed for spacing
     
    459460%.runquiet :
    460461        @+make $(basename $@)
    461         @./a.out
     462        @taskset -c 1 ./a.out
    462463        @rm -f a.out
    463464
     
    473474        @echo -e '\t"githash": "'${githash}'",'
    474475        @echo -e '\t"arch": "'   ${arch}   '",'
     476@DOifskipcompile@
    475477        @echo -e '\t"compile": {'
    476478        @+make compile TIME_FORMAT='%e,' PRINT_FORMAT='\t\t\"%s\" :'
    477479        @echo -e '\t\t"dummy" : {}'
    478480        @echo -e '\t},'
     481@DOendif@
    479482        @echo -e '\t"ctxswitch": {'
    480483        @echo -en '\t\t"coroutine":'
  • src/driver/cfa.cc

    r11b7028 r3ce0c915  
    1010// Created On       : Tue Aug 20 13:44:49 2002
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Jan 30 15:46:15 2018
    13 // Update Count     : 161
     12// Last Modified On : Thu Feb  1 22:26:10 2018
     13// Update Count     : 163
    1414//
    1515
     
    358358                args[nargs] = "-D__int8_t_defined";                             // prevent gcc type-size attributes
    359359                nargs += 1;
    360                 args[nargs] = "-D__NO_STRING_INLINES";                  // prevent gcc strcmp unrolling
    361                 nargs += 1;
    362360                args[nargs] = ( *new string( string("-B") + Bprefix + "/" ) ).c_str();
    363361                nargs += 1;
  • src/libcfa/concurrency/kernel.c

    r11b7028 r3ce0c915  
    5959
    6060volatile thread_local bool preemption_in_progress = 0;
     61volatile thread_local bool preemption_enabled = false;
    6162volatile thread_local unsigned short disable_preempt_count = 1;
    6263
     
    196197                        if(readyThread)
    197198                        {
    198                                 verify( disable_preempt_count > 0 );
     199                                verify( !preemption_enabled );
    199200
    200201                                runThread(this, readyThread);
    201202
    202                                 verify( disable_preempt_count > 0 );
     203                                verify( !preemption_enabled );
    203204
    204205                                //Some actions need to be taken from the kernel
     
    242243void finishRunning(processor * this) with( this->finish ) {
    243244        if( action_code == Release ) {
    244                 verify( disable_preempt_count > 1 );
     245                verify( !preemption_enabled );
    245246                unlock( *lock );
    246247        }
     
    249250        }
    250251        else if( action_code == Release_Schedule ) {
    251                 verify( disable_preempt_count > 1 );
     252                verify( !preemption_enabled );
    252253                unlock( *lock );
    253254                ScheduleThread( thrd );
    254255        }
    255256        else if( action_code == Release_Multi ) {
    256                 verify( disable_preempt_count > lock_count );
     257                verify( !preemption_enabled );
    257258                for(int i = 0; i < lock_count; i++) {
    258259                        unlock( *locks[i] );
     
    286287        this_coroutine = NULL;
    287288        this_thread = NULL;
     289        preemption_enabled = false;
    288290        disable_preempt_count = 1;
    289291        // SKULLDUGGERY: We want to create a context for the processor coroutine
     
    333335        verify( thrd->self_cor.state != Halted );
    334336
    335         verify( disable_preempt_count > 0 );
     337        verify( !preemption_enabled );
    336338
    337339        verifyf( thrd->next == NULL, "Expected null got %p", thrd->next );
     
    343345        }
    344346
    345         verify( disable_preempt_count > 0 );
     347        verify( !preemption_enabled );
    346348}
    347349
    348350thread_desc * nextThread(cluster * this) with( *this ) {
    349         verify( disable_preempt_count > 0 );
     351        verify( !preemption_enabled );
    350352        lock( ready_queue_lock __cfaabi_dbg_ctx2 );
    351353        thread_desc * head = pop_head( ready_queue );
    352354        unlock( ready_queue_lock );
    353         verify( disable_preempt_count > 0 );
     355        verify( !preemption_enabled );
    354356        return head;
    355357}
     
    357359void BlockInternal() {
    358360        disable_interrupts();
    359         verify( disable_preempt_count > 0 );
    360         suspend();
    361         verify( disable_preempt_count > 0 );
     361        verify( !preemption_enabled );
     362        suspend();
     363        verify( !preemption_enabled );
    362364        enable_interrupts( __cfaabi_dbg_ctx );
    363365}
     
    368370        this_processor->finish.lock        = lock;
    369371
    370         verify( disable_preempt_count > 1 );
    371         suspend();
    372         verify( disable_preempt_count > 0 );
     372        verify( !preemption_enabled );
     373        suspend();
     374        verify( !preemption_enabled );
    373375
    374376        enable_interrupts( __cfaabi_dbg_ctx );
     
    380382        this_processor->finish.thrd        = thrd;
    381383
    382         verify( disable_preempt_count > 0 );
    383         suspend();
    384         verify( disable_preempt_count > 0 );
     384        verify( !preemption_enabled );
     385        suspend();
     386        verify( !preemption_enabled );
    385387
    386388        enable_interrupts( __cfaabi_dbg_ctx );
     
    394396        this_processor->finish.thrd        = thrd;
    395397
    396         verify( disable_preempt_count > 1 );
    397         suspend();
    398         verify( disable_preempt_count > 0 );
     398        verify( !preemption_enabled );
     399        suspend();
     400        verify( !preemption_enabled );
    399401
    400402        enable_interrupts( __cfaabi_dbg_ctx );
     
    407409        this_processor->finish.lock_count  = count;
    408410
    409         verify( disable_preempt_count > 0 );
    410         suspend();
    411         verify( disable_preempt_count > 0 );
     411        verify( !preemption_enabled );
     412        suspend();
     413        verify( !preemption_enabled );
    412414
    413415        enable_interrupts( __cfaabi_dbg_ctx );
     
    422424        this_processor->finish.thrd_count  = thrd_count;
    423425
    424         verify( disable_preempt_count > 0 );
    425         suspend();
    426         verify( disable_preempt_count > 0 );
     426        verify( !preemption_enabled );
     427        suspend();
     428        verify( !preemption_enabled );
    427429
    428430        enable_interrupts( __cfaabi_dbg_ctx );
     
    430432
    431433void LeaveThread(__spinlock_t * lock, thread_desc * thrd) {
    432         verify( disable_preempt_count > 0 );
     434        verify( !preemption_enabled );
    433435        this_processor->finish.action_code = thrd ? Release_Schedule : Release;
    434436        this_processor->finish.lock        = lock;
  • src/libcfa/concurrency/kernel_private.h

    r11b7028 r3ce0c915  
    7474
    7575extern volatile thread_local bool preemption_in_progress;
     76extern volatile thread_local bool preemption_enabled;
    7677extern volatile thread_local unsigned short disable_preempt_count;
    7778
  • src/libcfa/concurrency/monitor.c

    r11b7028 r3ce0c915  
    8787                thread_desc * thrd = this_thread;
    8888
    89                 verify( disable_preempt_count > 0 );
    90 
    9189                __cfaabi_dbg_print_safe("Kernel : %10p Entering mon %p (%p)\n", thrd, this, this->owner);
    9290
     
    117115                        // Some one else has the monitor, wait in line for it
    118116                        append( this->entry_queue, thrd );
    119 
    120                         verify( disable_preempt_count > 0 );
    121117
    122118                        BlockInternal( &this->lock );
     
    396392        append( this.blocked, &waiter );
    397393
    398         verify( disable_preempt_count == 0 );
    399 
    400394        // Lock all monitors (aggregates the locks as well)
    401395        lock_all( monitors, locks, count );
    402 
    403         // verifyf( disable_preempt_count == count, "Got %d, expected %d\n", disable_preempt_count, count );
    404         if(disable_preempt_count != count) { __cfaabi_dbg_print_buffer_decl("----------Gonna crash\n"); }
    405396
    406397        // Find the next thread(s) to run
     
    477468        monitor_ctx( this.monitors, this.monitor_count );
    478469
    479         verify( disable_preempt_count == 0 );
    480 
    481470        // Lock all monitors (aggregates the locks them as well)
    482471        lock_all( monitors, locks, count );
    483 
    484         // verify( disable_preempt_count == count );
    485         if(disable_preempt_count != count) { __cfaabi_dbg_print_buffer_decl("----------Gonna crash\n"); }
    486472
    487473
  • src/libcfa/concurrency/preemption.c

    r11b7028 r3ce0c915  
    4949// Machine specific register name
    5050#if   defined(__x86_64__)
    51 #define CFA_REG_IP REG_RIP
     51#define CFA_REG_IP gregs[REG_RIP]
    5252#elif defined(__i386__)
    53 #define CFA_REG_IP REG_EIP
     53#define CFA_REG_IP gregs[REG_EIP]
    5454#elif defined(__ARM_ARCH__)
    55 #define CFA_REG_IP REG_R15
     55#define CFA_REG_IP arm_pc
    5656#endif
    5757
     
    142142        // Disable interrupts by incrementing the counter
    143143        void disable_interrupts() {
    144                 __attribute__((unused)) unsigned short new_val = __atomic_add_fetch_2( &disable_preempt_count, 1, __ATOMIC_SEQ_CST );
     144                preemption_enabled = false;
     145                __attribute__((unused)) unsigned short new_val = disable_preempt_count + 1;
     146                disable_preempt_count = new_val;
    145147                verify( new_val < 65_000u );              // If this triggers someone is disabling interrupts without enabling them
    146148        }
     
    152154                thread_desc * thrd = this_thread;         // Cache the thread now since interrupts can start happening after the atomic add
    153155
    154                 unsigned short prev = __atomic_fetch_add_2( &disable_preempt_count, -1, __ATOMIC_SEQ_CST );
     156                unsigned short prev = disable_preempt_count;
     157                disable_preempt_count -= 1;
    155158                verify( prev != 0u );                     // If this triggers someone is enabled already enabled interruptsverify( prev != 0u );
    156159
    157160                // Check if we need to prempt the thread because an interrupt was missed
    158                 if( prev == 1 && proc->pending_preemption ) {
    159                         proc->pending_preemption = false;
    160                         BlockInternal( thrd );
     161                if( prev == 1 ) {
     162                        preemption_enabled = true;
     163                        if( proc->pending_preemption ) {
     164                                proc->pending_preemption = false;
     165                                BlockInternal( thrd );
     166                        }
    161167                }
    162168
     
    168174        // Don't execute any pending CtxSwitch even if counter reaches 0
    169175        void enable_interrupts_noPoll() {
    170                 __attribute__((unused)) unsigned short prev = __atomic_fetch_add_2( &disable_preempt_count, -1, __ATOMIC_SEQ_CST );
     176                unsigned short prev = disable_preempt_count;
     177                disable_preempt_count -= 1;
    171178                verifyf( prev != 0u, "Incremented from %u\n", prev );                     // If this triggers someone is enabled already enabled interrupts
     179                if( prev == 1 ) {
     180                        preemption_enabled = true;
     181                }
    172182        }
    173183}
     
    210220// If false : preemption is unsafe and marked as pending
    211221static inline bool preemption_ready() {
    212         bool ready = disable_preempt_count == 0 && !preemption_in_progress; // Check if preemption is safe
     222        bool ready = preemption_enabled && !preemption_in_progress; // Check if preemption is safe
    213223        this_processor->pending_preemption = !ready;                        // Adjust the pending flag accordingly
    214224        return ready;
     
    225235
    226236        // Start with preemption disabled until ready
     237        preemption_enabled = false;
    227238        disable_preempt_count = 1;
    228239
     
    284295// Receives SIGUSR1 signal and causes the current thread to yield
    285296void sigHandler_ctxSwitch( __CFA_SIGPARMS__ ) {
    286 #if defined( __ARM_ARCH )
    287         __cfaabi_dbg_debug_do( last_interrupt = (void *)(cxt->uc_mcontext.arm_pc); )
    288 #else
    289         __cfaabi_dbg_debug_do( last_interrupt = (void *)(cxt->uc_mcontext.gregs[CFA_REG_IP]); )
    290 #endif
    291 
    292                 // Check if it is safe to preempt here
     297        __cfaabi_dbg_debug_do( last_interrupt = (void *)(cxt->uc_mcontext.CFA_REG_IP); )
     298
     299        // Check if it is safe to preempt here
    293300        if( !preemption_ready() ) { return; }
    294301
Note: See TracChangeset for help on using the changeset viewer.