Changeset 3ce0c915
- Timestamp:
- Feb 2, 2018, 4:00:09 PM (7 years ago)
- Branches:
- ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, 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. - Files:
-
- 1 added
- 11 edited
Legend:
- Unmodified
- Added
- Removed
-
configure
r11b7028 r3ce0c915 678 678 CFA_INCDIR 679 679 CFA_PREFIX 680 DOendif 681 DOifskipcompile 680 682 BUILD_CONCURRENCY_FALSE 681 683 BUILD_CONCURRENCY_TRUE … … 3342 3344 3343 3345 3346 DOifskipcompile='ifeq ($(skipcompile),yes) 3347 else' 3348 3349 3350 3351 DOendif='endif' 3352 3353 3354 3344 3355 if test "x$prefix" = "xNONE"; then 3345 3356 cfa_prefix=${ac_default_prefix} -
configure.ac
r11b7028 r3ce0c915 130 130 AM_CONDITIONAL([BUILD_NO_LIB], [test "x$build_release$build_debug" = "xnono"]) 131 131 AM_CONDITIONAL([BUILD_CONCURRENCY], [test "x$build_threading" = "xyes"]) 132 133 DOifskipcompile='ifeq ($(skipcompile),yes) 134 else' 135 AC_SUBST([DOifskipcompile]) 136 AM_SUBST_NOTMAKE([DOifskipcompile]) 137 138 DOendif='endif' 139 AC_SUBST([DOendif]) 140 AM_SUBST_NOTMAKE([DOendif]) 132 141 133 142 if test "x$prefix" = "xNONE"; then -
doc/papers/general/Paper.tex
r11b7028 r3ce0c915 148 148 The 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. 149 149 This 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.150 The 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. 151 151 The top 3 rankings over the past 30 years are: 152 152 \lstDeleteShortInline@% … … 185 185 \label{sec:poly-fns} 186 186 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}. 188 188 The 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): 189 189 \begin{lstlisting} … … 258 258 } 259 259 \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@.260 Within the block, the nested version of @?<?@ performs @?>?@ and this local version overrides the built-in @?<?@ so it is passed to @qsort@. 261 261 Hence, programmers can easily form local environments, adding and modifying appropriate functions, to maximize reuse of other existing functions and types. 262 262 … … 337 337 % 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. 338 338 339 340 339 \section{Generic Types} 341 340 … … 466 465 However, the \CFA type-checker ensures matching types are used by all calls to @?+?@, preventing nonsensical computations like adding a length to a volume. 467 466 468 469 467 \section{Tuples} 470 468 \label{sec:tuples} … … 544 542 p`->0` = 5; $\C{// change quotient}$ 545 543 bar( 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}$544 rem = [div( 13, 5 ), 42]`.0.1`; $\C{// access 2nd component of 1st component of tuple expression}$ 547 545 \end{lstlisting} 548 546 … … 730 728 \end{lstlisting} 731 729 Hence, 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}.730 This relaxation is possible by extending the thunk scheme described by Bilson\cite{Bilson03}. 733 731 Whenever 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: 734 732 \begin{lstlisting} … … 901 899 \end{comment} 902 900 901 \section{Improved Procedural Paradigm} 902 903 It is important to the design team that \CFA subjectively ``feel like'' C to user programmers. 904 An 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. 905 Maintaining 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. 906 Nonetheless, 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 910 One 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. 911 However, 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 918 In any programming language, some functions have a naturally close relationship with a particular data type. 919 Object-oriented programming allows this close relationship to be codified in the language by making such functions \emph{class methods} of their related data type. 920 Class methods have certain privileges with respect to their associated data type, notably un-prefixed access to the fields of that data type. 921 When 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} 903 928 904 929 \section{Evaluation} … … 1013 1038 In 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. 1014 1039 The 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;1040 Until \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; 1016 1041 furthermore, \CC concepts are restricted to template polymorphism. 1017 1042 … … 1021 1046 In \CFA terms, all Cyclone polymorphism must be dtype-static. 1022 1047 While 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 syntaxand 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.1048 Smith 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 1050 Objective-C~\cite{obj-c-book} is an industrially successful extension to C. 1026 1051 However, Objective-C is a radical departure from C, using an object-oriented model with message-passing. 1027 1052 Objective-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;1053 The GObject~\cite{GObject} framework also adds object-oriented programming with runtime type-checking and reference-counting garbage-collection to C; 1029 1054 these 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.1055 Vala~\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. 1031 1056 Java~\cite{Java8} included generic types in Java~5, which are type-checked at compilation and type-erased at runtime, similar to \CFA's. 1032 1057 However, in Java, each object carries its own table of method pointers, while \CFA passes the method pointers separately to maintain a C-compatible layout. 1033 1058 Java is also a garbage-collected, object-oriented language, with the associated resource usage and C-interoperability burdens. 1034 1059 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.1060 D~\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. 1036 1061 However, 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. 1037 1062 D and Go are garbage-collected languages, imposing the associated runtime overhead. … … 1054 1079 \CCeleven introduced @std::tuple@ as a library variadic template structure. 1055 1080 Tuples 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 val es, @std::tie@ to create a tuple of references used for assignment, and lexicographic comparisons.1081 Operations include @std::get<N>@ to extract values, @std::tie@ to create a tuple of references used for assignment, and lexicographic comparisons. 1057 1082 \CCseventeen proposes \emph{structured bindings}~\cite{Sutter15} to eliminate pre-declaring variables and use of @std::tie@ for binding the results. 1058 1083 This 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. … … 1068 1093 The 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. 1069 1094 While 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 twolanguage features that illustrate the \CFA type-system and approaches taken to achieve the goal of evolutionary C extension.1095 The 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. 1071 1096 The contributions are a powerful type-system using parametric polymorphism and overloading, generic types, and tuples, which all have complex interactions. 1072 1097 The work is a challenging design, engineering, and implementation exercise. -
doc/theses/thierry_delisle/Makefile
r11b7028 r3ce0c915 98 98 fig2dev -L pstex_t -p ${Build}/$@ $< > ${Build}/$@_t 99 99 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 111 figures/%.tex: build/%.pstex 101 112 echo -n "\documentclass[preview]{standalone}\n" \ 102 113 "\usepackage[T1]{fontenc}\n" \ … … 110 121 "\end{document}" > $@ 111 122 112 %.png : %.pstex %.tex113 echo ${basename $@}114 ${LaTeX} figures/${basename $@}.tex115 dvips build/${basename $@}.dvi -o build/${basename $@}.ps116 ps2pdf build/${basename $@}.ps117 convert -negate ${basename $@}.pdf $@118 119 123 # Local Variables: # 120 124 # compile-command: "make" # -
src/benchmark/Makefile.am
r11b7028 r3ce0c915 23 23 STATS = ${TOOLSDIR}stat.py 24 24 repeats = 30 25 skipcompile = no 25 26 TIME_FORMAT = "%E" 26 27 PRINT_FORMAT = %20s: #Comments needed for spacing … … 43 44 %.runquiet : 44 45 @+make $(basename $@) 45 @ ./a.out46 @taskset -c 1 ./a.out 46 47 @rm -f a.out 47 48 … … 59 60 @echo -e '\t"githash": "'${githash}'",' 60 61 @echo -e '\t"arch": "' ${arch} '",' 62 @DOifskipcompile@ 61 63 @echo -e '\t"compile": {' 62 64 @+make compile TIME_FORMAT='%e,' PRINT_FORMAT='\t\t\"%s\" :' 63 65 @echo -e '\t\t"dummy" : {}' 64 66 @echo -e '\t},' 67 @DOendif@ 65 68 @echo -e '\t"ctxswitch": {' 66 69 @echo -en '\t\t"coroutine":' -
src/benchmark/Makefile.in
r11b7028 r3ce0c915 253 253 STATS = ${TOOLSDIR}stat.py 254 254 repeats = 30 255 skipcompile = no 255 256 TIME_FORMAT = "%E" 256 257 PRINT_FORMAT = %20s: #Comments needed for spacing … … 459 460 %.runquiet : 460 461 @+make $(basename $@) 461 @ ./a.out462 @taskset -c 1 ./a.out 462 463 @rm -f a.out 463 464 … … 473 474 @echo -e '\t"githash": "'${githash}'",' 474 475 @echo -e '\t"arch": "' ${arch} '",' 476 @DOifskipcompile@ 475 477 @echo -e '\t"compile": {' 476 478 @+make compile TIME_FORMAT='%e,' PRINT_FORMAT='\t\t\"%s\" :' 477 479 @echo -e '\t\t"dummy" : {}' 478 480 @echo -e '\t},' 481 @DOendif@ 479 482 @echo -e '\t"ctxswitch": {' 480 483 @echo -en '\t\t"coroutine":' -
src/driver/cfa.cc
r11b7028 r3ce0c915 10 10 // Created On : Tue Aug 20 13:44:49 2002 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : T ue Jan 30 15:46:15201813 // Update Count : 16 112 // Last Modified On : Thu Feb 1 22:26:10 2018 13 // Update Count : 163 14 14 // 15 15 … … 358 358 args[nargs] = "-D__int8_t_defined"; // prevent gcc type-size attributes 359 359 nargs += 1; 360 args[nargs] = "-D__NO_STRING_INLINES"; // prevent gcc strcmp unrolling361 nargs += 1;362 360 args[nargs] = ( *new string( string("-B") + Bprefix + "/" ) ).c_str(); 363 361 nargs += 1; -
src/libcfa/concurrency/kernel.c
r11b7028 r3ce0c915 59 59 60 60 volatile thread_local bool preemption_in_progress = 0; 61 volatile thread_local bool preemption_enabled = false; 61 62 volatile thread_local unsigned short disable_preempt_count = 1; 62 63 … … 196 197 if(readyThread) 197 198 { 198 verify( disable_preempt_count > 0);199 verify( !preemption_enabled ); 199 200 200 201 runThread(this, readyThread); 201 202 202 verify( disable_preempt_count > 0);203 verify( !preemption_enabled ); 203 204 204 205 //Some actions need to be taken from the kernel … … 242 243 void finishRunning(processor * this) with( this->finish ) { 243 244 if( action_code == Release ) { 244 verify( disable_preempt_count > 1);245 verify( !preemption_enabled ); 245 246 unlock( *lock ); 246 247 } … … 249 250 } 250 251 else if( action_code == Release_Schedule ) { 251 verify( disable_preempt_count > 1);252 verify( !preemption_enabled ); 252 253 unlock( *lock ); 253 254 ScheduleThread( thrd ); 254 255 } 255 256 else if( action_code == Release_Multi ) { 256 verify( disable_preempt_count > lock_count);257 verify( !preemption_enabled ); 257 258 for(int i = 0; i < lock_count; i++) { 258 259 unlock( *locks[i] ); … … 286 287 this_coroutine = NULL; 287 288 this_thread = NULL; 289 preemption_enabled = false; 288 290 disable_preempt_count = 1; 289 291 // SKULLDUGGERY: We want to create a context for the processor coroutine … … 333 335 verify( thrd->self_cor.state != Halted ); 334 336 335 verify( disable_preempt_count > 0);337 verify( !preemption_enabled ); 336 338 337 339 verifyf( thrd->next == NULL, "Expected null got %p", thrd->next ); … … 343 345 } 344 346 345 verify( disable_preempt_count > 0);347 verify( !preemption_enabled ); 346 348 } 347 349 348 350 thread_desc * nextThread(cluster * this) with( *this ) { 349 verify( disable_preempt_count > 0);351 verify( !preemption_enabled ); 350 352 lock( ready_queue_lock __cfaabi_dbg_ctx2 ); 351 353 thread_desc * head = pop_head( ready_queue ); 352 354 unlock( ready_queue_lock ); 353 verify( disable_preempt_count > 0);355 verify( !preemption_enabled ); 354 356 return head; 355 357 } … … 357 359 void BlockInternal() { 358 360 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 ); 362 364 enable_interrupts( __cfaabi_dbg_ctx ); 363 365 } … … 368 370 this_processor->finish.lock = lock; 369 371 370 verify( disable_preempt_count > 1);371 suspend(); 372 verify( disable_preempt_count > 0);372 verify( !preemption_enabled ); 373 suspend(); 374 verify( !preemption_enabled ); 373 375 374 376 enable_interrupts( __cfaabi_dbg_ctx ); … … 380 382 this_processor->finish.thrd = thrd; 381 383 382 verify( disable_preempt_count > 0);383 suspend(); 384 verify( disable_preempt_count > 0);384 verify( !preemption_enabled ); 385 suspend(); 386 verify( !preemption_enabled ); 385 387 386 388 enable_interrupts( __cfaabi_dbg_ctx ); … … 394 396 this_processor->finish.thrd = thrd; 395 397 396 verify( disable_preempt_count > 1);397 suspend(); 398 verify( disable_preempt_count > 0);398 verify( !preemption_enabled ); 399 suspend(); 400 verify( !preemption_enabled ); 399 401 400 402 enable_interrupts( __cfaabi_dbg_ctx ); … … 407 409 this_processor->finish.lock_count = count; 408 410 409 verify( disable_preempt_count > 0);410 suspend(); 411 verify( disable_preempt_count > 0);411 verify( !preemption_enabled ); 412 suspend(); 413 verify( !preemption_enabled ); 412 414 413 415 enable_interrupts( __cfaabi_dbg_ctx ); … … 422 424 this_processor->finish.thrd_count = thrd_count; 423 425 424 verify( disable_preempt_count > 0);425 suspend(); 426 verify( disable_preempt_count > 0);426 verify( !preemption_enabled ); 427 suspend(); 428 verify( !preemption_enabled ); 427 429 428 430 enable_interrupts( __cfaabi_dbg_ctx ); … … 430 432 431 433 void LeaveThread(__spinlock_t * lock, thread_desc * thrd) { 432 verify( disable_preempt_count > 0);434 verify( !preemption_enabled ); 433 435 this_processor->finish.action_code = thrd ? Release_Schedule : Release; 434 436 this_processor->finish.lock = lock; -
src/libcfa/concurrency/kernel_private.h
r11b7028 r3ce0c915 74 74 75 75 extern volatile thread_local bool preemption_in_progress; 76 extern volatile thread_local bool preemption_enabled; 76 77 extern volatile thread_local unsigned short disable_preempt_count; 77 78 -
src/libcfa/concurrency/monitor.c
r11b7028 r3ce0c915 87 87 thread_desc * thrd = this_thread; 88 88 89 verify( disable_preempt_count > 0 );90 91 89 __cfaabi_dbg_print_safe("Kernel : %10p Entering mon %p (%p)\n", thrd, this, this->owner); 92 90 … … 117 115 // Some one else has the monitor, wait in line for it 118 116 append( this->entry_queue, thrd ); 119 120 verify( disable_preempt_count > 0 );121 117 122 118 BlockInternal( &this->lock ); … … 396 392 append( this.blocked, &waiter ); 397 393 398 verify( disable_preempt_count == 0 );399 400 394 // Lock all monitors (aggregates the locks as well) 401 395 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"); }405 396 406 397 // Find the next thread(s) to run … … 477 468 monitor_ctx( this.monitors, this.monitor_count ); 478 469 479 verify( disable_preempt_count == 0 );480 481 470 // Lock all monitors (aggregates the locks them as well) 482 471 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"); }486 472 487 473 -
src/libcfa/concurrency/preemption.c
r11b7028 r3ce0c915 49 49 // Machine specific register name 50 50 #if defined(__x86_64__) 51 #define CFA_REG_IP REG_RIP51 #define CFA_REG_IP gregs[REG_RIP] 52 52 #elif defined(__i386__) 53 #define CFA_REG_IP REG_EIP53 #define CFA_REG_IP gregs[REG_EIP] 54 54 #elif defined(__ARM_ARCH__) 55 #define CFA_REG_IP REG_R1555 #define CFA_REG_IP arm_pc 56 56 #endif 57 57 … … 142 142 // Disable interrupts by incrementing the counter 143 143 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; 145 147 verify( new_val < 65_000u ); // If this triggers someone is disabling interrupts without enabling them 146 148 } … … 152 154 thread_desc * thrd = this_thread; // Cache the thread now since interrupts can start happening after the atomic add 153 155 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; 155 158 verify( prev != 0u ); // If this triggers someone is enabled already enabled interruptsverify( prev != 0u ); 156 159 157 160 // 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 } 161 167 } 162 168 … … 168 174 // Don't execute any pending CtxSwitch even if counter reaches 0 169 175 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; 171 178 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 } 172 182 } 173 183 } … … 210 220 // If false : preemption is unsafe and marked as pending 211 221 static inline bool preemption_ready() { 212 bool ready = disable_preempt_count == 0&& !preemption_in_progress; // Check if preemption is safe222 bool ready = preemption_enabled && !preemption_in_progress; // Check if preemption is safe 213 223 this_processor->pending_preemption = !ready; // Adjust the pending flag accordingly 214 224 return ready; … … 225 235 226 236 // Start with preemption disabled until ready 237 preemption_enabled = false; 227 238 disable_preempt_count = 1; 228 239 … … 284 295 // Receives SIGUSR1 signal and causes the current thread to yield 285 296 void 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 293 300 if( !preemption_ready() ) { return; } 294 301
Note: See TracChangeset
for help on using the changeset viewer.