Changes in / [c25202b:0982b3ec]


Ignore:
Files:
11 edited

Legend:

Unmodified
Added
Removed

  • Jenkins/FullBuild

    rc25202b r0982b3ec  
    2626                                        gcc_11_x64_new: { trigger_build( 'gcc-11',  'x64', false ) },
    2727//                                      gcc_12_x64_new: { trigger_build( 'gcc-12',  'x64', false ) },
    28                                         gcc_14_x64_new: { trigger_build( 'gcc-14',  'x64', false ) },
    29                                         gcc_10_arm64_new: { trigger_build( 'gcc-10', 'arm64', false ) },
    30                                         gcc_11_arm64_new: { trigger_build( 'gcc-11', 'arm64', false ) },
     28//                                      gcc_10_arm64_new: { trigger_build( 'gcc-10', 'arm64', false ) },
     29//                                      gcc_11_arm64_new: { trigger_build( 'gcc-11', 'arm64', false ) },
    3130                                        //gcc_12_arm64_new: { trigger_build( 'gcc-12', 'arm64', false ) },
    3231                                        clang_x64_new:  { trigger_build( 'clang',   'x64', true  ) },

  • Jenkinsfile

    rc25202b r0982b3ec  
    332332                                this.Architecture = new Arch_Desc('x86', '--host=i386', 'x86')
    333333                        break
    334                         case 'arm64':
    335                                 this.Architecture = new Arch_Desc('arm64', '--host=aarch64', 'arm64')
    336                         break
     334//                      case 'arm64':
     335//                              this.Architecture = new Arch_Desc('arm64', '--host=aarch64', 'arm64')
     336//                      break
    337337                        default :
    338338                                error "Unhandled architecture : ${arch}"

  • doc/bibliography/pl.bib

    rc25202b r0982b3ec  
    92929292}
    92939293
    9294 @inproceedings{valgrind,
     9294@inproceedings{valgind,
    92959295    keywords    = {Memcheck, Valgrind, dynamic binary analysis, dynamic binary instrumentation, shadow values},
    92969296    contributer = {pabuhr@plg},

  • doc/uC++toCFA/uC++toCFA.tex

    rc25202b r0982b3ec  
    1111%% Created On       : Wed Apr  6 14:53:29 2016
    1212%% Last Modified By : Peter A. Buhr
    13 %% Last Modified On : Fri Feb 20 11:19:31 2026
    14 %% Update Count     : 6717
     13%% Last Modified On : Mon Nov 17 11:14:48 2025
     14%% Update Count     : 6677
    1515%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    1616
    … …  
    194194
    195195The @choose@ statement provides an implicit @break@ after the @case@ clause for safety.
    196 It is possible to @fallthrough@ label in a @case@ clause to transfer to common code or the @default@ clause.
    197 \begin{cquote}
    198 \begin{tabular}{@{}l|l@{}}
    199 \begin{cfa}
     196It is possible to @break default@ in a @case@ clause to transfer to common code in the @default@ clause.
     197\begin{cquote}
     198\begin{tabular}{@{}l|l@{}}
     199\begin{uC++}
    200200switch ( i ) {
    201   case 3: ... @fallthrough common@;
    202   case 2: if ( ... ) @fallthrough@;
    203   case 1:
    204   common: ... ; // implicit fall through
     201  case 1: ... @break@; // explicit break
     202  case 2: ... @break@; // explicit break
    205203  default: ... ;
    206204}
    207 \end{cfa}
     205\end{uC++}
    208206&
    209207\begin{cfa}
    210208choose ( i ) {
    211   case 3: ... @fallthrough common@; // labelled explicit fallthrough
    212   case 2: if ( ... ) @fallthrough@; // conditional explicit fallthrough
    213   case 1:
    214   common: ... ; // implicit break
     209  case 1: ... ; // implicit break
     210  case 2: ... ; // implicit break
    215211  default: ... ;
    216212}
    … …  
    254250for ( i; @5@ ~ @15@ ~ @2@ ) { ... } // 5 to 14 by 2
    255251for ( i; -2 ~@=@ 10 ~ 3 ) { ... } // -2 to 10 by 3
    256 for ( i; -3 @-@~ 10 ) { ... } // 10 to -2 by -1, not 10 -~= -3
    257 for ( i; 0 @-@~@=@ 10 ) { ... } // 10 to 0 by -1, not 10 -~= 0
     252for ( i; -3 @-@~ 10 ) { ... } // not 10 -~= -3, 10 to -2 by -1
     253for ( i; 0 @-@~@=@ 10 ) { ... } // not 10 -~= 0, 10 to 0 by -1
    258254\end{cfa}
    259255\end{tabular}
    … …  
    912908  public:
    913909};
    914 T t;
    915 uProcessor p[3];
    916910\end{uC++}
    917911&
    … …  
    923917};
    924918void main( @T & t@ ) {
    925         ... @resumeAt( partner, ExceptionInst( E, ... ) )@;
     919        ... @resumeAt( partner, ExceptionInst( E, ... )@ );
    926920        ... @active_thread();@ ...
    927921}
    928 T t;  // create thread object and start thread in main
    929 processor p[3]; // 4 kernel threads including program main
    930 \end{cfa}
     922\end{cfa}
     923\\
     924\multicolumn{2}{@{}l@{}}{\lstinline{T t; // start thread in main routine}}
    931925\end{tabular}
    932926\end{cquote}
    … …  
    10151009        }
    10161010};
    1017 Barrier b{ 3 };
     1011enum { N = 3 };
     1012Barrier b{ N };
    10181013\end{uC++}
    10191014&
    … …  
    10391034        }
    10401035}
    1041 Barrier b{ 3 };
     1036enum { N = 3 };
     1037Barrier b{ N };
    10421038\end{cfa}
    10431039\end{tabular}
    … …  
    11821178
    11831179
    1184 {\lstset{tabsize=4}
     1180{\lstset{tabsize=3}
    11851181\setlength{\tabcolsep}{5pt}
    11861182\begin{tabular}{@{}l|ll@{}}
    … …  
    11901186@Future_ISM@<double> fd;
    11911187struct Msg { int i, j; }; @Future_ISM@<Msg> fm;
     1188struct Stop {}; @Future_ISM@<Stop> fs;
    11921189struct Cont {}; @Future_ISM@<Cont> fc;
    1193 _Exception Stop {};
    11941190
    11951191_Task Worker {
    11961192        void main() {
    1197                 try {
    1198                         for ( ;; ) {
    1199                                 _Select( fi ) { cout << fi() << endl; fi.reset(); }
    1200                                 and _Select( fd ) { cout << fd() << endl; fd.reset(); }
    1201                                 and _Select( fm ) {
    1202                                         cout << fm().i << " " << fm().j << endl; fm.reset();
    1203                                 }
    1204                                 fc( (Cont){} );         // synchronize
    1205                         }
    1206                 } catch( Stop & ) { cout << "stop" << endl;}
    1207         }
     1193
     1194                for ( ;; ) {
     1195                        _Select( fi ) { cout << fi() << endl; fi.reset(); }
     1196                        and _Select( fd ) { cout << fd() << endl; fd.reset(); }
     1197                        and _Select( fm ) {
     1198                                cout << fm().i << " " << fm().j << endl; fm.reset();
     1199                        } or _Select( fs ) { cout << "stop" << endl; break; }
     1200                        fc.delivery( (Cont){} );        // synchronize
     1201                }
     1202        }
     1203
    12081204};
    12091205int main() {
    12101206        Worker worker;
    12111207        for ( int i = 0; i < 10; i += 1 ) {
    1212                 fi( i );   fd( i + 2.5 );   fm( (Msg){ i, 2 } );  // fulfil
     1208                fi( i );   fd( i + 2.5 );   fm( (Msg){ i, 2 } ); // fulfil
    12131209                fc(); fc.reset();                               // synchronize
    12141210        }
    1215         fi( new Stop{} );                               // trigger exception
     1211        fs( (Stop){} );
    12161212} // wait for worker to terminate
    12171213\end{uC++}
    … …  
    12191215\begin{cfa}
    12201216#include <future.hfa>
    1221 @future_rc@( int ) fi;
    1222 @future_rc@( double ) fd;
    1223 struct Msg { int i, j; }; @future_rc@( Msg ) fm;
    1224 struct Cont {}; @future_rc@( Cont ) fc;
    1225 ExceptionDecl( Stop );
    1226 
     1217@future_rc@(int) fi;
     1218@future_rc@(double) fd;
     1219struct Msg { int i, j; }; @future_rc@(Msg) fm;
     1220struct Stop {}; @future_rc@(Stop) fs;
     1221struct Cont {}; @future_rc@(Cont) fc;
     1222ExceptionDecl( Break );
    12271223thread Worker {};
    12281224void main( Worker & ) {
    … …  
    12311227                        waituntil( fi ) { sout | fi(); reset( fi ); }
    12321228                        and waituntil( fd ) { sout | fd(); reset( fd ); }
    1233                         and waituntil( fm ) {
    1234                                 sout | fm().i | fm().j; reset( fm );
     1229                        and waituntil( fm ) { sout | fm().i | fm().j; reset( fm ); }
     1230                        or waituntil( fs ) { sout | "stop";
     1231                                throw ExceptionInst( Break );
    12351232                        }
    12361233                        fc( (Cont){} );         // synchronize
    12371234                }
    1238         } catch( Stop * ) { sout | "stop"; }
    1239 }
    1240 
     1235        } catch( Break * ) {}
     1236}
    12411237int main() {
    12421238        Worker worker;
    12431239        for ( i; 10 ) {
    1244                 fi( i );   fd( i + 2.5 );   fm( (Msg){ i, 2 } );  // fulfil
     1240                fi( i );   fd( i + 2.5 );   fm( (Msg){ i, 2 } ); // fulfil
    12451241                fc(); reset( fc );              // synchronize
    12461242        }
    1247         fi( ExceptionPtr( ExceptionInst( Stop ) ) );
     1243        fs( (Stop){} );
    12481244} // wait for worker to terminate
    12491245\end{cfa}

  • libcfa/src/concurrency/cofor.cfa

    rc25202b r0982b3ec  
    4444        }
    4545}
     46
     47

  • libcfa/src/concurrency/coroutine.cfa

    rc25202b r0982b3ec  
    1010// Created On       : Mon Nov 28 12:27:26 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Mar  1 17:36:41 2026
    13 // Update Count     : 115
     12// Last Modified On : Fri Apr 25 06:48:19 2025
     13// Update Count     : 31
    1414//
    1515
    … …  
    326326void ^?{}( ehm_cleanup & this ) { free( this.ex ); }
    327327
    328 void * stack_pointer( coroutine$ * cor ) libcfa_public {
    329         if ( active_coroutine() == cor ) {                                      // accessing myself ?
    330                 void * sp;                                                                              // use my current stack value
    331                 #if defined( __i386__ )
    332                 asm( "movl %%esp,%0" : "=m" (sp) : );
    333                 #elif defined( __x86_64__ )
    334                 asm( "movq %%rsp,%0" : "=m" (sp) : );
    335                 #elif defined( __arm_64__ )
    336                 asm( "mov x9, sp; str x9,%0" : "=m" (sp) : : "x9" );
    337                 #else
    338                         #error Cforall : internal error, unsupported architecture
    339                 #endif
    340                 return sp;
    341         } else {                                                                                        // accessing another coroutine
    342                 return cor->context.SP;
    343         } // if
    344 } // stackPointer
    345 
    346 void * stack_pointer() libcfa_public { return stack_pointer( active_coroutine() ); }
    347 
    348 #define xstr(s) str(s)
    349 #define str(s) #s
    350 #define STACK_ERROR 4
    351 #define STACK_WARNING 16
    352 
    353 void stack_verify( coroutine$ * cor ) libcfa_public {
    354         void * sp = stack_pointer( cor );                                       // optimizations
    355         struct __stack_t * cor_stack = __get_stack( cor );
    356         void * safelimit = (void *)((char *)cor_stack->limit + STACK_ERROR * 1024); // space needed for printing abort message and backtrace
    357 
    358         if ( sp < safelimit ) {                                                         // must leave stack space to call abort
    359                 abort( "Stack overflow detected: stack pointer %p below safe limit %p.\n"
    360                            "Possible cause is allocation of large stack frame(s) and/or deep call stack.",
    361                            sp, safelimit );
    362         } else if ( sp < (void *)((char *)cor_stack->limit + STACK_WARNING * 1024) ) { // must leave stack space to call abort
    363                 #define STACK_WARNING_MSG "Cforall Runtime warning : within " xstr(STACK_WARNING) "K of stack limit.\n"
    364                 __cfaabi_bits_write( STDERR_FILENO, STACK_WARNING_MSG, sizeof( STACK_WARNING_MSG ) - 1 );
    365         } else if ( sp > cor_stack->base ) {
    366                 abort( "Stack underflow detected: stack pointer %p above base %p.\n"
    367                            "Possible cause is corrupted stack frame via overwriting memory.",
    368                            sp, cor_stack->base );
    369         } // if
    370 } // verify
    371 
    372 void stack_verify() libcfa_public { return stack_verify( active_coroutine() ); }
    373 
    374328bool poll( coroutine$ * cor ) libcfa_public {
    375329        nonlocal_exception * nl_ex = pop_ehm_head( cor );
    … …  
    397351// user facing ehm operations
    398352forall(T & | is_coroutine(T)) {
    399         void * stack_pointer( T & cor ) libcfa_public { return stack_pointer( get_coroutine( cor ) ); }
    400         void stack_verify( T & cor ) libcfa_public { return stack_verify( get_coroutine( cor ) ); }
    401 
    402353        // enable/disable non-local exceptions
    403354        void enable_ehm( T & cor ) libcfa_public { get_coroutine( cor )->ehm_state.ehm_enabled = true; }

  • libcfa/src/concurrency/coroutine.hfa

    rc25202b r0982b3ec  
    1010// Created On       : Mon Nov 28 12:27:26 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Mar  1 17:44:11 2026
    13 // Update Count     : 43
     12// Last Modified On : Fri Apr 25 06:52:04 2025
     13// Update Count     : 15
    1414//
    1515
    … …  
    9898}
    9999
    100 void stack_verify( coroutine$ * cor );
    101 void stack_verify();
    102 
    103100// Private wrappers for context switch and stack creation
     101// Wrapper for co
    104102static inline void $ctx_switch( coroutine$ * src, coroutine$ * dst ) __attribute__((nonnull (1, 2))) {
    105103        // set state of current coroutine to inactive
    … …  
    112110        /* paranoid */ verify( !athrd->corctx_flag );
    113111        athrd->corctx_flag = true;
    114 
    115         #if defined( __CFA_DEBUG__ )
    116         stack_verify( src );                                                            // test on front side of context switch, backside is too late.
    117         #endif // __CFA_DEBUG__
    118112
    119113        // set new coroutine that task is executing
    … …  
    231225
    232226// non local ehm and coroutine utility routines
    233 void * stack_pointer( coroutine$ * cor );
    234 void * stack_pointer();
    235227void enable_ehm();
    236228void disable_ehm();
    … …  
    242234
    243235forall(T & | is_coroutine(T)) {
    244         void * stack_pointer( T & cor );
    245         void stack_verify( T & cor );
    246236    void enable_ehm( T & cor );         // enable checking non-local exceptions for cor via checked_poll
    247237    void disable_ehm( T & cor );        // disable checking non-local exceptions for cor via checked_poll

  • libcfa/src/concurrency/invoke.h

    rc25202b r0982b3ec  
    1010// Created On       : Tue Jan 17 12:27:26 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Mar  1 15:43:17 2026
    13 // Update Count     : 70
     12// Last Modified On : Fri Oct 31 08:46:59 2025
     13// Update Count     : 67
    1414//
    1515
    … …  
    3131#define _INVOKE_H_
    3232
    33         enum { DEFAULT_STACK_SIZE = 256000 };                           // raised from 65000
     33        enum { DEFAULT_STACK_SIZE = 65000 };
    3434
    3535        struct __cfaehm_try_resume_node;

  • libcfa/src/concurrency/kernel/startup.cfa

    rc25202b r0982b3ec  
    474474//-----------------------------------------------------------------------------
    475475// Main thread construction
    476 static void ?{}( coroutine$ & this, current_stack_info_t * info ) with( this ) {
     476static void ?{}( coroutine$ & this, current_stack_info_t * info) with( this ) {
    477477        stack.storage = info->storage;
    478478        with(*stack.storage) {
    … …  
    485485        state = Start;
    486486        starter = 0p;
    487         this.last = 0p;                                                                         // "last" overloaded in scope => qualification
     487        this.last = 0p;
    488488        cancellation = 0p;
    489489        ehm_state.ehm_buffer{};
    … …  
    492492}
    493493
    494 static void ?{}( thread$ & this, current_stack_info_t * info ) with( this ) {
     494static void ?{}( thread$ & this, current_stack_info_t * info) with( this ) {
    495495        ticket = TICKET_RUNNING;
    496496        state = Start;

  • libcfa/src/concurrency/preemption.cfa

    rc25202b r0982b3ec  
    1010// Created On       : Mon Jun 5 14:20:42 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Mar  1 10:00:18 2026
    13 // Update Count     : 68
     12// Last Modified On : Fri Apr 25 07:24:39 2025
     13// Update Count     : 63
    1414//
    1515
    … …  
    571571        __cfaabi_dbg_print_buffer_decl( " KERNEL: preempting core %p (%p @ %p).\n", __cfaabi_tls.this_processor, __cfaabi_tls.this_thread, (void *)(cxt->uc_mcontext.CFA_REG_IP) );
    572572
    573         #if defined( __CFA_DEBUG__ )
    574         stack_verify();                                                                         // good place to check for stack overflow
    575         #endif // __CFA_DEBUG__
    576 
    577573        // Sync flag : prevent recursive calls to the signal handler
    578574        __cfaabi_tls.preemption_state.in_progress = true;
    … …  
    595591        #endif
    596592
    597         force_yield( __ALARM_PREEMPTION );                                      // Do the actual __cfactx_switch
     593        force_yield( __ALARM_PREEMPTION ); // Do the actual __cfactx_switch
    598594}
    599595

  • libcfa/src/stdhdr/math.h

    rc25202b r0982b3ec  
    1010// Created On       : Mon Jul  4 23:25:26 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Feb  8 22:03:48 2026
    13 // Update Count     : 25
     12// Last Modified On : Fri Jun  6 06:35:49 2025
     13// Update Count     : 24
    1414//
    1515
    1616extern "C" {
     17#if ! defined( exception )                                                              // nesting ?
     18//#define exception ``exception                                                 // make keyword an identifier
     19#define __CFA_MATH_H__
     20#endif
     21
    1722#include_next <math.h>                                                                  // has internal check for multiple expansion
     23
     24#if defined( exception ) && defined( __CFA_MATH_H__ )   // reset only if set
     25//#undef exception
     26#undef __CFA_MATH_H__
     27#endif
    1828} // extern "C"
    1929
Note: See TracChangeset for help on using the changeset viewer.