Changeset 45c43e5 for src


Ignore:
Timestamp:
Feb 26, 2018, 12:49:55 PM (8 years ago)
Author:
Rob Schluntz <rschlunt@…>
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:
eddb399
Parents:
17fc7a5 (diff), 2c39855 (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

Location:
src
Files:
2 added
21 edited

Legend:

Unmodified
Added
Removed

  • src/Parser/DeclarationNode.cc

    r17fc7a5 r45c43e5  
    1010// Created On       : Sat May 16 12:34:05 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Nov 20 09:21:52 2017
    13 // Update Count     : 1031
     12// Last Modified On : Thu Feb 22 15:37:17 2018
     13// Update Count     : 1033
    1414//
    1515
    … …  
    120120} // DeclarationNode::clone
    121121
    122 bool DeclarationNode::get_hasEllipsis() const {
    123         return hasEllipsis;
    124 }
    125 
    126122void DeclarationNode::print( std::ostream &os, int indent ) const {
    127123        os << string( indent, ' ' );
    … …  
    167163}
    168164
    169 DeclarationNode * DeclarationNode::newFunction( string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body, bool newStyle ) {
     165DeclarationNode * DeclarationNode::newFunction( string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body ) {
    170166        DeclarationNode * newnode = new DeclarationNode;
    171167        newnode->name = name;
    172168        newnode->type = new TypeData( TypeData::Function );
    173169        newnode->type->function.params = param;
    174         newnode->type->function.newStyle = newStyle;
    175170        newnode->type->function.body = body;
    176171

  • src/Parser/ParseNode.h

    r17fc7a5 r45c43e5  
    1010// Created On       : Sat May 16 13:28:16 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Nov 27 17:33:35 2017
    13 // Update Count     : 824
     12// Last Modified On : Thu Feb 22 17:49:31 2018
     13// Update Count     : 827
    1414//
    1515
    … …  
    209209        enum Length { Short, Long, LongLong, NoLength };
    210210        static const char * lengthNames[];
    211         enum Aggregate { Struct, Union, Trait, Coroutine, Monitor, Thread, NoAggregate };
     211        enum Aggregate { Struct, Union, Exception, Trait, Coroutine, Monitor, Thread, NoAggregate };
    212212        static const char * aggregateNames[];
    213213        enum TypeClass { Otype, Dtype, Ftype, Ttype, NoTypeClass };
    … …  
    226226        static DeclarationNode * newForall( DeclarationNode * );
    227227        static DeclarationNode * newFromTypedef( std::string * );
    228         static DeclarationNode * newFunction( std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body, bool newStyle = false );
     228        static DeclarationNode * newFunction( std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body );
    229229        static DeclarationNode * newAggregate( Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body );
    230230        static DeclarationNode * newEnum( std::string * name, DeclarationNode * constants, bool body );
    … …  
    288288        Type * buildType() const;
    289289
    290         bool get_hasEllipsis() const;
    291290        LinkageSpec::Spec get_linkage() const { return linkage; }
    292291        DeclarationNode * extractAggregate() const;

  • src/Parser/TypeData.cc

    r17fc7a5 r45c43e5  
    1010// Created On       : Sat May 16 15:12:51 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Sep 25 18:33:41 2017
    13 // Update Count     : 587
     12// Last Modified On : Thu Feb 22 15:49:00 2018
     13// Update Count     : 597
    1414//
    1515
    … …  
    5454                function.oldDeclList = nullptr;
    5555                function.body = nullptr;
    56                 function.newStyle = false;
    5756                function.withExprs = nullptr;
    5857                break;
    … …  
    195194                newtype->function.oldDeclList = maybeClone( function.oldDeclList );
    196195                newtype->function.body = maybeClone( function.body );
    197                 newtype->function.newStyle = function.newStyle;
    198196                newtype->function.withExprs = maybeClone( function.withExprs );
    199197                break;
    … …  
    881879FunctionType * buildFunction( const TypeData * td ) {
    882880        assert( td->kind == TypeData::Function );
    883         bool hasEllipsis = td->function.params ? td->function.params->get_hasEllipsis() : true;
    884         if ( ! td->function.params ) hasEllipsis = ! td->function.newStyle;
    885         FunctionType * ft = new FunctionType( buildQualifiers( td ), hasEllipsis );
     881        FunctionType * ft = new FunctionType( buildQualifiers( td ), ! td->function.params || td->function.params->hasEllipsis );
    886882        buildList( td->function.params, ft->get_parameters() );
    887883        buildForall( td->forall, ft->get_forall() );

  • src/Parser/TypeData.h

    r17fc7a5 r45c43e5  
    1010// Created On       : Sat May 16 15:18:36 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Sep  1 23:33:45 2017
    13 // Update Count     : 190
     12// Last Modified On : Thu Feb 22 15:21:23 2018
     13// Update Count     : 191
    1414//
    1515
    … …  
    6464                mutable DeclarationNode * oldDeclList;
    6565                StatementNode * body;
    66                 bool newStyle;
    6766                ExpressionNode * withExprs;             // expressions from function's with_clause
    6867        };

  • src/Parser/lex.ll

    r17fc7a5 r45c43e5  
    1010 * Created On       : Sat Sep 22 08:58:10 2001
    1111 * Last Modified By : Peter A. Buhr
    12  * Last Modified On : Wed Oct 25 13:53:56 2017
    13  * Update Count     : 634
     12 * Last Modified On : Thu Feb 22 18:11:27 2018
     13 * Update Count     : 637
    1414 */
    1515
    … …  
    232232enum                    { KEYWORD_RETURN(ENUM); }
    233233__extension__   { KEYWORD_RETURN(EXTENSION); }                  // GCC
     234exception               { KEYWORD_RETURN(EXCEPTION); }                  // CFA
    234235extern                  { KEYWORD_RETURN(EXTERN); }
    235236fallthru                { KEYWORD_RETURN(FALLTHRU); }                   // CFA

  • src/Parser/parser.yy

    r17fc7a5 r45c43e5  
    1010// Created On       : Sat Sep  1 20:22:55 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb 15 17:12:31 2018
    13 // Update Count     : 3006
     12// Last Modified On : Thu Feb 22 17:48:54 2018
     13// Update Count     : 3028
    1414//
    1515
    … …  
    187187%token TYPEOF LABEL                                                                             // GCC
    188188%token ENUM STRUCT UNION
     189%token EXCEPTION                                                                                // CFA
    189190%token COROUTINE MONITOR THREAD                                                 // CFA
    190191%token OTYPE FTYPE DTYPE TTYPE TRAIT                                    // CFA
    … …  
    314315%type<decl> cfa_identifier_parameter_declarator_tuple cfa_identifier_parameter_ptr
    315316
    316 %type<decl> cfa_parameter_declaration cfa_parameter_list cfa_parameter_type_list cfa_parameter_type_list_opt
     317%type<decl> cfa_parameter_declaration cfa_parameter_list cfa_parameter_type_list_opt
    317318
    318319%type<decl> cfa_typedef_declaration cfa_variable_declaration cfa_variable_specifier
    … …  
    322323%type<decl> KR_declaration_list KR_declaration_list_opt
    323324
    324 %type<decl> parameter_declaration parameter_list parameter_type_list
    325 %type<decl> parameter_type_list_opt
     325%type<decl> parameter_declaration parameter_list parameter_type_list_opt
    326326
    327327%type<decl> paren_identifier paren_type
    … …  
    779779        | unary_expression assignment_operator assignment_expression
    780780                { $$ = new ExpressionNode( build_binary_val( $2, $1, $3 ) ); }
    781         | unary_expression '=' '{' initializer_list comma_opt '}' // FIX ME
    782                 { $$ = nullptr; }
     781        | unary_expression '=' '{' initializer_list comma_opt '}'
     782                { throw SemanticError( yylloc, "Initializer assignment is currently unimplemented." ); $$ = nullptr; } // FIX ME
    783783        ;
    784784
    … …  
    849849        | waitfor_statement
    850850        | exception_statement
     851        | enable_disable_statement
     852                { throw SemanticError( yylloc, "enable/disable statement is currently unimplemented." ); $$ = nullptr; } // FIX ME
    851853        | asm_statement
    852854        ;
    … …  
    10641066        | RETURN comma_expression_opt ';'
    10651067                { $$ = new StatementNode( build_return( $2 ) ); }
    1066         | RETURN '{' initializer_list comma_opt '}'                     // FIX ME
    1067                 { $$ = nullptr; }
     1068        | RETURN '{' initializer_list comma_opt '}'
     1069                { throw SemanticError( yylloc, "Initializer return is currently unimplemented." ); $$ = nullptr; } // FIX ME
    10681070        | THROW assignment_expression_opt ';'                           // handles rethrow
    10691071                { $$ = new StatementNode( build_throw( $2 ) ); }
    … …  
    11931195        ;
    11941196
     1197enable_disable_statement:
     1198        enable_disable_key identifier_list compound_statement
     1199        ;
     1200
     1201enable_disable_key:
     1202        ENABLE
     1203        | DISABLE
     1204        ;
     1205
    11951206asm_statement:
    11961207        ASM asm_volatile_opt '(' string_literal ')' ';'
    … …  
    13921403                        DeclarationNode * ret = new DeclarationNode;
    13931404                        ret->type = maybeClone( $1->type->base );
    1394                         $$ = $1->appendList( DeclarationNode::newFunction( $5, ret, $8, nullptr, true ) );
     1405                        $$ = $1->appendList( DeclarationNode::newFunction( $5, ret, $8, nullptr ) );
    13951406                }
    13961407        ;
    … …  
    14221433                // To obtain LR(1 ), this rule must be factored out from function return type (see cfa_abstract_declarator).
    14231434                {
    1424                         $$ = DeclarationNode::newFunction( $2, $1, $5, 0, true );
     1435                        $$ = DeclarationNode::newFunction( $2, $1, $5, 0 );
    14251436                }
    14261437        | cfa_function_return identifier_or_type_name '(' push cfa_parameter_type_list_opt pop ')'
    14271438                {
    1428                         $$ = DeclarationNode::newFunction( $2, $1, $5, 0, true );
     1439                        $$ = DeclarationNode::newFunction( $2, $1, $5, 0 );
    14291440                }
    14301441        ;
    … …  
    18811892        | UNION
    18821893                { $$ = DeclarationNode::Union; }
     1894        | EXCEPTION
     1895                { $$ = DeclarationNode::Exception; }
    18831896        | COROUTINE
    18841897                { $$ = DeclarationNode::Coroutine; }
    … …  
    19902003        ;
    19912004
    1992 // Minimum of one parameter after which ellipsis is allowed only at the end.
    1993 
    1994 cfa_parameter_type_list_opt:                                                    // CFA
     2005cfa_parameter_type_list_opt:                                                    // CFA, abstract + real
    19952006        // empty
     2007                { $$ = DeclarationNode::newBasicType( DeclarationNode::Void ); }
     2008        | ELLIPSIS
    19962009                { $$ = nullptr; }
    1997         | cfa_parameter_type_list
    1998         ;
    1999 
    2000 cfa_parameter_type_list:                                                                // CFA, abstract + real
    2001         cfa_abstract_parameter_list
     2010        | cfa_abstract_parameter_list
    20022011        | cfa_parameter_list
    20032012        | cfa_parameter_list pop ',' push cfa_abstract_parameter_list
    … …  
    20302039        // empty
    20312040                { $$ = nullptr; }
    2032         | parameter_type_list
    2033         ;
    2034 
    2035 parameter_type_list:
    2036         parameter_list
     2041        | ELLIPSIS
     2042                { $$ = nullptr; }
     2043        | parameter_list
    20372044        | parameter_list pop ',' push ELLIPSIS
    20382045                { $$ = $1->addVarArgs(); }

  • src/benchmark/bench.h

    r17fc7a5 r45c43e5  
    1010#if defined(__cforall)
    1111}
     12#include <bits/cfatime.h>
    1213#endif
     14
    1315
    1416static inline unsigned long long int Time() {
    … …  
    4547        ( EndTime - StartTime ) / n;
    4648
    47 unsigned int default_preemption() {
     49__cfa_time_t default_preemption() {
    4850        return 0;
    4951}

  • src/libcfa/Makefile.am

    r17fc7a5 r45c43e5  
    101101        gmp                             \
    102102        bits/align.h            \
     103        bits/cfatime.h          \
    103104        bits/containers.h               \
    104105        bits/defs.h             \

  • src/libcfa/Makefile.in

    r17fc7a5 r45c43e5  
    264264        concurrency/thread concurrency/kernel concurrency/monitor \
    265265        ${shell find stdhdr -type f -printf "%p "} math gmp \
    266         bits/align.h bits/containers.h bits/defs.h bits/debug.h \
    267         bits/locks.h concurrency/invoke.h
     266        bits/align.h bits/cfatime.h bits/containers.h bits/defs.h \
     267        bits/debug.h bits/locks.h concurrency/invoke.h
    268268HEADERS = $(nobase_cfa_include_HEADERS)
    269269am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
    … …  
    437437        gmp                             \
    438438        bits/align.h            \
     439        bits/cfatime.h          \
    439440        bits/containers.h               \
    440441        bits/defs.h             \

  • src/libcfa/bits/cfatime.h

    r17fc7a5 r45c43e5  
    4848// ctors
    4949static inline void ?{}( __cfa_time_t & this ) { this.val = 0; }
     50static inline void ?{}( __cfa_time_t & this, const __cfa_time_t & rhs ) { this.val = rhs.val; }
    5051static inline void ?{}( __cfa_time_t & this, zero_t zero ) { this.val = 0; }
    5152
    … …  
    9293static inline __cfa_time_t from_us ( uint64_t val ) { __cfa_time_t ret; ret.val = val *         1_000ul; return ret; }
    9394static inline __cfa_time_t from_ns ( uint64_t val ) { __cfa_time_t ret; ret.val = val *             1ul; return ret; }
     95
     96static inline uint64_t to_s  ( __cfa_time_t t ) { return t.val / 1_000_000_000ul; }
     97static inline uint64_t to_ms ( __cfa_time_t t ) { return t.val /     1_000_000ul; }
     98static inline uint64_t to_us ( __cfa_time_t t ) { return t.val /         1_000ul; }
     99static inline uint64_t to_ns ( __cfa_time_t t ) { return t.val /             1ul; }

  • src/libcfa/concurrency/coroutine.c

    r17fc7a5 r45c43e5  
    9999// Wrapper for co
    100100void CoroutineCtxSwitch(coroutine_desc* src, coroutine_desc* dst) {
    101         verify( preemption.enabled || this_processor->do_terminate );
     101        verify( preemption_state.enabled || this_processor->do_terminate );
    102102        disable_interrupts();
    103103
    … …  
    117117
    118118        enable_interrupts( __cfaabi_dbg_ctx );
    119         verify( preemption.enabled || this_processor->do_terminate );
     119        verify( preemption_state.enabled || this_processor->do_terminate );
    120120} //ctxSwitchDirect
    121121

  • src/libcfa/concurrency/kernel

    r17fc7a5 r45c43e5  
    1919
    2020#include "invoke.h"
     21#include "bits/cfatime.h"
    2122
    2223extern "C" {
    … …  
    4849
    4950        // Preemption rate on this cluster
    50         unsigned long long int preemption;
     51        __cfa_time_t preemption_rate;
    5152};
     53
     54extern __cfa_time_t default_preemption();
    5255
    5356void ?{} (cluster & this);

  • src/libcfa/concurrency/kernel.c

    r17fc7a5 r45c43e5  
    6060// volatile thread_local unsigned short disable_preempt_count = 1;
    6161
    62 volatile thread_local __cfa_kernel_preemption_data_t preemption = { false, false, 1 };
     62volatile thread_local __cfa_kernel_preemption_state_t preemption_state = { false, false, 1 };
    6363
    6464//-----------------------------------------------------------------------------
    … …  
    180180        ready_queue_lock{};
    181181
    182         preemption = default_preemption();
     182        preemption_rate = default_preemption();
    183183}
    184184
    … …  
    209209                        if(readyThread)
    210210                        {
    211                                 verify( !preemption.enabled );
     211                                verify( !preemption_state.enabled );
    212212
    213213                                runThread(this, readyThread);
    214214
    215                                 verify( !preemption.enabled );
     215                                verify( !preemption_state.enabled );
    216216
    217217                                //Some actions need to be taken from the kernel
    … …  
    262262void finishRunning(processor * this) with( this->finish ) {
    263263        if( action_code == Release ) {
    264                 verify( !preemption.enabled );
     264                verify( !preemption_state.enabled );
    265265                unlock( *lock );
    266266        }
    … …  
    269269        }
    270270        else if( action_code == Release_Schedule ) {
    271                 verify( !preemption.enabled );
     271                verify( !preemption_state.enabled );
    272272                unlock( *lock );
    273273                ScheduleThread( thrd );
    274274        }
    275275        else if( action_code == Release_Multi ) {
    276                 verify( !preemption.enabled );
     276                verify( !preemption_state.enabled );
    277277                for(int i = 0; i < lock_count; i++) {
    278278                        unlock( *locks[i] );
    … …  
    306306        this_coroutine = NULL;
    307307        this_thread = NULL;
    308         preemption.enabled = false;
    309         preemption.disable_count = 1;
     308        preemption_state.enabled = false;
     309        preemption_state.disable_count = 1;
    310310        // SKULLDUGGERY: We want to create a context for the processor coroutine
    311311        // which is needed for the 2-step context switch. However, there is no reason
    … …  
    351351        coroutine_desc * dst = get_coroutine(*this->runner);
    352352
    353         verify( !preemption.enabled );
     353        verify( !preemption_state.enabled );
    354354
    355355        create_stack(&dst->stack, dst->stack.size);
    356356        CtxStart(this->runner, CtxInvokeCoroutine);
    357357
    358         verify( !preemption.enabled );
     358        verify( !preemption_state.enabled );
    359359
    360360        dst->last = src;
    … …  
    382382        src->state = Active;
    383383
    384         verify( !preemption.enabled );
     384        verify( !preemption_state.enabled );
    385385}
    386386
    … …  
    392392        verify( thrd->self_cor.state != Halted );
    393393
    394         verify( !preemption.enabled );
     394        verify( !preemption_state.enabled );
    395395
    396396        verifyf( thrd->next == NULL, "Expected null got %p", thrd->next );
    … …  
    402402        }
    403403
    404         verify( !preemption.enabled );
     404        verify( !preemption_state.enabled );
    405405}
    406406
    407407thread_desc * nextThread(cluster * this) with( *this ) {
    408         verify( !preemption.enabled );
     408        verify( !preemption_state.enabled );
    409409        lock( ready_queue_lock __cfaabi_dbg_ctx2 );
    410410        thread_desc * head = pop_head( ready_queue );
    411411        unlock( ready_queue_lock );
    412         verify( !preemption.enabled );
     412        verify( !preemption_state.enabled );
    413413        return head;
    414414}
    … …  
    416416void BlockInternal() {
    417417        disable_interrupts();
    418         verify( !preemption.enabled );
     418        verify( !preemption_state.enabled );
    419419        returnToKernel();
    420         verify( !preemption.enabled );
     420        verify( !preemption_state.enabled );
    421421        enable_interrupts( __cfaabi_dbg_ctx );
    422422}
    … …  
    427427        this_processor->finish.lock        = lock;
    428428
    429         verify( !preemption.enabled );
     429        verify( !preemption_state.enabled );
    430430        returnToKernel();
    431         verify( !preemption.enabled );
     431        verify( !preemption_state.enabled );
    432432
    433433        enable_interrupts( __cfaabi_dbg_ctx );
    … …  
    439439        this_processor->finish.thrd        = thrd;
    440440
    441         verify( !preemption.enabled );
     441        verify( !preemption_state.enabled );
    442442        returnToKernel();
    443         verify( !preemption.enabled );
     443        verify( !preemption_state.enabled );
    444444
    445445        enable_interrupts( __cfaabi_dbg_ctx );
    … …  
    453453        this_processor->finish.thrd        = thrd;
    454454
    455         verify( !preemption.enabled );
     455        verify( !preemption_state.enabled );
    456456        returnToKernel();
    457         verify( !preemption.enabled );
     457        verify( !preemption_state.enabled );
    458458
    459459        enable_interrupts( __cfaabi_dbg_ctx );
    … …  
    466466        this_processor->finish.lock_count  = count;
    467467
    468         verify( !preemption.enabled );
     468        verify( !preemption_state.enabled );
    469469        returnToKernel();
    470         verify( !preemption.enabled );
     470        verify( !preemption_state.enabled );
    471471
    472472        enable_interrupts( __cfaabi_dbg_ctx );
    … …  
    481481        this_processor->finish.thrd_count  = thrd_count;
    482482
    483         verify( !preemption.enabled );
     483        verify( !preemption_state.enabled );
    484484        returnToKernel();
    485         verify( !preemption.enabled );
     485        verify( !preemption_state.enabled );
    486486
    487487        enable_interrupts( __cfaabi_dbg_ctx );
    … …  
    489489
    490490void LeaveThread(__spinlock_t * lock, thread_desc * thrd) {
    491         verify( !preemption.enabled );
     491        verify( !preemption_state.enabled );
    492492        this_processor->finish.action_code = thrd ? Release_Schedule : Release;
    493493        this_processor->finish.lock        = lock;
    … …  
    503503// Kernel boot procedures
    504504void kernel_startup(void) {
    505         verify( !preemption.enabled );
     505        verify( !preemption_state.enabled );
    506506        __cfaabi_dbg_print_safe("Kernel : Starting\n");
    507507
    … …  
    548548        __cfaabi_dbg_print_safe("Kernel : Started\n--------------------------------------------------\n\n");
    549549
    550         verify( !preemption.enabled );
     550        verify( !preemption_state.enabled );
    551551        enable_interrupts( __cfaabi_dbg_ctx );
    552         verify( preemption.enabled );
     552        verify( preemption_state.enabled );
    553553}
    554554
    … …  
    556556        __cfaabi_dbg_print_safe("\n--------------------------------------------------\nKernel : Shutting down\n");
    557557
    558         verify( preemption.enabled );
     558        verify( preemption_state.enabled );
    559559        disable_interrupts();
    560         verify( !preemption.enabled );
     560        verify( !preemption_state.enabled );
    561561
    562562        // SKULLDUGGERY: Notify the mainProcessor it needs to terminates.

  • src/libcfa/concurrency/kernel_private.h

    r17fc7a5 r45c43e5  
    7878// extern volatile thread_local unsigned short disable_preempt_count;
    7979
    80 struct __cfa_kernel_preemption_data_t {
     80struct __cfa_kernel_preemption_state_t {
    8181        bool enabled;
    8282        bool in_progress;
    … …  
    8484};
    8585
    86 extern volatile thread_local __cfa_kernel_preemption_data_t preemption;
     86extern volatile thread_local __cfa_kernel_preemption_state_t preemption_state;
    8787
    8888//-----------------------------------------------------------------------------

  • src/libcfa/concurrency/preemption.c

    r17fc7a5 r45c43e5  
    2323}
    2424
     25#include "bits/cfatime.h"
    2526#include "bits/signal.h"
    2627
    27 //TODO move to defaults
    28 #define __CFA_DEFAULT_PREEMPTION__ 10000
    29 
    30 //TODO move to defaults
    31 __attribute__((weak)) unsigned int default_preemption() {
     28#if !defined(__CFA_DEFAULT_PREEMPTION__)
     29#define __CFA_DEFAULT_PREEMPTION__ 10`cfa_ms
     30#endif
     31
     32__cfa_time_t default_preemption() __attribute__((weak)) {
    3233        return __CFA_DEFAULT_PREEMPTION__;
    3334}
    … …  
    149150        // Disable interrupts by incrementing the counter
    150151        void disable_interrupts() {
    151                 preemption.enabled = false;
    152                 __attribute__((unused)) unsigned short new_val = preemption.disable_count + 1;
    153                 preemption.disable_count = new_val;
     152                preemption_state.enabled = false;
     153                __attribute__((unused)) unsigned short new_val = preemption_state.disable_count + 1;
     154                preemption_state.disable_count = new_val;
    154155                verify( new_val < 65_000u );              // If this triggers someone is disabling interrupts without enabling them
    155156        }
    … …  
    161162                thread_desc * thrd = this_thread;         // Cache the thread now since interrupts can start happening after the atomic add
    162163
    163                 unsigned short prev = preemption.disable_count;
    164                 preemption.disable_count -= 1;
     164                unsigned short prev = preemption_state.disable_count;
     165                preemption_state.disable_count -= 1;
    165166                verify( prev != 0u );                     // If this triggers someone is enabled already enabled interruptsverify( prev != 0u );
    166167
    167168                // Check if we need to prempt the thread because an interrupt was missed
    168169                if( prev == 1 ) {
    169                         preemption.enabled = true;
     170                        preemption_state.enabled = true;
    170171                        if( proc->pending_preemption ) {
    171172                                proc->pending_preemption = false;
    … …  
    181182        // Don't execute any pending CtxSwitch even if counter reaches 0
    182183        void enable_interrupts_noPoll() {
    183                 unsigned short prev = preemption.disable_count;
    184                 preemption.disable_count -= 1;
     184                unsigned short prev = preemption_state.disable_count;
     185                preemption_state.disable_count -= 1;
    185186                verifyf( prev != 0u, "Incremented from %u\n", prev );                     // If this triggers someone is enabled already enabled interrupts
    186187                if( prev == 1 ) {
    187                         preemption.enabled = true;
     188                        preemption_state.enabled = true;
    188189                }
    189190        }
    … …  
    235236// If false : preemption is unsafe and marked as pending
    236237static inline bool preemption_ready() {
    237         bool ready = preemption.enabled && !preemption.in_progress; // Check if preemption is safe
     238        bool ready = preemption_state.enabled && !preemption_state.in_progress; // Check if preemption is safe
    238239        this_processor->pending_preemption = !ready;                        // Adjust the pending flag accordingly
    239240        return ready;
    … …  
    250251
    251252        // Start with preemption disabled until ready
    252         preemption.enabled = false;
    253         preemption.disable_count = 1;
     253        preemption_state.enabled = false;
     254        preemption_state.disable_count = 1;
    254255
    255256        // Initialize the event kernel
    … …  
    294295        this.proc->preemption_alarm = &this.alarm;
    295296
    296         update_preemption( this.proc, from_us(this.proc->cltr->preemption) );
     297        update_preemption( this.proc, this.proc->cltr->preemption_rate );
    297298}
    298299
    … …  
    330331        __cfaabi_dbg_print_buffer_decl( " KERNEL: preempting core %p (%p).\n", this_processor, this_thread);
    331332
    332         preemption.in_progress = true;                      // Sync flag : prevent recursive calls to the signal handler
     333        preemption_state.in_progress = true;                      // Sync flag : prevent recursive calls to the signal handler
    333334        signal_unblock( SIGUSR1 );                          // We are about to CtxSwitch out of the signal handler, let other handlers in
    334         preemption.in_progress = false;                     // Clear the in progress flag
     335        preemption_state.in_progress = false;                     // Clear the in progress flag
    335336
    336337        // Preemption can occur here

  • src/libcfa/concurrency/preemption.h

    r17fc7a5 r45c43e5  
    1919#include "kernel_private.h"
    2020
    21 __attribute__((weak)) unsigned int default_preemption();
    2221void kernel_start_preemption();
    2322void kernel_stop_preemption();

  • src/libcfa/concurrency/thread.c

    r17fc7a5 r45c43e5  
    9898
    9999void yield( void ) {
    100         verify( preemption.enabled );
     100        verify( preemption_state.enabled );
    101101        BlockInternal( this_thread );
    102         verify( preemption.enabled );
     102        verify( preemption_state.enabled );
    103103}
    104104

  • src/libcfa/exception.c

    r17fc7a5 r45c43e5  
    1010// Created On       : Mon Jun 26 15:13:00 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Feb  9 14:41:55 2018
    13 // Update Count     : 8
     12// Last Modified On : Thu Feb 22 18:17:34 2018
     13// Update Count     : 11
    1414//
    1515
    … …  
    5252    struct __cfaabi_ehm__try_resume_node * current_resume;
    5353
    54     exception * current_exception;
     54    exception_t * current_exception;
    5555    int current_handler_index;
    5656} shared_stack = {NULL, NULL, 0, 0};
    … …  
    7171// This macro should be the only thing that needs to change across machines.  Used in the personality function, way down
    7272// in termination.
    73 // struct _Unwind_Context * -> _Unwind_Reason_Code(*)(exception *)
     73// struct _Unwind_Context * -> _Unwind_Reason_Code(*)(exception_t *)
    7474#define MATCHER_FROM_CONTEXT(ptr_to_context) \
    75         (*(_Unwind_Reason_Code(**)(exception*))(_Unwind_GetCFA(ptr_to_context) + 8))
     75        (*(_Unwind_Reason_Code(**)(exception_t *))(_Unwind_GetCFA(ptr_to_context) + 8))
    7676
    7777
    7878// RESUMPTION ================================================================
    7979
    80 void __cfaabi_ehm__throw_resume(exception * except) {
     80void __cfaabi_ehm__throw_resume(exception_t * except) {
    8181
    8282        __cfaabi_dbg_print_safe("Throwing resumption exception\n");
    … …  
    106106
    107107void __cfaabi_ehm__try_resume_setup(struct __cfaabi_ehm__try_resume_node * node,
    108                         _Bool (*handler)(exception * except)) {
     108                        _Bool (*handler)(exception_t * except)) {
    109109        node->next = shared_stack.top_resume;
    110110        node->handler = handler;
    … …  
    126126};
    127127
    128 #define NODE_TO_EXCEPT(node) ((exception *)(1 + (node)))
     128#define NODE_TO_EXCEPT(node) ((exception_t *)(1 + (node)))
    129129#define EXCEPT_TO_NODE(except) ((struct __cfaabi_ehm__node *)(except) - 1)
    130130
    131131// Creates a copy of the indicated exception and sets current_exception to it.
    132 static void __cfaabi_ehm__allocate_exception( exception * except ) {
     132static void __cfaabi_ehm__allocate_exception( exception_t * except ) {
    133133        struct exception_context_t * context = this_exception_context();
    134134
    … …  
    151151
    152152// Delete the provided exception, unsetting current_exception if relivant.
    153 static void __cfaabi_ehm__delete_exception( exception * except ) {
     153static void __cfaabi_ehm__delete_exception( exception_t * except ) {
    154154        struct exception_context_t * context = this_exception_context();
    155155
    … …  
    179179// If this isn't a rethrow (*except==0), delete the provided exception.
    180180void __cfaabi_ehm__cleanup_terminate( void * except ) {
    181         if ( *(void**)except ) __cfaabi_ehm__delete_exception( *(exception**)except );
     181        if ( *(void**)except ) __cfaabi_ehm__delete_exception( *(exception_t **)except );
    182182}
    183183
    … …  
    233233}
    234234
    235 void __cfaabi_ehm__throw_terminate( exception * val ) {
     235void __cfaabi_ehm__throw_terminate( exception_t * val ) {
    236236        __cfaabi_dbg_print_safe("Throwing termination exception\n");
    237237
    … …  
    348348                                        // _Unwind_Reason_Code (*matcher)() = (_Unwind_Reason_Code (*)())lsd_info.LPStart + imatcher;
    349349
    350                                         _Unwind_Reason_Code (*matcher)(exception *) =
     350                                        _Unwind_Reason_Code (*matcher)(exception_t *) =
    351351                                                MATCHER_FROM_CONTEXT(context);
    352352                                        int index = matcher(shared_stack.current_exception);
    … …  
    409409__attribute__((noinline))
    410410void __cfaabi_ehm__try_terminate(void (*try_block)(),
    411                 void (*catch_block)(int index, exception * except),
    412                 __attribute__((unused)) int (*match_block)(exception * except)) {
     411                void (*catch_block)(int index, exception_t * except),
     412                __attribute__((unused)) int (*match_block)(exception_t * except)) {
    413413        //! volatile int xy = 0;
    414414        //! printf("%p %p %p %p\n", &try_block, &catch_block, &match_block, &xy);

  • src/libcfa/exception.h

    r17fc7a5 r45c43e5  
    99// Author           : Andrew Beach
    1010// Created On       : Mon Jun 26 15:11:00 2017
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Thr Aug 17 15:44:00 2017
    13 // Update Count     : 6
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Thu Feb 22 18:11:15 2018
     13// Update Count     : 8
    1414//
    1515
    … …  
    2222
    2323struct __cfaabi_ehm__base_exception_t;
    24 typedef struct __cfaabi_ehm__base_exception_t exception;
     24typedef struct __cfaabi_ehm__base_exception_t exception_t;
    2525struct __cfaabi_ehm__base_exception_t_vtable {
    2626        const struct __cfaabi_ehm__base_exception_t_vtable * parent;
    … …  
    3939
    4040// Used in throw statement translation.
    41 void __cfaabi_ehm__throw_terminate(exception * except) __attribute__((noreturn));
     41void __cfaabi_ehm__throw_terminate(exception_t * except) __attribute__((noreturn));
    4242void __cfaabi_ehm__rethrow_terminate() __attribute__((noreturn));
    43 void __cfaabi_ehm__throw_resume(exception * except);
     43void __cfaabi_ehm__throw_resume(exception_t * except);
    4444
    4545// Function catches termination exceptions.
    4646void __cfaabi_ehm__try_terminate(
    4747    void (*try_block)(),
    48     void (*catch_block)(int index, exception * except),
    49     int (*match_block)(exception * except));
     48    void (*catch_block)(int index, exception_t * except),
     49    int (*match_block)(exception_t * except));
    5050
    5151// Clean-up the exception in catch blocks.
    … …  
    5555struct __cfaabi_ehm__try_resume_node {
    5656    struct __cfaabi_ehm__try_resume_node * next;
    57     _Bool (*handler)(exception * except);
     57    _Bool (*handler)(exception_t * except);
    5858};
    5959
    … …  
    6161void __cfaabi_ehm__try_resume_setup(
    6262    struct __cfaabi_ehm__try_resume_node * node,
    63     _Bool (*handler)(exception * except));
     63    _Bool (*handler)(exception_t * except));
    6464void __cfaabi_ehm__try_resume_cleanup(
    6565    struct __cfaabi_ehm__try_resume_node * node);

  • src/libcfa/stdhdr/math.h

    r17fc7a5 r45c43e5  
    1010// Created On       : Mon Jul  4 23:25:26 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Jul  5 20:38:18 2016
    13 // Update Count     : 12
     12// Last Modified On : Thu Feb 22 18:16:07 2018
     13// Update Count     : 13
    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

  • src/prelude/builtins.c

    r17fc7a5 r45c43e5  
    2323void exit( int status, const char fmt[], ... ) __attribute__ (( format(printf, 2, 3), __nothrow__, __leaf__, __noreturn__ ));
    2424void abort ( const char fmt[], ... ) __attribute__ (( format(printf, 1, 2), __nothrow__, __leaf__, __noreturn__ ));
     25
     26// increment/decrement unification
     27
     28static inline forall( dtype T | { T& ?+=?( T&, one_t ); } )
     29T& ++? ( T& x ) { return x += 1; }
     30
     31static inline forall( dtype T | sized(T) | { void ?{}( T&, T ); void ^?{}( T& ); T& ?+=?( T&, one_t ); } )
     32T& ?++ ( T& x ) { T tmp = x; x += 1; return tmp; }
     33
     34static inline forall( dtype T | { T& ?-=?( T&, one_t ); } )
     35T& --? ( T& x ) { return x -= 1; }
     36
     37static inline forall( dtype T | sized(T) | { void ?{}( T&, T ); void ^?{}( T& ); T& ?-=?( T&, one_t ); } )
     38T& ?-- ( T& x ) { T tmp = x; x -= 1; return tmp; }
    2539
    2640// exponentiation operator implementation
Note: See TracChangeset for help on using the changeset viewer.