Changeset 12c1eef


Ignore:
Timestamp:
Jan 19, 2022, 2:36:56 PM (23 months ago)
Author:
Michael Brooks <mlbrooks@…>
Branches:
ADT, ast-experimental, enum, master, pthread-emulation, qualifiedEnum
Children:
97c215f
Parents:
5235d49 (diff), 6a33e40 (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:software/cfa/cfa-cc

Files:
12 added
6 deleted
40 edited

Legend:

Unmodified
Added
Removed

  • benchmark/readyQ/churn.cfa

    r5235d49 r12c1eef  
    2121        wait( sem );
    2222        for() {
    23                 uint64_t r = thread_rand();
     23                uint32_t r = prng();
    2424                bench_sem * next = __atomic_exchange_n(&spots[r % spot_cnt], &sem, __ATOMIC_SEQ_CST);
    2525                if(next) post( *next );

  • benchmark/readyQ/locality.cfa

    r5235d49 r12c1eef  
    128128__attribute__((noinline)) void work(MyData & data, size_t cnt_, uint64_t & state) {
    129129        for (cnt_) {
    130                 access(data, __xorshift64(state));
     130                access(data, xorshift_13_7_17(state));
    131131        }
    132132}
    133133
    134134void main(MyThread & this) {
    135         uint64_t state = thread_rand();
     135        uint64_t state = prng();
    136136
    137137        // Wait for start
    … …  
    144144
    145145                // Wait on a random spot
    146                 uint64_t idx = __xorshift64(state) % this.spots.len;
     146                uint64_t idx = xorshift_13_7_17(state) % this.spots.len;
    147147                bool closed = put(*this.spots.ptr[idx], this, this.data, this.share);
    148148

  • benchmark/readyQ/transfer.cfa

    r5235d49 r12c1eef  
    11#include "rq_bench.hfa"
    22#include <fstream.hfa>
     3#include <locale.h>
    34
    45Duration default_preemption() {
    … …  
    89#define PRINT(...)
    910
    10 __lehmer64_state_t lead_seed;
     11__uint128_t lead_seed;
    1112volatile unsigned leader;
    1213volatile size_t lead_idx;
    … …  
    6869        waitgroup();
    6970
    70         unsigned nleader = __lehmer64( lead_seed ) % nthreads;
     71        unsigned nleader = lehmer64( lead_seed ) % nthreads;
    7172        __atomic_store_n( &leader, nleader, __ATOMIC_SEQ_CST );
    7273
    … …  
    105106// ==================================================
    106107int main(int argc, char * argv[]) {
    107         __lehmer64_state_t lead_seed = getpid();
    108         for(10) __lehmer64( lead_seed );
     108        uint64_t lead_seed = getpid();
     109        for(10) lehmer64( lead_seed );
    109110        unsigned nprocs = 2;
    110111
    … …  
    126127
    127128        lead_idx = 0;
    128         leader = __lehmer64( lead_seed ) % nthreads;
     129        leader = lehmer64( lead_seed ) % nthreads;
    129130
    130131        size_t rechecks = 0;
    … …  
    167168        }
    168169
     170        setlocale( LC_NUMERIC, getenv( "LANG" ) );
    169171        sout | "Duration (ms)           : " | ws(3, 3, unit(eng((end - start)`dms)));
    170172        sout | "Number of processors    : " | nprocs;

  • libcfa/prelude/Makefile.am

    r5235d49 r12c1eef  
    1111## Created On       : Sun May 31 08:54:01 2015
    1212## Last Modified By : Peter A. Buhr
    13 ## Last Modified On : Mon Feb  3 21:27:18 2020
    14 ## Update Count     : 208
     13## Last Modified On : Thu Jan 13 17:06:27 2022
     14## Update Count     : 215
    1515###############################################################################
    1616
    … …  
    3737# create extra forward types/declarations to reduce inclusion of library files
    3838extras.cf : ${srcdir}/extras.regx ${srcdir}/extras.c
    39         ${AM_V_GEN}gcc ${AM_CFLAGS} -E ${srcdir}/extras.c | grep -f ${srcdir}/extras.regx > extras.cf
    40         ${AM_V_GEN}gcc ${AM_CFLAGS} -E ${srcdir}/extras.c | grep -zo -f ${srcdir}/extras.regx2 | tr '\0' '\n' >> extras.cf
     39        @echo '# 2 "${@}"  // needed for error messages from this file' > ${@}
     40        ${AM_V_GEN}gcc ${AM_CFLAGS} -E ${srcdir}/extras.c | grep -f ${srcdir}/extras.regx >> ${@}
     41        ${AM_V_GEN}gcc ${AM_CFLAGS} -E ${srcdir}/extras.c | grep -zo -f ${srcdir}/extras.regx2 | tr '\0' '\n' >> ${@}
    4142
    4243# create forward declarations for gcc builtins
    4344gcc-builtins.cf : gcc-builtins.c ${srcdir}/prototypes.sed
    44         ${AM_V_GEN}gcc -I${srcdir} -E -P $< | sed -r -f ${srcdir}/prototypes.sed > $@
     45        @echo '# 2 "${@}"  // needed for error messages from this file' > ${@}
     46        ${AM_V_GEN}gcc -I${srcdir} -E -P $< | sed -r -f ${srcdir}/prototypes.sed >> ${@}
    4547
    4648gcc-builtins.c : ${srcdir}/builtins.def ${srcdir}/prototypes.awk ${srcdir}/sync-builtins.cf ${srcdir}/prototypes.c
    47         ${AM_V_GEN}gcc -I${srcdir} -E ${srcdir}/prototypes.c | awk -f ${srcdir}/prototypes.awk > $@
     49        ${AM_V_GEN}gcc -I${srcdir} -E ${srcdir}/prototypes.c | awk -f ${srcdir}/prototypes.awk > ${@}
    4850
    4951prelude.cfa : prelude-gen.cc
    5052        ${AM_V_GEN}${CXX} ${AM_CXXFLAGS} ${CXXFLAGS} ${AM_CFLAGS} ${<} -o prelude-gen -Wall -Wextra -O2 -g -std=c++14
    51         @./prelude-gen > $@
     53        @./prelude-gen > ${@}
    5254        @rm ./prelude-gen
    5355
    … …  
    5860# create forward declarations for cfa builtins
    5961builtins.cf : builtins.c @LOCAL_CFACC@
    60         ${AM_V_GEN}gcc ${AM_CFLAGS} -E -P ${<} -o ${@} -MD -MP -MF $(DEPDIR)/builtins.Po -D__cforall
     62        ${AM_V_GEN}gcc ${AM_CFLAGS} -E ${<} -o ${@} -MD -MP -MF $(DEPDIR)/builtins.Po -D__cforall
    6163        ${AM_V_at}sed -i 's/builtins.o/builtins.cf/g' $(DEPDIR)/builtins.Po
    6264
    … …  
    6466
    6567bootloader.c : ${srcdir}/bootloader.cf prelude.cfa extras.cf gcc-builtins.cf builtins.cf @CFACPP@
    66         ${AM_V_GEN}@CFACPP@ --prelude-dir=${builddir} -tpm ${srcdir}/bootloader.cf $@  # use src/cfa-cpp as not in lib until after install
     68        ${AM_V_GEN}@CFACPP@ --prelude-dir=${builddir} -tpm ${srcdir}/bootloader.cf ${@}  # use src/cfa-cpp as not in lib until after install
    6769
    6870maintainer-clean-local :

  • libcfa/src/bits/locks.hfa

    r5235d49 r12c1eef  
    3131                // previous thread to acquire the lock
    3232                void* prev_thrd;
     33                // keep track of number of times we had to spin, just in case the number is unexpectedly huge
     34                size_t spin_count;
    3335        #endif
    3436};
    … …  
    4850        static inline void ?{}( __spinlock_t & this ) {
    4951                this.lock = 0;
     52                #ifdef __CFA_DEBUG__
     53                        this.spin_count = 0;
     54                #endif
    5055        }
    5156
    … …  
    7277                for ( unsigned int i = 1;; i += 1 ) {
    7378                        if ( (this.lock == 0) && (__atomic_test_and_set( &this.lock, __ATOMIC_ACQUIRE ) == 0) ) break;
     79                        #ifdef __CFA_DEBUG__
     80                                this.spin_count++;
     81                        #endif
    7482                        #ifndef NOEXPBACK
    7583                                // exponential spin

  • libcfa/src/bits/random.hfa

    r5235d49 r12c1eef  
     1//
     2// Cforall Version 1.0.0 Copyright (C) 2022 University of Waterloo
     3//
     4// The contents of this file are covered under the licence agreement in the
     5// file "LICENCE" distributed with Cforall.
     6//
     7// random.hfa --
     8//
     9// Author           : Peter A. Buhr
     10// Created On       : Fri Jan 14 07:18:11 2022
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Fri Jan 14 07:18:58 2022
     13// Update Count     : 1
     14//
     15
    116#pragma once
    217
    318#include <stdint.h>
    419
     20// Pipelined to allow out-of-order overlap with reduced dependencies. Critically, the current random state is returned
     21// (copied), and then compute and store the next random value.
     22
     23#if defined(__SIZEOF_INT128__)
    524//--------------------------------------------------
    6 #if defined(__SIZEOF_INT128__)
    7         typedef __uint128_t __lehmer64_state_t;
    8         static inline uint64_t __lehmer64( __lehmer64_state_t & state ) {
     25        static inline uint64_t lehmer64( __uint128_t & state ) {
     26                __uint128_t ret = state;
    927                state *= 0xda942042e4dd58b5;
    10                 return state >> 64;
     28                return ret >> 64;
    1129        }
    1230
    1331//--------------------------------------------------
    14         typedef uint64_t __wyhash64_state_t;
    15         static inline uint64_t __wyhash64( __wyhash64_state_t & state ) {
     32        static inline uint64_t wyhash64( uint64_t & state ) {
    1633                state += 0x60bee2bee120fc15;
    1734                __uint128_t tmp;
    … …  
    2542
    2643//--------------------------------------------------
    27 typedef uint64_t __xorshift64_state_t;
    28 static inline uint64_t __xorshift64( __xorshift64_state_t & state ) {
    29         uint64_t x = state;
    30         x ^= x << 13;
    31         x ^= x >> 7;
    32         x ^= x << 17;
    33         return state = x;
     44static inline uint64_t xorshift_13_7_17( uint64_t & state ) {
     45        uint64_t ret = state;
     46        state ^= state << 13;
     47        state ^= state >> 7;
     48        state ^= state << 17;
     49        return ret;
    3450}
     51
     52//--------------------------------------------------
     53static inline uint32_t xorshift_6_21_7( uint32_t & state ) {
     54        uint32_t ret = state;
     55        state ^= state << 6;
     56        state ^= state >> 21;
     57        state ^= state << 7;
     58        return ret;
     59} // xorshift_6_21_7
    3560
    3661//--------------------------------------------------
    … …  
    3863  uint32_t a, b, c, d;
    3964  uint32_t counter;
    40 } __xorwow__state_t;
     65} xorwow__state_t;
    4166
    42 /* The state array must be initialized to not be all zero in the first four words */
    43 static inline uint32_t __xorwow( __xorwow__state_t & state ) {
    44         /* Algorithm "xorwow" from p. 5 of Marsaglia, "Xorshift RNGs" */
     67// The state array must be initialized to not be all zero in the first four words.
     68static inline uint32_t xorwow( xorwow__state_t & state ) {
     69        // Algorithm "xorwow" from p. 5 of Marsaglia, "Xorshift RNGs".
     70        uint32_t ret = state.a + state.counter;
    4571        uint32_t t = state.d;
    4672
    … …  
    5682
    5783        state.counter += 362437;
    58         return t + state.counter;
     84        return ret;
    5985}
     86
     87//--------------------------------------------------
     88static inline uint32_t LCG( uint32_t & state ) {                // linear congruential generator
     89        uint32_t ret = state;
     90        state = 36969 * (state & 65535) + (state >> 16);        // 36969 is NOT prime! No not change it!
     91        return ret;
     92} // LCG
     93
     94//--------------------------------------------------
     95#define M  (1_l64u << 48_l64u)
     96#define A  (25214903917_l64u)
     97#define AI (18446708753438544741_l64u)
     98#define C  (11_l64u)
     99#define D  (16_l64u)
     100
     101// Bi-directional LCG random-number generator
     102static inline uint32_t LCGBI_fwd( uint64_t & state ) {
     103        state = (A * state + C) & (M - 1);
     104        return state >> D;
     105}
     106
     107static inline uint32_t LCGBI_bck( uint64_t & state ) {
     108        unsigned int r = state >> D;
     109        state = AI * (state - C) & (M - 1);
     110        return r;
     111}
     112
     113#undef M
     114#undef A
     115#undef AI
     116#undef C
     117#undef D

  • libcfa/src/common.hfa

    r5235d49 r12c1eef  
    1 // 
     1//
    22// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
    33//
    44// The contents of this file are covered under the licence agreement in the
    55// file "LICENCE" distributed with Cforall.
    6 // 
    7 // common --
    8 // 
     6//
     7// common.hfa --
     8//
    99// Author           : Peter A. Buhr
    1010// Created On       : Wed Jul 11 17:54:36 2018
    … …  
    1212// Last Modified On : Wed May  5 14:02:04 2021
    1313// Update Count     : 18
    14 // 
     14//
    1515
    1616#pragma once

  • libcfa/src/concurrency/clib/cfathread.cfa

    r5235d49 r12c1eef  
    2222#include "thread.hfa"
    2323#include "time.hfa"
     24#include "stdlib.hfa"
    2425
    2526#include "cfathread.h"
    … …  
    195196                                eevent.data.u64 = (uint64_t)active_thread();
    196197
    197                                 int id = thread_rand() % poller_cnt;
     198                                int id = prng() % poller_cnt;
    198199                                if(0 != epoll_ctl(poller_fds[id], EPOLL_CTL_ADD, fd, &eevent))
    199200                                {

  • libcfa/src/concurrency/coroutine.hfa

    r5235d49 r12c1eef  
    1010// Created On       : Mon Nov 28 12:27:26 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Feb  4 12:29:26 2020
    13 // Update Count     : 11
     12// Last Modified On : Thu Jan  6 16:33:16 2022
     13// Update Count     : 12
    1414//
    1515
    … …  
    155155
    156156        if( unlikely(dst->context.SP == 0p) ) {
    157                 __stack_prepare(&dst->stack, 65000);
     157                __stack_prepare(&dst->stack, DEFAULT_STACK_SIZE);
    158158                __cfactx_start(main, dst, cor, __cfactx_invoke_coroutine);
    159159        }

  • libcfa/src/concurrency/invoke.h

    r5235d49 r12c1eef  
    1010// Created On       : Tue Jan 17 12:27:26 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Dec  5 16:26:03 2019
    13 // Update Count     : 44
     12// Last Modified On : Sun Jan  9 19:06:45 2022
     13// Update Count     : 48
    1414//
    1515
    … …  
    2727#ifndef _INVOKE_H_
    2828#define _INVOKE_H_
     29
     30        enum { DEFAULT_STACK_SIZE = 65000 };
    2931
    3032        struct __cfaehm_try_resume_node;
    … …  
    209211                struct processor * last_proc;
    210212
     213                uint32_t random_state;                                                  // fast random numbers
     214
    211215                #if defined( __CFA_WITH_VERIFY__ )
    212216                        void * canary;

  • libcfa/src/concurrency/io.cfa

    r5235d49 r12c1eef  
    144144                __ioarbiter_flush( ctx );
    145145
    146                 __STATS__( true, io.calls.flush++; )
    147                 int ret = syscall( __NR_io_uring_enter, ctx.fd, ctx.sq.to_submit, min_comp, min_comp > 0 ? IORING_ENTER_GETEVENTS : 0, (sigset_t *)0p, _NSIG / 8);
    148                 if( ret < 0 ) {
    149                         switch((int)errno) {
    150                         case EAGAIN:
    151                         case EINTR:
    152                         case EBUSY:
    153                                 // Update statistics
    154                                 __STATS__( false, io.calls.errors.busy ++; )
    155                                 return false;
    156                         default:
    157                                 abort( "KERNEL ERROR: IO_URING SYSCALL - (%d) %s\n", (int)errno, strerror(errno) );
     146                if(ctx.sq.to_submit != 0 || min_comp > 0) {
     147
     148                        __STATS__( true, io.calls.flush++; )
     149                        int ret = syscall( __NR_io_uring_enter, ctx.fd, ctx.sq.to_submit, min_comp, min_comp > 0 ? IORING_ENTER_GETEVENTS : 0, (sigset_t *)0p, _NSIG / 8);
     150                        if( ret < 0 ) {
     151                                switch((int)errno) {
     152                                case EAGAIN:
     153                                case EINTR:
     154                                case EBUSY:
     155                                        // Update statistics
     156                                        __STATS__( false, io.calls.errors.busy ++; )
     157                                        return false;
     158                                default:
     159                                        abort( "KERNEL ERROR: IO_URING SYSCALL - (%d) %s\n", (int)errno, strerror(errno) );
     160                                }
    158161                        }
    159                 }
    160 
    161                 __cfadbg_print_safe(io, "Kernel I/O : %u submitted to io_uring %d\n", ret, ctx.fd);
    162                 __STATS__( true, io.calls.submitted += ret; )
    163                 /* paranoid */ verify( ctx.sq.to_submit <= *ctx.sq.num );
    164                 /* paranoid */ verify( ctx.sq.to_submit >= ret );
    165 
    166                 ctx.sq.to_submit -= ret;
    167 
    168                 /* paranoid */ verify( ctx.sq.to_submit <= *ctx.sq.num );
    169 
    170                 // Release the consumed SQEs
    171                 __release_sqes( ctx );
    172 
    173                 /* paranoid */ verify( ! __preemption_enabled() );
    174 
    175                 ctx.proc->io.pending = false;
     162
     163                        __cfadbg_print_safe(io, "Kernel I/O : %u submitted to io_uring %d\n", ret, ctx.fd);
     164                        __STATS__( true, io.calls.submitted += ret; )
     165                        /* paranoid */ verify( ctx.sq.to_submit <= *ctx.sq.num );
     166                        /* paranoid */ verify( ctx.sq.to_submit >= ret );
     167
     168                        ctx.sq.to_submit -= ret;
     169
     170                        /* paranoid */ verify( ctx.sq.to_submit <= *ctx.sq.num );
     171
     172                        // Release the consumed SQEs
     173                        __release_sqes( ctx );
     174
     175                        /* paranoid */ verify( ! __preemption_enabled() );
     176
     177                        ctx.proc->io.pending = false;
     178                }
     179
    176180                ready_schedule_lock();
    177181                bool ret = __cfa_io_drain( proc );
    … …  
    548552                        /* paranoid */ verify( proc == __cfaabi_tls.this_processor );
    549553                        /* paranoid */ verify( ! __preemption_enabled() );
     554
     555                        return true;
    550556                }
    551557        #endif

  • libcfa/src/concurrency/kernel.cfa

    r5235d49 r12c1eef  
    142142extern void __disable_interrupts_hard();
    143143extern void __enable_interrupts_hard();
    144 
    145 static inline void __disable_interrupts_checked() {
    146         /* paranoid */ verify( __preemption_enabled() );
    147         disable_interrupts();
    148         /* paranoid */ verify( ! __preemption_enabled() );
    149 }
    150 
    151 static inline void __enable_interrupts_checked( bool poll = true ) {
    152         /* paranoid */ verify( ! __preemption_enabled() );
    153         enable_interrupts( poll );
    154         /* paranoid */ verify( __preemption_enabled() );
    155 }
    156144
    157145
    … …  
    566554        /* paranoid */ verify( 0x0D15EA5E0D15EA5Ep == thrd->canary );
    567555
    568         const bool local = thrd->state != Start;
    569556        if (thrd->preempted == __NO_PREEMPTION) thrd->state = Ready;
    570557
    … …  
    749736
    750737        // Check if there is a sleeping processor
    751         int fd = __atomic_load_n(&this->procs.fd, __ATOMIC_SEQ_CST);
     738        // int fd = __atomic_load_n(&this->procs.fd, __ATOMIC_SEQ_CST);
     739        int fd = 0;
     740        if( __atomic_load_n(&this->procs.fd, __ATOMIC_SEQ_CST) != 0 ) {
     741                fd = __atomic_exchange_n(&this->procs.fd, 0, __ATOMIC_RELAXED);
     742        }
    752743
    753744        // If no one is sleeping, we are done
    … …  
    776767// Unconditionnaly wake a thread
    777768void __wake_proc(processor * this) {
     769        /* paranoid */ verify( ! __preemption_enabled() );
     770
    778771        __cfadbg_print_safe(runtime_core, "Kernel : waking Processor %p\n", this);
    779772
    780         __disable_interrupts_checked();
    781                 /* paranoid */ verify( ! __preemption_enabled() );
    782                 eventfd_t val;
    783                 val = 1;
    784                 eventfd_write( this->idle_fd, val );
    785         __enable_interrupts_checked();
     773        eventfd_t val;
     774        val = 1;
     775        eventfd_write( this->idle_fd, val );
     776
     777        /* paranoid */ verify( ! __preemption_enabled() );
    786778}
    787779

  • libcfa/src/concurrency/kernel.hfa

    r5235d49 r12c1eef  
    6767                unsigned target;
    6868                unsigned last;
    69                 unsigned cnt;
    70                 unsigned long long int cutoff;
     69                signed   cpu;
    7170        } rdq;
    7271
    … …  
    152151        volatile unsigned long long tv;
    153152        volatile unsigned long long ma;
     153};
     154
     155struct __attribute__((aligned(16))) __cache_id_t {
     156        volatile unsigned id;
    154157};
    155158
    … …  
    164167static inline void ^?{}(__timestamp_t & this) {}
    165168
     169struct __attribute__((aligned(128))) __ready_queue_caches_t;
     170void  ?{}(__ready_queue_caches_t & this);
     171void ^?{}(__ready_queue_caches_t & this);
     172
    166173//TODO adjust cache size to ARCHITECTURE
    167 // Structure holding the relaxed ready queue
     174// Structure holding the ready queue
    168175struct __ready_queue_t {
    169176        // Data tracking the actual lanes
    … …  
    177184                // Array of times
    178185                __timestamp_t * volatile tscs;
     186
     187                __cache_id_t * volatile caches;
    179188
    180189                // Array of stats

  • libcfa/src/concurrency/kernel/fwd.hfa

    r5235d49 r12c1eef  
    7777
    7878                static inline uint64_t __tls_rand() {
     79                        return
    7980                        #if defined(__SIZEOF_INT128__)
    80                                 return __lehmer64( kernelTLS().rand_seed );
     81                                lehmer64( kernelTLS().rand_seed );
    8182                        #else
    82                                 return __xorshift64( kernelTLS().rand_seed );
     83                                xorshift_13_7_17( kernelTLS().rand_seed );
    8384                        #endif
    8485                }
    8586
    86                 #define M  (1_l64u << 48_l64u)
    87                 #define A  (25214903917_l64u)
    88                 #define AI (18446708753438544741_l64u)
    89                 #define C  (11_l64u)
    90                 #define D  (16_l64u)
    91 
    9287                static inline unsigned __tls_rand_fwd() {
    93 
    94                         kernelTLS().ready_rng.fwd_seed = (A * kernelTLS().ready_rng.fwd_seed + C) & (M - 1);
    95                         return kernelTLS().ready_rng.fwd_seed >> D;
     88                        return LCGBI_fwd( kernelTLS().ready_rng.fwd_seed );
    9689                }
    9790
    9891                static inline unsigned __tls_rand_bck() {
    99                         unsigned int r = kernelTLS().ready_rng.bck_seed >> D;
    100                         kernelTLS().ready_rng.bck_seed = AI * (kernelTLS().ready_rng.bck_seed - C) & (M - 1);
    101                         return r;
    102                 }
    103 
    104                 #undef M
    105                 #undef A
    106                 #undef AI
    107                 #undef C
    108                 #undef D
     92                        return LCGBI_bck( kernelTLS().ready_rng.bck_seed );
     93                }
    10994
    11095                static inline void __tls_rand_advance_bck(void) {
    … …  
    11297                }
    11398        }
    114 
    115 
    11699
    117100        extern void disable_interrupts();
    … …  
    142125                        }
    143126                }
    144 
    145                 extern uint64_t thread_rand();
    146127
    147128                // Semaphore which only supports a single thread

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

    r5235d49 r12c1eef  
    3434#include "kernel_private.hfa"
    3535#include "startup.hfa"          // STARTUP_PRIORITY_XXX
     36#include "limits.hfa"
    3637#include "math.hfa"
    3738
    … …  
    101102extern void __wake_proc(processor *);
    102103extern int cfa_main_returned;                                                   // from interpose.cfa
     104extern uint32_t __global_random_seed;
    103105
    104106//-----------------------------------------------------------------------------
    … …  
    176178
    177179
    178 
    179180//=============================================================================================
    180181// Kernel Setup logic
    … …  
    279280        // When its coroutine terminates, it return control to the mainThread
    280281        // which is currently here
     282        /* paranoid */ verify( !__atomic_load_n(&mainProcessor->do_terminate, __ATOMIC_ACQUIRE) );
    281283        __atomic_store_n(&mainProcessor->do_terminate, true, __ATOMIC_RELEASE);
     284        __wake_proc( mainProcessor );
    282285        __kernel_last_resume( __cfaabi_tls.this_processor );
    283286        mainThread->self_cor.state = Halted;
    … …  
    403406
    404407        __cfaabi_tls.this_thread->curr_cor = dst;
    405         __stack_prepare( &dst->stack, 65000 );
     408        __stack_prepare( &dst->stack, DEFAULT_STACK_SIZE );
    406409        __cfactx_start(main, dst, this->runner, __cfactx_invoke_coroutine);
    407410
    … …  
    487490        preferred = ready_queue_new_preferred();
    488491        last_proc = 0p;
     492        random_state = __global_random_seed;
    489493        #if defined( __CFA_WITH_VERIFY__ )
    490494                canary = 0x0D15EA5E0D15EA5Ep;
    … …  
    511515        this.rdq.its = 0;
    512516        this.rdq.itr = 0;
    513         this.rdq.id  = -1u;
    514         this.rdq.target = -1u;
    515         this.rdq.last = -1u;
    516         this.rdq.cutoff = 0ull;
     517        this.rdq.id  = MAX;
     518        this.rdq.target = MAX;
     519        this.rdq.last = MAX;
     520        this.rdq.cpu = 0;
     521        // this.rdq.cutoff = 0ull;
    517522        do_terminate = false;
    518523        preemption_alarm = 0p;
    … …  
    564569extern size_t __page_size;
    565570void ^?{}(processor & this) with( this ){
    566         if( ! __atomic_load_n(&do_terminate, __ATOMIC_ACQUIRE) ) {
    567                 __cfadbg_print_safe(runtime_core, "Kernel : core %p signaling termination\n", &this);
    568 
    569                 __atomic_store_n(&do_terminate, true, __ATOMIC_RELAXED);
     571        /* paranoid */ verify( !__atomic_load_n(&do_terminate, __ATOMIC_ACQUIRE) );
     572        __cfadbg_print_safe(runtime_core, "Kernel : core %p signaling termination\n", &this);
     573
     574        __atomic_store_n(&do_terminate, true, __ATOMIC_RELAXED);
     575        __disable_interrupts_checked();
    570576                __wake_proc( &this );
    571 
    572                 wait( terminated );
    573                 /* paranoid */ verify( active_processor() != &this);
    574         }
     577        __enable_interrupts_checked();
     578
     579        wait( terminated );
     580        /* paranoid */ verify( active_processor() != &this);
    575581
    576582        __destroy_pthread( kernel_thread, this.stack, 0p );
    … …  
    682688        [this->unique_id, last_size] = ready_mutate_register();
    683689
     690                this->rdq.cpu = __kernel_getcpu();
     691
    684692                this->cltr->procs.total += 1u;
    685693                insert_last(this->cltr->procs.actives, *this);
    … …  
    721729        check( pthread_attr_init( &attr ), "pthread_attr_init" ); // initialize attribute
    722730
    723         size_t stacksize;
    724         // default stack size, normally defined by shell limit
    725         check( pthread_attr_getstacksize( &attr, &stacksize ), "pthread_attr_getstacksize" );
    726         assert( stacksize >= PTHREAD_STACK_MIN );
     731        size_t stacksize = DEFAULT_STACK_SIZE;
    727732
    728733        void * stack;
    … …  
    749754        #endif
    750755
    751 
    752756        check( pthread_attr_setstack( &attr, stack, stacksize ), "pthread_attr_setstack" );
    753 
    754757        check( pthread_create( pthread, &attr, start, arg ), "pthread_create" );
    755758        return stack;

  • libcfa/src/concurrency/kernel_private.hfa

    r5235d49 r12c1eef  
    6060extern bool __preemption_enabled();
    6161
     62static inline void __disable_interrupts_checked() {
     63        /* paranoid */ verify( __preemption_enabled() );
     64        disable_interrupts();
     65        /* paranoid */ verify( ! __preemption_enabled() );
     66}
     67
     68static inline void __enable_interrupts_checked( bool poll = true ) {
     69        /* paranoid */ verify( ! __preemption_enabled() );
     70        enable_interrupts( poll );
     71        /* paranoid */ verify( __preemption_enabled() );
     72}
     73
    6274//release/wake-up the following resources
    6375void __thread_finish( thread$ * thrd );

  • libcfa/src/concurrency/locks.hfa

    r5235d49 r12c1eef  
    2929#include "time_t.hfa"
    3030#include "time.hfa"
    31 
    32 //-----------------------------------------------------------------------------
    33 // Semaphores
    34 
    35 // '0-nary' semaphore
    36 // Similar to a counting semaphore except the value of one is never reached
    37 // as a consequence, a V() that would bring the value to 1 *spins* until
    38 // a P consumes it
    39 struct Semaphore0nary {
    40         __spinlock_t lock; // needed to protect
    41         mpsc_queue(thread$) queue;
    42 };
    43 
    44 static inline bool P(Semaphore0nary & this, thread$ * thrd) {
    45         /* paranoid */ verify(!thrd`next);
    46         /* paranoid */ verify(!(&(*thrd)`next));
    47 
    48         push(this.queue, thrd);
    49         return true;
    50 }
    51 
    52 static inline bool P(Semaphore0nary & this) {
    53     thread$ * thrd = active_thread();
    54     P(this, thrd);
    55     park();
    56     return true;
    57 }
    58 
    59 static inline thread$ * V(Semaphore0nary & this, bool doUnpark = true) {
    60         thread$ * next;
    61         lock(this.lock __cfaabi_dbg_ctx2);
    62                 for (;;) {
    63                         next = pop(this.queue);
    64                         if (next) break;
    65                         Pause();
    66                 }
    67         unlock(this.lock);
    68 
    69         if (doUnpark) unpark(next);
    70         return next;
    71 }
    72 
    73 // Wrapper used on top of any sempahore to avoid potential locking
    74 struct BinaryBenaphore {
    75         volatile ssize_t counter;
    76 };
    77 
    78 static inline {
    79         void ?{}(BinaryBenaphore & this) { this.counter = 0; }
    80         void ?{}(BinaryBenaphore & this, zero_t) { this.counter = 0; }
    81         void ?{}(BinaryBenaphore & this, one_t ) { this.counter = 1; }
    82 
    83         // returns true if no blocking needed
    84         bool P(BinaryBenaphore & this) {
    85                 return __atomic_fetch_sub(&this.counter, 1, __ATOMIC_SEQ_CST) > 0;
    86         }
    87 
    88         bool tryP(BinaryBenaphore & this) {
    89                 ssize_t c = this.counter;
    90                 /* paranoid */ verify( c > MIN );
    91                 return (c >= 1) && __atomic_compare_exchange_n(&this.counter, &c, c-1, false, __ATOMIC_SEQ_CST, __ATOMIC_RELAXED);
    92         }
    93 
    94         // returns true if notify needed
    95         bool V(BinaryBenaphore & this) {
    96                 ssize_t c = 0;
    97                 for () {
    98                         /* paranoid */ verify( this.counter < MAX );
    99                         if (__atomic_compare_exchange_n(&this.counter, &c, c+1, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
    100                                 if (c == 0) return true;
    101                                 /* paranoid */ verify(c < 0);
    102                                 return false;
    103                         } else {
    104                                 if (c == 1) return true;
    105                                 /* paranoid */ verify(c < 1);
    106                                 Pause();
    107                         }
    108                 }
    109         }
    110 }
    111 
    112 // Binary Semaphore based on the BinaryBenaphore on top of the 0-nary Semaphore
    113 struct ThreadBenaphore {
    114         BinaryBenaphore ben;
    115         Semaphore0nary  sem;
    116 };
    117 
    118 static inline void ?{}(ThreadBenaphore & this) {}
    119 static inline void ?{}(ThreadBenaphore & this, zero_t) { (this.ben){ 0 }; }
    120 static inline void ?{}(ThreadBenaphore & this, one_t ) { (this.ben){ 1 }; }
    121 
    122 static inline bool P(ThreadBenaphore & this)              { return P(this.ben) ? false : P(this.sem); }
    123 static inline bool tryP(ThreadBenaphore & this)           { return tryP(this.ben); }
    124 static inline bool P(ThreadBenaphore & this, bool wait)   { return wait ? P(this) : tryP(this); }
    125 
    126 static inline thread$ * V(ThreadBenaphore & this, bool doUnpark = true) {
    127         if (V(this.ben)) return 0p;
    128         return V(this.sem, doUnpark);
    129 }
    13031
    13132//-----------------------------------------------------------------------------
    … …  
    17172static inline void   on_wakeup( owner_lock & this, size_t v ) { on_wakeup ( (blocking_lock &)this, v ); }
    17273static inline void   on_notify( owner_lock & this, struct thread$ * t ) { on_notify( (blocking_lock &)this, t ); }
    173 
    174 struct fast_lock {
    175         thread$ * volatile owner;
    176         ThreadBenaphore sem;
    177 };
    178 
    179 static inline void ?{}(fast_lock & this) { this.owner = 0p; }
    180 
    181 static inline bool $try_lock(fast_lock & this, thread$ * thrd) {
    182     thread$ * exp = 0p;
    183     return __atomic_compare_exchange_n(&this.owner, &exp, thrd, false, __ATOMIC_SEQ_CST, __ATOMIC_RELAXED);
    184 }
    185 
    186 static inline void lock( fast_lock & this ) __attribute__((artificial));
    187 static inline void lock( fast_lock & this ) {
    188         thread$ * thrd = active_thread();
    189         /* paranoid */verify(thrd != this.owner);
    190 
    191         for (;;) {
    192                 if ($try_lock(this, thrd)) return;
    193                 P(this.sem);
    194         }
    195 }
    196 
    197 static inline bool try_lock( fast_lock & this ) __attribute__((artificial));
    198 static inline bool try_lock ( fast_lock & this ) {
    199         thread$ * thrd = active_thread();
    200         /* paranoid */ verify(thrd != this.owner);
    201         return $try_lock(this, thrd);
    202 }
    203 
    204 static inline thread$ * unlock( fast_lock & this ) __attribute__((artificial));
    205 static inline thread$ * unlock( fast_lock & this ) {
    206         /* paranoid */ verify(active_thread() == this.owner);
    207 
    208         // open 'owner' before unlocking anyone
    209         // so new and unlocked threads don't park incorrectly.
    210         // This may require additional fencing on ARM.
    211         this.owner = 0p;
    212 
    213         return V(this.sem);
    214 }
    215 
    216 static inline size_t on_wait( fast_lock & this ) { unlock(this); return 0; }
    217 static inline void on_wakeup( fast_lock & this, size_t ) { lock(this); }
    218 static inline void on_notify( fast_lock &, struct thread$ * t ) { unpark(t); }
    21974
    22075struct mcs_node {

  • libcfa/src/concurrency/ready_queue.cfa

    r5235d49 r12c1eef  
    2020
    2121
    22 #define USE_RELAXED_FIFO
     22// #define USE_RELAXED_FIFO
    2323// #define USE_WORK_STEALING
    2424// #define USE_CPU_WORK_STEALING
     25#define USE_AWARE_STEALING
    2526
    2627#include "bits/defs.hfa"
    … …  
    2930
    3031#include "stdlib.hfa"
     32#include "limits.hfa"
    3133#include "math.hfa"
    3234
    … …  
    5456#endif
    5557
    56 #if   defined(USE_CPU_WORK_STEALING)
     58#if   defined(USE_AWARE_STEALING)
     59        #define READYQ_SHARD_FACTOR 2
     60        #define SEQUENTIAL_SHARD 2
     61#elif defined(USE_CPU_WORK_STEALING)
    5762        #define READYQ_SHARD_FACTOR 2
    5863#elif defined(USE_RELAXED_FIFO)
    … …  
    138143        __kernel_rseq_register();
    139144
    140         __cfadbg_print_safe(ready_queue, "Kernel : Registering proc %p for RW-Lock\n", proc);
    141145        bool * handle = (bool *)&kernelTLS().sched_lock;
    142146
    … …  
    174178        }
    175179
    176         __cfadbg_print_safe(ready_queue, "Kernel : Registering proc %p done, id %lu\n", proc, n);
    177 
    178180        // Return new spot.
    179181        /* paranoid */ verify(n < ready);
    … …  
    190192
    191193        __atomic_store_n(cell, 0p, __ATOMIC_RELEASE);
    192 
    193         __cfadbg_print_safe(ready_queue, "Kernel : Unregister proc %p\n", proc);
    194194
    195195        __kernel_rseq_unregister();
    … …  
    244244
    245245//=======================================================================
     246// caches handling
     247
     248struct __attribute__((aligned(128))) __ready_queue_caches_t {
     249        // Count States:
     250        // - 0  : No one is looking after this cache
     251        // - 1  : No one is looking after this cache, BUT it's not empty
     252        // - 2+ : At least one processor is looking after this cache
     253        volatile unsigned count;
     254};
     255
     256void  ?{}(__ready_queue_caches_t & this) { this.count = 0; }
     257void ^?{}(__ready_queue_caches_t & this) {}
     258
     259static inline void depart(__ready_queue_caches_t & cache) {
     260        /* paranoid */ verify( cache.count > 1);
     261        __atomic_fetch_add(&cache.count, -1, __ATOMIC_SEQ_CST);
     262        /* paranoid */ verify( cache.count != 0);
     263        /* paranoid */ verify( cache.count < 65536 ); // This verify assumes no cluster will have more than 65000 kernel threads mapped to a single cache, which could be correct but is super weird.
     264}
     265
     266static inline void arrive(__ready_queue_caches_t & cache) {
     267        // for() {
     268        //      unsigned expected = cache.count;
     269        //      unsigned desired  = 0 == expected ? 2 : expected + 1;
     270        // }
     271}
     272
     273//=======================================================================
    246274// Cforall Ready Queue used for scheduling
    247275//=======================================================================
    248 unsigned long long moving_average(unsigned long long nval, unsigned long long oval) {
    249         const unsigned long long tw = 16;
    250         const unsigned long long nw = 4;
    251         const unsigned long long ow = tw - nw;
    252         return ((nw * nval) + (ow * oval)) / tw;
     276unsigned long long moving_average(unsigned long long currtsc, unsigned long long instsc, unsigned long long old_avg) {
     277        /* paranoid */ verifyf( currtsc < 45000000000000000, "Suspiciously large current time: %'llu (%llx)\n", currtsc, currtsc );
     278        /* paranoid */ verifyf( instsc  < 45000000000000000, "Suspiciously large insert time: %'llu (%llx)\n", instsc, instsc );
     279        /* paranoid */ verifyf( old_avg < 15000000000000, "Suspiciously large previous average: %'llu (%llx)\n", old_avg, old_avg );
     280
     281        const unsigned long long new_val = currtsc > instsc ? currtsc - instsc : 0;
     282        const unsigned long long total_weight = 16;
     283        const unsigned long long new_weight   = 4;
     284        const unsigned long long old_weight = total_weight - new_weight;
     285        const unsigned long long ret = ((new_weight * new_val) + (old_weight * old_avg)) / total_weight;
     286        return ret;
    253287}
    254288
    … …  
    271305                }
    272306        #else
    273                 lanes.data  = 0p;
    274                 lanes.tscs  = 0p;
    275                 lanes.help  = 0p;
    276                 lanes.count = 0;
     307                lanes.data   = 0p;
     308                lanes.tscs   = 0p;
     309                lanes.caches = 0p;
     310                lanes.help   = 0p;
     311                lanes.count  = 0;
    277312        #endif
    278313}
    … …  
    285320        free(lanes.data);
    286321        free(lanes.tscs);
     322        free(lanes.caches);
    287323        free(lanes.help);
    288324}
    289325
    290326//-----------------------------------------------------------------------
     327#if defined(USE_AWARE_STEALING)
     328        __attribute__((hot)) void push(struct cluster * cltr, struct thread$ * thrd, unpark_hint hint) with (cltr->ready_queue) {
     329                processor * const proc = kernelTLS().this_processor;
     330                const bool external = (!proc) || (cltr != proc->cltr);
     331                const bool remote   = hint == UNPARK_REMOTE;
     332
     333                unsigned i;
     334                if( external || remote ) {
     335                        // Figure out where thread was last time and make sure it's valid
     336                        /* paranoid */ verify(thrd->preferred >= 0);
     337                        if(thrd->preferred * READYQ_SHARD_FACTOR < lanes.count) {
     338                                /* paranoid */ verify(thrd->preferred * READYQ_SHARD_FACTOR < lanes.count);
     339                                unsigned start = thrd->preferred * READYQ_SHARD_FACTOR;
     340                                do {
     341                                        unsigned r = __tls_rand();
     342                                        i = start + (r % READYQ_SHARD_FACTOR);
     343                                        /* paranoid */ verify( i < lanes.count );
     344                                        // If we can't lock it retry
     345                                } while( !__atomic_try_acquire( &lanes.data[i].lock ) );
     346                        } else {
     347                                do {
     348                                        i = __tls_rand() % lanes.count;
     349                                } while( !__atomic_try_acquire( &lanes.data[i].lock ) );
     350                        }
     351                } else {
     352                        do {
     353                                unsigned r = proc->rdq.its++;
     354                                i = proc->rdq.id + (r % READYQ_SHARD_FACTOR);
     355                                /* paranoid */ verify( i < lanes.count );
     356                                // If we can't lock it retry
     357                        } while( !__atomic_try_acquire( &lanes.data[i].lock ) );
     358                }
     359
     360                // Actually push it
     361                push(lanes.data[i], thrd);
     362
     363                // Unlock and return
     364                __atomic_unlock( &lanes.data[i].lock );
     365
     366                #if !defined(__CFA_NO_STATISTICS__)
     367                        if(unlikely(external || remote)) __atomic_fetch_add(&cltr->stats->ready.push.extrn.success, 1, __ATOMIC_RELAXED);
     368                        else __tls_stats()->ready.push.local.success++;
     369                #endif
     370        }
     371
     372        static inline unsigned long long calc_cutoff(const unsigned long long ctsc, const processor * proc, __ready_queue_t & rdq) {
     373                unsigned start = proc->rdq.id;
     374                unsigned long long max = 0;
     375                for(i; READYQ_SHARD_FACTOR) {
     376                        unsigned long long ptsc = ts(rdq.lanes.data[start + i]);
     377                        if(ptsc != -1ull) {
     378                                /* paranoid */ verify( start + i < rdq.lanes.count );
     379                                unsigned long long tsc = moving_average(ctsc, ptsc, rdq.lanes.tscs[start + i].ma);
     380                                if(tsc > max) max = tsc;
     381                        }
     382                }
     383                return (max + 2 * max) / 2;
     384        }
     385
     386        __attribute__((hot)) struct thread$ * pop_fast(struct cluster * cltr) with (cltr->ready_queue) {
     387                /* paranoid */ verify( lanes.count > 0 );
     388                /* paranoid */ verify( kernelTLS().this_processor );
     389                /* paranoid */ verify( kernelTLS().this_processor->rdq.id < lanes.count );
     390
     391                processor * const proc = kernelTLS().this_processor;
     392                unsigned this = proc->rdq.id;
     393                /* paranoid */ verify( this < lanes.count );
     394                __cfadbg_print_safe(ready_queue, "Kernel : pop from %u\n", this);
     395
     396                // Figure out the current cpu and make sure it is valid
     397                const int cpu = __kernel_getcpu();
     398                /* paranoid */ verify(cpu >= 0);
     399                /* paranoid */ verify(cpu < cpu_info.hthrd_count);
     400                unsigned this_cache = cpu_info.llc_map[cpu].cache;
     401
     402                // Super important: don't write the same value over and over again
     403                // We want to maximise our chances that his particular values stays in cache
     404                if(lanes.caches[this / READYQ_SHARD_FACTOR].id != this_cache)
     405                        __atomic_store_n(&lanes.caches[this / READYQ_SHARD_FACTOR].id, this_cache, __ATOMIC_RELAXED);
     406
     407                const unsigned long long ctsc = rdtscl();
     408
     409                if(proc->rdq.target == MAX) {
     410                        uint64_t chaos = __tls_rand();
     411                        unsigned ext = chaos & 0xff;
     412                        unsigned other  = (chaos >> 8) % (lanes.count);
     413
     414                        if(ext < 3 || __atomic_load_n(&lanes.caches[other / READYQ_SHARD_FACTOR].id, __ATOMIC_RELAXED) == this_cache) {
     415                                proc->rdq.target = other;
     416                        }
     417                }
     418                else {
     419                        const unsigned target = proc->rdq.target;
     420                        __cfadbg_print_safe(ready_queue, "Kernel : %u considering helping %u, tcsc %llu\n", this, target, lanes.tscs[target].tv);
     421                        /* paranoid */ verify( lanes.tscs[target].tv != MAX );
     422                        if(target < lanes.count) {
     423                                const unsigned long long cutoff = calc_cutoff(ctsc, proc, cltr->ready_queue);
     424                                const unsigned long long age = moving_average(ctsc, lanes.tscs[target].tv, lanes.tscs[target].ma);
     425                                __cfadbg_print_safe(ready_queue, "Kernel : Help attempt on %u from %u, age %'llu vs cutoff %'llu, %s\n", target, this, age, cutoff, age > cutoff ? "yes" : "no");
     426                                if(age > cutoff) {
     427                                        thread$ * t = try_pop(cltr, target __STATS(, __tls_stats()->ready.pop.help));
     428                                        if(t) return t;
     429                                }
     430                        }
     431                        proc->rdq.target = MAX;
     432                }
     433
     434                for(READYQ_SHARD_FACTOR) {
     435                        unsigned i = this + (proc->rdq.itr++ % READYQ_SHARD_FACTOR);
     436                        if(thread$ * t = try_pop(cltr, i __STATS(, __tls_stats()->ready.pop.local))) return t;
     437                }
     438
     439                // All lanes where empty return 0p
     440                return 0p;
     441
     442        }
     443        __attribute__((hot)) struct thread$ * pop_slow(struct cluster * cltr) with (cltr->ready_queue) {
     444                unsigned i = __tls_rand() % lanes.count;
     445                return try_pop(cltr, i __STATS(, __tls_stats()->ready.pop.steal));
     446        }
     447        __attribute__((hot)) struct thread$ * pop_search(struct cluster * cltr) {
     448                return search(cltr);
     449        }
     450#endif
    291451#if defined(USE_CPU_WORK_STEALING)
    292452        __attribute__((hot)) void push(struct cluster * cltr, struct thread$ * thrd, unpark_hint hint) with (cltr->ready_queue) {
    … …  
    350510                /* paranoid */ verify( kernelTLS().this_processor );
    351511
     512                processor * const proc = kernelTLS().this_processor;
    352513                const int cpu = __kernel_getcpu();
    353514                /* paranoid */ verify(cpu >= 0);
    … …  
    360521                /* paranoid */ verifyf((map.start + map.count) * READYQ_SHARD_FACTOR <= lanes.count, "have %zu lanes but map can go up to %u", lanes.count, (map.start + map.count) * READYQ_SHARD_FACTOR);
    361522
    362                 processor * const proc = kernelTLS().this_processor;
    363523                const int start = map.self * READYQ_SHARD_FACTOR;
    364524                const unsigned long long ctsc = rdtscl();
    365525
    366526                // Did we already have a help target
    367                 if(proc->rdq.target == -1u) {
     527                if(proc->rdq.target == MAX) {
    368528                        unsigned long long max = 0;
    369529                        for(i; READYQ_SHARD_FACTOR) {
    370                                 unsigned long long tsc = moving_average(ctsc - ts(lanes.data[start + i]), lanes.tscs[start + i].ma);
     530                                unsigned long long tsc = moving_average(ctsc, ts(lanes.data[start + i]), lanes.tscs[start + i].ma);
    371531                                if(tsc > max) max = tsc;
    372532                        }
    373                         proc->rdq.cutoff = (max + 2 * max) / 2;
     533                        // proc->rdq.cutoff = (max + 2 * max) / 2;
    374534                        /* paranoid */ verify(lanes.count < 65536); // The following code assumes max 65536 cores.
    375535                        /* paranoid */ verify(map.count < 65536); // The following code assumes max 65536 cores.
    … …  
    384544                        }
    385545
    386                         /* paranoid */ verify(proc->rdq.target != -1u);
     546                        /* paranoid */ verify(proc->rdq.target != MAX);
    387547                }
    388548                else {
    389549                        unsigned long long max = 0;
    390550                        for(i; READYQ_SHARD_FACTOR) {
    391                                 unsigned long long tsc = moving_average(ctsc - ts(lanes.data[start + i]), lanes.tscs[start + i].ma);
     551                                unsigned long long tsc = moving_average(ctsc, ts(lanes.data[start + i]), lanes.tscs[start + i].ma);
    392552                                if(tsc > max) max = tsc;
    393553                        }
    … …  
    395555                        {
    396556                                unsigned target = proc->rdq.target;
    397                                 proc->rdq.target = -1u;
     557                                proc->rdq.target = MAX;
    398558                                lanes.help[target / READYQ_SHARD_FACTOR].tri++;
    399                                 if(moving_average(ctsc - lanes.tscs[target].tv, lanes.tscs[target].ma) > cutoff) {
     559                                if(moving_average(ctsc, lanes.tscs[target].tv, lanes.tscs[target].ma) > cutoff) {
    400560                                        thread$ * t = try_pop(cltr, target __STATS(, __tls_stats()->ready.pop.help));
    401561                                        proc->rdq.last = target;
    402562                                        if(t) return t;
    403                                         else proc->rdq.target = -1u;
    404563                                }
    405                                 else proc->rdq.target = -1u;
     564                                proc->rdq.target = MAX;
    406565                        }
    407566
    408567                        unsigned last = proc->rdq.last;
    409                         if(last != -1u && lanes.tscs[last].tv < cutoff && ts(lanes.data[last]) < cutoff) {
     568                        if(last != MAX && moving_average(ctsc, lanes.tscs[last].tv, lanes.tscs[last].ma) > cutoff) {
    410569                                thread$ * t = try_pop(cltr, last __STATS(, __tls_stats()->ready.pop.help));
    411570                                if(t) return t;
    412571                        }
    413572                        else {
    414                                 proc->rdq.last = -1u;
     573                                proc->rdq.last = MAX;
    415574                        }
    416575                }
    … …  
    428587                processor * const proc = kernelTLS().this_processor;
    429588                unsigned last = proc->rdq.last;
    430                 if(last != -1u) {
     589                if(last != MAX) {
    431590                        struct thread$ * t = try_pop(cltr, last __STATS(, __tls_stats()->ready.pop.steal));
    432591                        if(t) return t;
    433                         proc->rdq.last = -1u;
     592                        proc->rdq.last = MAX;
    434593                }
    435594
    … …  
    560719                #else
    561720                        unsigned preferred = thrd->preferred;
    562                         const bool external = (hint != UNPARK_LOCAL) || (!kernelTLS().this_processor) || preferred == -1u || thrd->curr_cluster != cltr;
     721                        const bool external = (hint != UNPARK_LOCAL) || (!kernelTLS().this_processor) || preferred == MAX || thrd->curr_cluster != cltr;
    563722                        /* paranoid */ verifyf(external || preferred < lanes.count, "Invalid preferred queue %u for %u lanes", preferred, lanes.count );
    564723
    … …  
    612771                processor * proc = kernelTLS().this_processor;
    613772
    614                 if(proc->rdq.target == -1u) {
     773                if(proc->rdq.target == MAX) {
    615774                        unsigned long long min = ts(lanes.data[proc->rdq.id]);
    616775                        for(int i = 0; i < READYQ_SHARD_FACTOR; i++) {
    … …  
    623782                else {
    624783                        unsigned target = proc->rdq.target;
    625                         proc->rdq.target = -1u;
     784                        proc->rdq.target = MAX;
    626785                        const unsigned long long bias = 0; //2_500_000_000;
    627786                        const unsigned long long cutoff = proc->rdq.cutoff > bias ? proc->rdq.cutoff - bias : proc->rdq.cutoff;
    … …  
    658817// try to pop from a lane given by index w
    659818static inline struct thread$ * try_pop(struct cluster * cltr, unsigned w __STATS(, __stats_readyQ_pop_t & stats)) with (cltr->ready_queue) {
     819        /* paranoid */ verify( w < lanes.count );
    660820        __STATS( stats.attempt++; )
    661821
    … …  
    681841        // Actually pop the list
    682842        struct thread$ * thrd;
    683         unsigned long long tsc_before = ts(lane);
     843        #if defined(USE_AWARE_STEALING) || defined(USE_WORK_STEALING) || defined(USE_CPU_WORK_STEALING)
     844                unsigned long long tsc_before = ts(lane);
     845        #endif
    684846        unsigned long long tsv;
    685847        [thrd, tsv] = pop(lane);
    … …  
    695857        __STATS( stats.success++; )
    696858
    697         #if defined(USE_WORK_STEALING) || defined(USE_CPU_WORK_STEALING)
    698                 unsigned long long now = rdtscl();
    699                 lanes.tscs[w].tv = tsv;
    700                 lanes.tscs[w].ma = moving_average(now > tsc_before ? now - tsc_before : 0, lanes.tscs[w].ma);
     859        #if defined(USE_AWARE_STEALING) || defined(USE_WORK_STEALING) || defined(USE_CPU_WORK_STEALING)
     860                if (tsv != MAX) {
     861                        unsigned long long now = rdtscl();
     862                        unsigned long long pma = __atomic_load_n(&lanes.tscs[w].ma, __ATOMIC_RELAXED);
     863                        __atomic_store_n(&lanes.tscs[w].tv, tsv, __ATOMIC_RELAXED);
     864                        __atomic_store_n(&lanes.tscs[w].ma, moving_average(now, tsc_before, pma), __ATOMIC_RELAXED);
     865                }
    701866        #endif
    702867
    703         #if defined(USE_CPU_WORK_STEALING)
     868        #if defined(USE_AWARE_STEALING) || defined(USE_CPU_WORK_STEALING)
    704869                thrd->preferred = w / READYQ_SHARD_FACTOR;
    705870        #else
    … …  
    800965                /* paranoid */ verifyf( it, "Unexpected null iterator, at index %u of %u\n", i, count);
    801966                it->rdq.id = value;
    802                 it->rdq.target = -1u;
     967                it->rdq.target = MAX;
    803968                value += READYQ_SHARD_FACTOR;
    804969                it = &(*it)`next;
    … …  
    813978
    814979static void fix_times( struct cluster * cltr ) with( cltr->ready_queue ) {
    815         #if defined(USE_WORK_STEALING)
     980        #if defined(USE_AWARE_STEALING) || defined(USE_WORK_STEALING)
    816981                lanes.tscs = alloc(lanes.count, lanes.tscs`realloc);
    817982                for(i; lanes.count) {
    818                         unsigned long long tsc1 = ts(lanes.data[i]);
    819                         unsigned long long tsc2 = rdtscl();
    820                         lanes.tscs[i].tv = min(tsc1, tsc2);
     983                        lanes.tscs[i].tv = rdtscl();
     984                        lanes.tscs[i].ma = 0;
    821985                }
    822986        #endif
    … …  
    8641028                        // Update original
    8651029                        lanes.count = ncount;
     1030
     1031                        lanes.caches = alloc( target, lanes.caches`realloc );
    8661032                }
    8671033
    … …  
    9401106                                fix(lanes.data[idx]);
    9411107                        }
     1108
     1109                        lanes.caches = alloc( target, lanes.caches`realloc );
    9421110                }
    9431111
    9441112                fix_times(cltr);
     1113
    9451114
    9461115                reassign_cltr_id(cltr);

  • libcfa/src/concurrency/thread.cfa

    r5235d49 r12c1eef  
    1010// Created On       : Tue Jan 17 12:27:26 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Dec  4 09:17:49 2019
    13 // Update Count     : 9
     12// Last Modified On : Thu Jan 13 20:11:55 2022
     13// Update Count     : 42
    1414//
    1515
    … …  
    2525#include "invoke.h"
    2626
    27 uint64_t thread_rand();
     27extern uint32_t __global_random_seed;
    2828
    2929//-----------------------------------------------------------------------------
    3030// Thread ctors and dtors
    31 void ?{}(thread$ & this, const char * const name, cluster & cl, void * storage, size_t storageSize ) with( this ) {
     31void ?{}( thread$ & this, const char * const name, cluster & cl, void * storage, size_t storageSize ) with( this ) {
    3232        context{ 0p, 0p };
    3333        self_cor{ name, storage, storageSize };
    … …  
    4545        preferred = ready_queue_new_preferred();
    4646        last_proc = 0p;
     47        random_state = __global_random_seed;
    4748        #if defined( __CFA_WITH_VERIFY__ )
    4849                canary = 0x0D15EA5E0D15EA5Ep;
    … …  
    171172}
    172173
    173 uint64_t thread_rand() {
    174         disable_interrupts();
    175         uint64_t ret = __tls_rand();
    176         enable_interrupts();
    177         return ret;
    178 }
     174//-----------------------------------------------------------------------------
     175#define GENERATOR LCG
     176
     177void set_seed( uint32_t seed ) {
     178        active_thread()->random_state = __global_random_seed = seed;
     179        GENERATOR( active_thread()->random_state );
     180} // set_seed
     181uint32_t prng( void ) { return GENERATOR( active_thread()->random_state ); } // [0,UINT_MAX]
    179182
    180183// Local Variables: //

  • libcfa/src/concurrency/thread.hfa

    r5235d49 r12c1eef  
    1010// Created On       : Tue Jan 17 12:27:26 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Dec  4 09:18:14 2019
    13 // Update Count     : 6
     12// Last Modified On : Thu Jan  6 16:40:16 2022
     13// Update Count     : 7
    1414//
    1515
    … …  
    6565void ^?{}(thread$ & this);
    6666
    67 static inline void ?{}(thread$ & this)                                                                  { this{ "Anonymous Thread", *mainCluster, 0p, 65000 }; }
     67static inline void ?{}(thread$ & this)                                                                  { this{ "Anonymous Thread", *mainCluster, 0p, DEFAULT_STACK_SIZE }; }
    6868static inline void ?{}(thread$ & this, size_t stackSize )                                               { this{ "Anonymous Thread", *mainCluster, 0p, stackSize }; }
    6969static inline void ?{}(thread$ & this, void * storage, size_t storageSize )                             { this{ "Anonymous Thread", *mainCluster, storage, storageSize }; }
    70 static inline void ?{}(thread$ & this, struct cluster & cl )                                            { this{ "Anonymous Thread", cl, 0p, 65000 }; }
     70static inline void ?{}(thread$ & this, struct cluster & cl )                                            { this{ "Anonymous Thread", cl, 0p, DEFAULT_STACK_SIZE }; }
    7171static inline void ?{}(thread$ & this, struct cluster & cl, size_t stackSize )                          { this{ "Anonymous Thread", cl, 0p, stackSize }; }
    7272static inline void ?{}(thread$ & this, struct cluster & cl, void * storage, size_t storageSize )        { this{ "Anonymous Thread", cl, storage, storageSize }; }
    73 static inline void ?{}(thread$ & this, const char * const name)                                         { this{ name, *mainCluster, 0p, 65000 }; }
    74 static inline void ?{}(thread$ & this, const char * const name, struct cluster & cl )                   { this{ name, cl, 0p, 65000 }; }
     73static inline void ?{}(thread$ & this, const char * const name)                                         { this{ name, *mainCluster, 0p, DEFAULT_STACK_SIZE }; }
     74static inline void ?{}(thread$ & this, const char * const name, struct cluster & cl )                   { this{ name, cl, 0p, DEFAULT_STACK_SIZE }; }
    7575static inline void ?{}(thread$ & this, const char * const name, struct cluster & cl, size_t stackSize ) { this{ name, cl, 0p, stackSize }; }
    7676

  • libcfa/src/device/cpu.cfa

    r5235d49 r12c1eef  
    427427                        unsigned c = pairings[i].cpu;
    428428                        unsigned llc_id = pairings[i].id;
    429                         unsigned width = maps[llc_id].raw->width;
    430429                        unsigned start = maps[llc_id].start;
    431                         unsigned self  = start + (maps[llc_id].count++);
    432                         entries[c].count = width;
     430                        entries[c].count = maps[llc_id].raw->width;
    433431                        entries[c].start = start;
    434                         entries[c].self  = self;
     432                        entries[c].self  = start + (maps[llc_id].count++);
     433                        entries[c].cache = llc_id;
    435434                }
    436435

  • libcfa/src/device/cpu.hfa

    r5235d49 r12c1eef  
    1616#include <stddef.h>
    1717
     18// Map from cpu entry to a structure detailling cpus with common topologies
     19// Note that the cpu-groups are contiguous so the indexing is different from
     20// the cpu indexing
    1821struct cpu_map_entry_t {
     22        // Where this particular cpu is in the group
    1923        unsigned self;
     24
     25        // Starting index of the cpus with the same topology
    2026        unsigned start;
     27
     28        // Number of cpus with the same topology
    2129        unsigned count;
     30
     31        // Index of the cache this entry describes
     32        unsigned cache;
    2233};
    2334

  • libcfa/src/fstream.cfa

    r5235d49 r12c1eef  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Oct 10 11:23:05 2021
    13 // Update Count     : 512
     12// Last Modified On : Mon Jan 10 08:45:05 2022
     13// Update Count     : 513
    1414//
    1515
    … …  
    5252inline void setPrt$( ofstream & os, bool state ) { os.prt$ = state; }
    5353
    54 inline void lock( ofstream & os ) with( os ) {  lock( os.lock$ ); }
     54inline void lock( ofstream & os ) with( os ) { lock( os.lock$ ); }
    5555inline void unlock( ofstream & os ) { unlock( os.lock$ ); }
    5656

  • libcfa/src/heap.cfa

    r5235d49 r12c1eef  
    1010// Created On       : Tue Dec 19 21:58:35 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Aug  9 19:03:02 2021
    13 // Update Count     : 1040
     12// Last Modified On : Sun Jan  2 23:29:41 2022
     13// Update Count     : 1058
    1414//
    1515
    … …  
    263263#ifdef __STATISTICS__
    264264// Heap statistics counters.
    265 static unsigned int malloc_zero_calls, malloc_calls;
    266 static unsigned long long int malloc_storage;
    267 static unsigned int aalloc_zero_calls, aalloc_calls;
    268 static unsigned long long int aalloc_storage;
    269 static unsigned int calloc_zero_calls, calloc_calls;
    270 static unsigned long long int calloc_storage;
    271 static unsigned int memalign_zero_calls, memalign_calls;
    272 static unsigned long long int memalign_storage;
    273 static unsigned int amemalign_zero_calls, amemalign_calls;
    274 static unsigned long long int amemalign_storage;
    275 static unsigned int cmemalign_zero_calls, cmemalign_calls;
    276 static unsigned long long int cmemalign_storage;
    277 static unsigned int resize_zero_calls, resize_calls;
    278 static unsigned long long int resize_storage;
    279 static unsigned int realloc_zero_calls, realloc_calls;
    280 static unsigned long long int realloc_storage;
    281 static unsigned int free_zero_calls, free_calls;
    282 static unsigned long long int free_storage;
     265static unsigned int malloc_calls, malloc_0_calls;
     266static unsigned long long int malloc_storage_request, malloc_storage_alloc;
     267static unsigned int aalloc_calls, aalloc_0_calls;
     268static unsigned long long int aalloc_storage_request, aalloc_storage_alloc;
     269static unsigned int calloc_calls, calloc_0_calls;
     270static unsigned long long int calloc_storage_request, calloc_storage_alloc;
     271static unsigned int memalign_calls, memalign_0_calls;
     272static unsigned long long int memalign_storage_request, memalign_storage_alloc;
     273static unsigned int amemalign_calls, amemalign_0_calls;
     274static unsigned long long int amemalign_storage_request, amemalign_storage_alloc;
     275static unsigned int cmemalign_calls, cmemalign_0_calls;
     276static unsigned long long int cmemalign_storage_request, cmemalign_storage_alloc;
     277static unsigned int resize_calls, resize_0_calls;
     278static unsigned long long int resize_storage_request, resize_storage_alloc;
     279static unsigned int realloc_calls, realloc_0_calls;
     280static unsigned long long int realloc_storage_request, realloc_storage_alloc;
     281static unsigned int free_calls, free_null_calls;
     282static unsigned long long int free_storage_request, free_storage_alloc;
    283283static unsigned int mmap_calls;
    284 static unsigned long long int mmap_storage;
     284static unsigned long long int mmap_storage_request, mmap_storage_alloc;
    285285static unsigned int munmap_calls;
    286 static unsigned long long int munmap_storage;
     286static unsigned long long int munmap_storage_request, munmap_storage_alloc;
    287287static unsigned int sbrk_calls;
    288288static unsigned long long int sbrk_storage;
    … …  
    294294        char helpText[1024];
    295295        __cfaabi_bits_print_buffer( STDERR_FILENO, helpText, sizeof(helpText),
    296                                                                 "\nHeap statistics:\n"
    297                                                                 "  malloc    0-calls %'u; >0-calls %'u; storage %'llu bytes\n"
    298                                                                 "  aalloc    0-calls %'u; >0-calls %'u; storage %'llu bytes\n"
    299                                                                 "  calloc    0-calls %'u; >0-calls %'u; storage %'llu bytes\n"
    300                                                                 "  memalign  0-calls %'u; >0-calls %'u; storage %'llu bytes\n"
    301                                                                 "  amemalign 0-calls %'u; >0-calls %'u; storage %'llu bytes\n"
    302                                                                 "  cmemalign 0-calls %'u; >0-calls %'u; storage %'llu bytes\n"
    303                                                                 "  resize    0-calls %'u; >0-calls %'u; storage %'llu bytes\n"
    304                                                                 "  realloc   0-calls %'u; >0-calls %'u; storage %'llu bytes\n"
    305                                                                 "  free      0-calls %'u; >0-calls %'u; storage %'llu bytes\n"
    306                                                                 "  mmap      calls %'u; storage %'llu bytes\n"
    307                                                                 "  munmap    calls %'u; storage %'llu bytes\n"
    308                                                                 "  sbrk      calls %'u; storage %'llu bytes\n",
    309                                                                 malloc_zero_calls, malloc_calls, malloc_storage,
    310                                                                 aalloc_zero_calls, aalloc_calls, aalloc_storage,
    311                                                                 calloc_zero_calls, calloc_calls, calloc_storage,
    312                                                                 memalign_zero_calls, memalign_calls, memalign_storage,
    313                                                                 amemalign_zero_calls, amemalign_calls, amemalign_storage,
    314                                                                 cmemalign_zero_calls, cmemalign_calls, cmemalign_storage,
    315                                                                 resize_zero_calls, resize_calls, resize_storage,
    316                                                                 realloc_zero_calls, realloc_calls, realloc_storage,
    317                                                                 free_zero_calls, free_calls, free_storage,
    318                                                                 mmap_calls, mmap_storage,
    319                                                                 munmap_calls, munmap_storage,
    320                                                                 sbrk_calls, sbrk_storage
     296                                                                "\nHeap statistics: (storage request / allocation + header)\n"
     297                                                                "  malloc    >0 calls %'u; 0 calls %'u; storage %'llu / %'llu bytes\n"
     298                                                                "  aalloc    >0 calls %'u; 0 calls %'u; storage %'llu / %'llu bytes\n"
     299                                                                "  calloc    >0 calls %'u; 0 calls %'u; storage %'llu / %'llu bytes\n"
     300                                                                "  memalign  >0 calls %'u; 0 calls %'u; storage %'llu / %'llu bytes\n"
     301                                                                "  amemalign >0 calls %'u; 0 calls %'u; storage %'llu / %'llu bytes\n"
     302                                                                "  cmemalign >0 calls %'u; 0 calls %'u; storage %'llu / %'llu bytes\n"
     303                                                                "  resize    >0 calls %'u; 0 calls %'u; storage %'llu / %'llu bytes\n"
     304                                                                "  realloc   >0 calls %'u; 0 calls %'u; storage %'llu / %'llu bytes\n"
     305                                                                "  free      !null calls %'u; null calls %'u; storage %'llu / %'llu bytes\n"
     306                                                                "  sbrk      calls %'u; storage %'llu bytes\n"
     307                                                                "  mmap      calls %'u; storage %'llu / %'llu bytes\n"
     308                                                                "  munmap    calls %'u; storage %'llu / %'llu bytes\n",
     309                                                                malloc_calls, malloc_0_calls, malloc_storage_request, malloc_storage_alloc,
     310                                                                aalloc_calls, aalloc_0_calls, aalloc_storage_request, aalloc_storage_alloc,
     311                                                                calloc_calls, calloc_0_calls, calloc_storage_request, calloc_storage_alloc,
     312                                                                memalign_calls, memalign_0_calls, memalign_storage_request, memalign_storage_alloc,
     313                                                                amemalign_calls, amemalign_0_calls, amemalign_storage_request, amemalign_storage_alloc,
     314                                                                cmemalign_calls, cmemalign_0_calls, cmemalign_storage_request, cmemalign_storage_alloc,
     315                                                                resize_calls, resize_0_calls, resize_storage_request, resize_storage_alloc,
     316                                                                realloc_calls, realloc_0_calls, realloc_storage_request, realloc_storage_alloc,
     317                                                                free_calls, free_null_calls, free_storage_request, free_storage_alloc,
     318                                                                sbrk_calls, sbrk_storage,
     319                                                                mmap_calls, mmap_storage_request, mmap_storage_alloc,
     320                                                                munmap_calls, munmap_storage_request, munmap_storage_alloc
    321321                );
    322322} // printStats
    … …  
    329329                                                "<sizes>\n"
    330330                                                "</sizes>\n"
    331                                                 "<total type=\"malloc\" 0 count=\"%'u;\" >0 count=\"%'u;\" size=\"%'llu\"/> bytes\n"
    332                                                 "<total type=\"aalloc\" 0 count=\"%'u;\" >0 count=\"%'u;\" size=\"%'llu\"/> bytes\n"
    333                                                 "<total type=\"calloc\" 0 count=\"%'u;\" >0 count=\"%'u;\" size=\"%'llu\"/> bytes\n"
    334                                                 "<total type=\"memalign\" 0 count=\"%'u;\" >0 count=\"%'u;\" size=\"%'llu\"/> bytes\n"
    335                                                 "<total type=\"amemalign\" 0 count=\"%'u;\" >0 count=\"%'u;\" size=\"%'llu\"/> bytes\n"
    336                                                 "<total type=\"cmemalign\" 0 count=\"%'u;\" >0 count=\"%'u;\" size=\"%'llu\"/> bytes\n"
    337                                                 "<total type=\"resize\" 0 count=\"%'u;\" >0 count=\"%'u;\" size=\"%'llu\"/> bytes\n"
    338                                                 "<total type=\"realloc\" 0 count=\"%'u;\" >0 count=\"%'u;\" size=\"%'llu\"/> bytes\n"
    339                                                 "<total type=\"free\" 0 count=\"%'u;\" >0 count=\"%'u;\" size=\"%'llu\"/> bytes\n"
    340                                                 "<total type=\"mmap\" count=\"%'u;\" size=\"%'llu\"/> bytes\n"
    341                                                 "<total type=\"munmap\" count=\"%'u;\" size=\"%'llu\"/> bytes\n"
     331                                                "<total type=\"malloc\" >0 count=\"%'u;\" 0 count=\"%'u;\" size=\"%'llu / %'llu\"/> bytes\n"
     332                                                "<total type=\"aalloc\" >0 count=\"%'u;\" 0 count=\"%'u;\" size=\"%'llu / %'llu\"/> bytes\n"
     333                                                "<total type=\"calloc\" >0 count=\"%'u;\" 0 count=\"%'u;\" size=\"%'llu / %'llu\"/> bytes\n"
     334                                                "<total type=\"memalign\" >0 count=\"%'u;\" 0 count=\"%'u;\" size=\"%'llu / %'llu\"/> bytes\n"
     335                                                "<total type=\"amemalign\" >0 count=\"%'u;\" 0 count=\"%'u;\" size=\"%'llu / %'llu\"/> bytes\n"
     336                                                "<total type=\"cmemalign\" >0 count=\"%'u;\" 0 count=\"%'u;\" size=\"%'llu / %'llu\"/> bytes\n"
     337                                                "<total type=\"resize\" >0 count=\"%'u;\" 0 count=\"%'u;\" size=\"%'llu / %'llu\"/> bytes\n"
     338                                                "<total type=\"realloc\" >0 count=\"%'u;\" 0 count=\"%'u;\" size=\"%'llu / %'llu\"/> bytes\n"
     339                                                "<total type=\"free\" !null=\"%'u;\" 0 null=\"%'u;\" size=\"%'llu / %'llu\"/> bytes\n"
    342340                                                "<total type=\"sbrk\" count=\"%'u;\" size=\"%'llu\"/> bytes\n"
     341                                                "<total type=\"mmap\" count=\"%'u;\" size=\"%'llu / %'llu\" / > bytes\n"
     342                                                "<total type=\"munmap\" count=\"%'u;\" size=\"%'llu / %'llu\"/> bytes\n"
    343343                                                "</malloc>",
    344                                                 malloc_zero_calls, malloc_calls, malloc_storage,
    345                                                 aalloc_zero_calls, aalloc_calls, aalloc_storage,
    346                                                 calloc_zero_calls, calloc_calls, calloc_storage,
    347                                                 memalign_zero_calls, memalign_calls, memalign_storage,
    348                                                 amemalign_zero_calls, amemalign_calls, amemalign_storage,
    349                                                 cmemalign_zero_calls, cmemalign_calls, cmemalign_storage,
    350                                                 resize_zero_calls, resize_calls, resize_storage,
    351                                                 realloc_zero_calls, realloc_calls, realloc_storage,
    352                                                 free_zero_calls, free_calls, free_storage,
    353                                                 mmap_calls, mmap_storage,
    354                                                 munmap_calls, munmap_storage,
    355                                                 sbrk_calls, sbrk_storage
     344                                                malloc_calls, malloc_0_calls, malloc_storage_request, malloc_storage_alloc,
     345                                                aalloc_calls, aalloc_0_calls, aalloc_storage_request, aalloc_storage_alloc,
     346                                                calloc_calls, calloc_0_calls, calloc_storage_request, calloc_storage_alloc,
     347                                                memalign_calls, memalign_0_calls, memalign_storage_request, memalign_storage_alloc,
     348                                                amemalign_calls, amemalign_0_calls, amemalign_storage_request, amemalign_storage_alloc,
     349                                                cmemalign_calls, cmemalign_0_calls, cmemalign_storage_request, cmemalign_storage_alloc,
     350                                                resize_calls, resize_0_calls, resize_storage_request, resize_storage_alloc,
     351                                                realloc_calls, realloc_0_calls, realloc_storage_request, realloc_storage_alloc,
     352                                                free_calls, free_null_calls, free_storage_request, free_storage_alloc,
     353                                                sbrk_calls, sbrk_storage,
     354                                                mmap_calls, mmap_storage_request, mmap_storage_alloc,
     355                                                munmap_calls, munmap_storage_request, munmap_storage_alloc
    356356                );
    357357        __cfaabi_bits_write( fileno( stream ), helpText, len ); // ensures all bytes written or exit
    … …  
    577577                #ifdef __STATISTICS__
    578578                __atomic_add_fetch( &mmap_calls, 1, __ATOMIC_SEQ_CST );
    579                 __atomic_add_fetch( &mmap_storage, tsize, __ATOMIC_SEQ_CST );
     579                __atomic_add_fetch( &mmap_storage_request, size, __ATOMIC_SEQ_CST );
     580                __atomic_add_fetch( &mmap_storage_alloc, tsize, __ATOMIC_SEQ_CST );
    580581                #endif // __STATISTICS__
    581582
    … …  
    626627                #ifdef __STATISTICS__
    627628                __atomic_add_fetch( &munmap_calls, 1, __ATOMIC_SEQ_CST );
    628                 __atomic_add_fetch( &munmap_storage, size, __ATOMIC_SEQ_CST );
     629                __atomic_add_fetch( &munmap_storage_request, header->kind.real.size, __ATOMIC_SEQ_CST );
     630                __atomic_add_fetch( &munmap_storage_alloc, size, __ATOMIC_SEQ_CST );
    629631                #endif // __STATISTICS__
    630632                if ( munmap( header, size ) == -1 ) {
    … …  
    642644                #ifdef __STATISTICS__
    643645                __atomic_add_fetch( &free_calls, 1, __ATOMIC_SEQ_CST );
    644                 __atomic_add_fetch( &free_storage, size, __ATOMIC_SEQ_CST );
     646                __atomic_add_fetch( &free_storage_request, header->kind.real.size, __ATOMIC_SEQ_CST );
     647                __atomic_add_fetch( &free_storage_alloc, size, __ATOMIC_SEQ_CST );
    645648                #endif // __STATISTICS__
    646649
    … …  
    819822                if ( likely( size > 0 ) ) {
    820823                        __atomic_add_fetch( &malloc_calls, 1, __ATOMIC_SEQ_CST );
    821                         __atomic_add_fetch( &malloc_storage, size, __ATOMIC_SEQ_CST );
     824                        __atomic_add_fetch( &malloc_storage_request, size, __ATOMIC_SEQ_CST );
    822825                } else {
    823                         __atomic_add_fetch( &malloc_zero_calls, 1, __ATOMIC_SEQ_CST );
     826                        __atomic_add_fetch( &malloc_0_calls, 1, __ATOMIC_SEQ_CST );
    824827                } // if
    825828                #endif // __STATISTICS__
    … …  
    835838                if ( likely( size > 0 ) ) {
    836839                        __atomic_add_fetch( &aalloc_calls, 1, __ATOMIC_SEQ_CST );
    837                         __atomic_add_fetch( &aalloc_storage, size, __ATOMIC_SEQ_CST );
     840                        __atomic_add_fetch( &aalloc_storage_request, size, __ATOMIC_SEQ_CST );
    838841                } else {
    839                         __atomic_add_fetch( &aalloc_zero_calls, 1, __ATOMIC_SEQ_CST );
     842                        __atomic_add_fetch( &aalloc_0_calls, 1, __ATOMIC_SEQ_CST );
    840843                } // if
    841844                #endif // __STATISTICS__
    … …  
    850853          if ( unlikely( size ) == 0 ) {                        // 0 BYTE ALLOCATION RETURNS NULL POINTER
    851854                        #ifdef __STATISTICS__
    852                         __atomic_add_fetch( &calloc_zero_calls, 1, __ATOMIC_SEQ_CST );
     855                        __atomic_add_fetch( &calloc_0_calls, 1, __ATOMIC_SEQ_CST );
    853856                        #endif // __STATISTICS__
    854857                        return 0p;
    … …  
    856859                #ifdef __STATISTICS__
    857860                __atomic_add_fetch( &calloc_calls, 1, __ATOMIC_SEQ_CST );
    858                 __atomic_add_fetch( &calloc_storage, dim * elemSize, __ATOMIC_SEQ_CST );
     861                __atomic_add_fetch( &calloc_storage_request, dim * elemSize, __ATOMIC_SEQ_CST );
    859862                #endif // __STATISTICS__
    860863
    … …  
    891894          if ( unlikely( size == 0 ) ) {                                        // special cases
    892895                        #ifdef __STATISTICS__
    893                         __atomic_add_fetch( &resize_zero_calls, 1, __ATOMIC_SEQ_CST );
     896                        __atomic_add_fetch( &resize_0_calls, 1, __ATOMIC_SEQ_CST );
    894897                        #endif // __STATISTICS__
    895898                        free( oaddr );
    … …  
    902905          if ( unlikely( oaddr == 0p ) ) {
    903906                        #ifdef __STATISTICS__
    904                         __atomic_add_fetch( &resize_storage, size, __ATOMIC_SEQ_CST );
     907                        __atomic_add_fetch( &resize_storage_request, size, __ATOMIC_SEQ_CST );
    905908                        #endif // __STATISTICS__
    906909                        return mallocNoStats( size );
    … …  
    921924
    922925                #ifdef __STATISTICS__
    923                 __atomic_add_fetch( &resize_storage, size, __ATOMIC_SEQ_CST );
     926                __atomic_add_fetch( &resize_storage_request, size, __ATOMIC_SEQ_CST );
    924927                #endif // __STATISTICS__
    925928
    … …  
    936939          if ( unlikely( size == 0 ) ) {                                        // special cases
    937940                        #ifdef __STATISTICS__
    938                         __atomic_add_fetch( &realloc_zero_calls, 1, __ATOMIC_SEQ_CST );
     941                        __atomic_add_fetch( &realloc_0_calls, 1, __ATOMIC_SEQ_CST );
    939942                        #endif // __STATISTICS__
    940943                        free( oaddr );
    … …  
    947950          if ( unlikely( oaddr == 0p ) ) {
    948951                        #ifdef __STATISTICS__
    949                         __atomic_add_fetch( &realloc_storage, size, __ATOMIC_SEQ_CST );
     952                        __atomic_add_fetch( &realloc_storage_request, size, __ATOMIC_SEQ_CST );
    950953                        #endif // __STATISTICS__
    951954                        return mallocNoStats( size );
    … …  
    969972
    970973                #ifdef __STATISTICS__
    971                 __atomic_add_fetch( &realloc_storage, size, __ATOMIC_SEQ_CST );
     974                __atomic_add_fetch( &realloc_storage_request, size, __ATOMIC_SEQ_CST );
    972975                #endif // __STATISTICS__
    973976
    … …  
    10001003                if ( likely( size > 0 ) ) {
    10011004                        __atomic_add_fetch( &memalign_calls, 1, __ATOMIC_SEQ_CST );
    1002                         __atomic_add_fetch( &memalign_storage, size, __ATOMIC_SEQ_CST );
     1005                        __atomic_add_fetch( &memalign_storage_request, size, __ATOMIC_SEQ_CST );
    10031006                } else {
    1004                         __atomic_add_fetch( &memalign_zero_calls, 1, __ATOMIC_SEQ_CST );
     1007                        __atomic_add_fetch( &memalign_0_calls, 1, __ATOMIC_SEQ_CST );
    10051008                } // if
    10061009                #endif // __STATISTICS__
    … …  
    10161019                if ( likely( size > 0 ) ) {
    10171020                        __atomic_add_fetch( &cmemalign_calls, 1, __ATOMIC_SEQ_CST );
    1018                         __atomic_add_fetch( &cmemalign_storage, size, __ATOMIC_SEQ_CST );
     1021                        __atomic_add_fetch( &cmemalign_storage_request, size, __ATOMIC_SEQ_CST );
    10191022                } else {
    1020                         __atomic_add_fetch( &cmemalign_zero_calls, 1, __ATOMIC_SEQ_CST );
     1023                        __atomic_add_fetch( &cmemalign_0_calls, 1, __ATOMIC_SEQ_CST );
    10211024                } // if
    10221025                #endif // __STATISTICS__
    … …  
    10311034          if ( unlikely( size ) == 0 ) {                                        // 0 BYTE ALLOCATION RETURNS NULL POINTER
    10321035                        #ifdef __STATISTICS__
    1033                         __atomic_add_fetch( &cmemalign_zero_calls, 1, __ATOMIC_SEQ_CST );
     1036                        __atomic_add_fetch( &cmemalign_0_calls, 1, __ATOMIC_SEQ_CST );
    10341037                        #endif // __STATISTICS__
    10351038                        return 0p;
    … …  
    10371040                #ifdef __STATISTICS__
    10381041                __atomic_add_fetch( &cmemalign_calls, 1, __ATOMIC_SEQ_CST );
    1039                 __atomic_add_fetch( &cmemalign_storage, dim * elemSize, __ATOMIC_SEQ_CST );
     1042                __atomic_add_fetch( &cmemalign_storage_request, dim * elemSize, __ATOMIC_SEQ_CST );
    10401043                #endif // __STATISTICS__
    10411044
    … …  
    11011104          if ( unlikely( addr == 0p ) ) {                                       // special case
    11021105                        #ifdef __STATISTICS__
    1103                         __atomic_add_fetch( &free_zero_calls, 1, __ATOMIC_SEQ_CST );
     1106                        __atomic_add_fetch( &free_null_calls, 1, __ATOMIC_SEQ_CST );
    11041107                        #endif // __STATISTICS__
    11051108
    … …  
    12801283  if ( unlikely( size == 0 ) ) {                                                // special cases
    12811284                #ifdef __STATISTICS__
    1282                 __atomic_add_fetch( &resize_zero_calls, 1, __ATOMIC_SEQ_CST );
     1285                __atomic_add_fetch( &resize_0_calls, 1, __ATOMIC_SEQ_CST );
    12831286                #endif // __STATISTICS__
    12841287                free( oaddr );
    … …  
    12941297                #ifdef __STATISTICS__
    12951298                __atomic_add_fetch( &resize_calls, 1, __ATOMIC_SEQ_CST );
    1296                 __atomic_add_fetch( &resize_storage, size, __ATOMIC_SEQ_CST );
     1299                __atomic_add_fetch( &resize_storage_request, size, __ATOMIC_SEQ_CST );
    12971300                #endif // __STATISTICS__
    12981301                return memalignNoStats( nalign, size );
    … …  
    13291332
    13301333        #ifdef __STATISTICS__
    1331         __atomic_add_fetch( &resize_storage, size, __ATOMIC_SEQ_CST );
     1334        __atomic_add_fetch( &resize_storage_request, size, __ATOMIC_SEQ_CST );
    13321335        #endif // __STATISTICS__
    13331336
    … …  
    13421345  if ( unlikely( size == 0 ) ) {                                                // special cases
    13431346                #ifdef __STATISTICS__
    1344                 __atomic_add_fetch( &realloc_zero_calls, 1, __ATOMIC_SEQ_CST );
     1347                __atomic_add_fetch( &realloc_0_calls, 1, __ATOMIC_SEQ_CST );
    13451348                #endif // __STATISTICS__
    13461349                free( oaddr );
    … …  
    13561359                #ifdef __STATISTICS__
    13571360                __atomic_add_fetch( &realloc_calls, 1, __ATOMIC_SEQ_CST );
    1358                 __atomic_add_fetch( &realloc_storage, size, __ATOMIC_SEQ_CST );
     1361                __atomic_add_fetch( &realloc_storage_request, size, __ATOMIC_SEQ_CST );
    13591362                #endif // __STATISTICS__
    13601363                return memalignNoStats( nalign, size );
    … …  
    13801383        #ifdef __STATISTICS__
    13811384        __atomic_add_fetch( &realloc_calls, 1, __ATOMIC_SEQ_CST );
    1382         __atomic_add_fetch( &realloc_storage, size, __ATOMIC_SEQ_CST );
     1385        __atomic_add_fetch( &realloc_storage_request, size, __ATOMIC_SEQ_CST );
    13831386        #endif // __STATISTICS__
    13841387

  • libcfa/src/iostream.cfa

    r5235d49 r12c1eef  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Oct 10 09:28:17 2021
    13 // Update Count     : 1345
     12// Last Modified On : Wed Jan 19 08:15:53 2022
     13// Update Count     : 1352
    1414//
    1515
    … …  
    5757        ostype & ?|?( ostype & os, signed char sc ) {
    5858                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
    59                 fmt( os, "%hhd", sc );
     59                fmt( os, "%'hhd", sc );
    6060                return os;
    6161        } // ?|?
    … …  
    6666        ostype & ?|?( ostype & os, unsigned char usc ) {
    6767                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
    68                 fmt( os, "%hhu", usc );
     68                fmt( os, "%'hhu", usc );
    6969                return os;
    7070        } // ?|?
    … …  
    7575        ostype & ?|?( ostype & os, short int si ) {
    7676                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
    77                 fmt( os, "%hd", si );
     77                fmt( os, "%'hd", si );
    7878                return os;
    7979        } // ?|?
    … …  
    8484        ostype & ?|?( ostype & os, unsigned short int usi ) {
    8585                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
    86                 fmt( os, "%hu", usi );
     86                fmt( os, "%'hu", usi );
    8787                return os;
    8888        } // ?|?
    … …  
    9393        ostype & ?|?( ostype & os, int i ) {
    9494                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
    95                 fmt( os, "%d", i );
     95                fmt( os, "%'d", i );
    9696                return os;
    9797        } // ?|?
    … …  
    102102        ostype & ?|?( ostype & os, unsigned int ui ) {
    103103                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
    104                 fmt( os, "%u", ui );
     104                fmt( os, "%'u", ui );
    105105                return os;
    106106        } // ?|?
    … …  
    111111        ostype & ?|?( ostype & os, long int li ) {
    112112                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
    113                 fmt( os, "%ld", li );
     113                fmt( os, "%'ld", li );
    114114                return os;
    115115        } // ?|?
    … …  
    120120        ostype & ?|?( ostype & os, unsigned long int uli ) {
    121121                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
    122                 fmt( os, "%lu", uli );
     122                fmt( os, "%'lu", uli );
    123123                return os;
    124124        } // ?|?
    … …  
    129129        ostype & ?|?( ostype & os, long long int lli ) {
    130130                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
    131                 fmt( os, "%lld", lli );
     131                fmt( os, "%'lld", lli );
    132132                return os;
    133133        } // ?|?
    … …  
    138138        ostype & ?|?( ostype & os, unsigned long long int ulli ) {
    139139                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
    140                 fmt( os, "%llu", ulli );
     140                fmt( os, "%'llu", ulli );
    141141                return os;
    142142        } // ?|?
    … …  
    205205        ostype & ?|?( ostype & os, float f ) {
    206206                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
    207                 PrintWithDP( os, "%g", f );
     207                PrintWithDP( os, "%'g", f );
    208208                return os;
    209209        } // ?|?
    … …  
    214214        ostype & ?|?( ostype & os, double d ) {
    215215                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
    216                 PrintWithDP( os, "%.*lg", d, DBL_DIG );
     216                PrintWithDP( os, "%'.*lg", d, DBL_DIG );
    217217                return os;
    218218        } // ?|?
    … …  
    223223        ostype & ?|?( ostype & os, long double ld ) {
    224224                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
    225                 PrintWithDP( os, "%.*Lg", ld, LDBL_DIG );
     225                PrintWithDP( os, "%'.*Lg", ld, LDBL_DIG );
    226226                return os;
    227227        } // ?|?
    … …  
    233233                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
    234234//              os | crealf( fc ) | nonl;
    235                 PrintWithDP( os, "%g", crealf( fc ) );
    236                 PrintWithDP( os, "%+g", cimagf( fc ) );
     235                PrintWithDP( os, "%'g", crealf( fc ) );
     236                PrintWithDP( os, "%'+g", cimagf( fc ) );
    237237                fmt( os, "i" );
    238238                return os;
    … …  
    245245                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
    246246//              os | creal( dc ) | nonl;
    247                 PrintWithDP( os, "%.*lg", creal( dc ), DBL_DIG );
    248                 PrintWithDP( os, "%+.*lg", cimag( dc ), DBL_DIG );
     247                PrintWithDP( os, "%'.*lg", creal( dc ), DBL_DIG );
     248                PrintWithDP( os, "%'+.*lg", cimag( dc ), DBL_DIG );
    249249                fmt( os, "i" );
    250250                return os;
    … …  
    257257                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
    258258//              os | creall( ldc ) || nonl;
    259                 PrintWithDP( os, "%.*Lg", creall( ldc ), LDBL_DIG );
    260                 PrintWithDP( os, "%+.*Lg", cimagl( ldc ), LDBL_DIG );
     259                PrintWithDP( os, "%'.*Lg", creall( ldc ), LDBL_DIG );
     260                PrintWithDP( os, "%'+.*Lg", cimagl( ldc ), LDBL_DIG );
    261261                fmt( os, "i" );
    262262                return os;
    … …  
    282282                }; // mask
    283283
     284          if ( s == 0p ) { fmt( os, "%s", "0p" ); return os; } // null pointer
    284285          if ( s[0] == '\0' ) { sepOff( os ); return os; } // null string => no separator
    285286
    … …  
    496497                if ( ! f.flags.pc ) memcpy( &fmtstr, IFMTNP, sizeof(IFMTNP) ); \
    497498                else memcpy( &fmtstr, IFMTP, sizeof(IFMTP) ); \
    498                 int star = 4;                                                                   /* position before first '*' */ \
     499                int star = 5;                                                                   /* position before first '*' */ \
    499500\
    500501                /* Insert flags into spaces before '*', from right to left. */ \
    … …  
    503504                if ( f.flags.sign ) { fmtstr[star] = '+'; star -= 1; } \
    504505                if ( f.flags.pad0 && ! f.flags.pc ) { fmtstr[star] = '0'; star -= 1; } \
     506                fmtstr[star] = '\''; star -= 1;                                 /* locale */ \
    505507                fmtstr[star] = '%'; \
    506508\
    … …  
    521523} // distribution
    522524
    523 IntegralFMTImpl( signed char, "     *hh ", "     *.*hh " )
    524 IntegralFMTImpl( unsigned char, "     *hh ", "     *.*hh " )
    525 IntegralFMTImpl( signed short int, "     *h ", "     *.*h " )
    526 IntegralFMTImpl( unsigned short int, "     *h ", "     *.*h " )
    527 IntegralFMTImpl( signed int, "     * ", "     *.* " )
    528 IntegralFMTImpl( unsigned int, "     * ", "     *.* " )
    529 IntegralFMTImpl( signed long int, "     *l ", "     *.*l " )
    530 IntegralFMTImpl( unsigned long int, "     *l ", "     *.*l " )
    531 IntegralFMTImpl( signed long long int, "     *ll ", "     *.*ll " )
    532 IntegralFMTImpl( unsigned long long int, "     *ll ", "     *.*ll " )
     525IntegralFMTImpl( signed char,            "      *hh ", "      *.*hh " )
     526IntegralFMTImpl( unsigned char,          "      *hh ", "      *.*hh " )
     527IntegralFMTImpl( signed short int,       "      *h ",  "      *.*h " )
     528IntegralFMTImpl( unsigned short int,     "      *h ",  "      *.*h " )
     529IntegralFMTImpl( signed int,             "      * ",   "      *.* " )
     530IntegralFMTImpl( unsigned int,           "      * ",   "      *.* " )
     531IntegralFMTImpl( signed long int,        "      *l ",  "      *.*l " )
     532IntegralFMTImpl( unsigned long int,      "      *l ",  "      *.*l " )
     533IntegralFMTImpl( signed long long int,   "      *ll ", "      *.*ll " )
     534IntegralFMTImpl( unsigned long long int, "      *ll ", "      *.*ll " )
    533535
    534536
    … …  
    692694                if ( ! f.flags.pc ) memcpy( &fmtstr, DFMTNP, sizeof(DFMTNP) ); \
    693695                else memcpy( &fmtstr, DFMTP, sizeof(DFMTP) ); \
    694                 int star = 4;                                                                   /* position before first '*' */ \
     696                int star = 5;                                                                   /* position before first '*' */ \
    695697\
    696698                /* Insert flags into spaces before '*', from right to left. */ \
    … …  
    698700                if ( f.flags.sign ) { fmtstr[star] = '+'; star -= 1; } \
    699701                if ( f.flags.pad0 ) { fmtstr[star] = '0'; star -= 1; } \
     702                fmtstr[star] = '\''; star -= 1;                                 /* locale */ \
    700703                fmtstr[star] = '%'; \
    701704\
    … …  
    715718} // distribution
    716719
    717 FloatingPointFMTImpl( double, "     * ", "     *.* " )
    718 FloatingPointFMTImpl( long double, "     *L ", "     *.*L " )
     720FloatingPointFMTImpl( double,      "      * ",  "      *.* " )
     721FloatingPointFMTImpl( long double, "      *L ", "      *.*L " )
    719722
    720723// *********************************** character ***********************************

  • libcfa/src/parseconfig.cfa

    r5235d49 r12c1eef  
     1
     2
     3#pragma GCC diagnostic push
     4//#pragma GCC diagnostic ignored "-Wunused-parameter"
     5//#pragma GCC diagnostic ignored "-Wunused-function"
     6//#pragma GCC diagnostic ignored "-Wuninitialized"
     7//#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
     8
    19#include <fstream.hfa>
    210#include <parseargs.hfa>
    … …  
    1927// TODO: use string interface when it's ready (and implement exception msg protocol)
    2028[ void ] msg( * Missing_Config_Entries ex ) {
    21         serr | nlOff;
    22         serr | "The config file is missing " | ex->num_missing;
    23         serr | nlOn;
    24         if ( ex->num_missing == 1 ) {
    25                 serr | " entry.";
    26         } else {
    27                 serr | " entries.";
    28         }
     29        serr | "The config file is missing " | ex->num_missing | "entr" | sepOff | (ex->num_missing == 1 ? "y." : "ies.");
    2930} // msg
    3031
    … …  
    223224        return value < zero_val;
    224225}
     226#pragma GCC diagnostic pop
    225227
    226228

  • libcfa/src/startup.cfa

    r5235d49 r12c1eef  
    1010// Created On       : Tue Jul 24 16:21:57 2018
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Jan  9 23:18:23 2021
    13 // Update Count     : 34
     12// Last Modified On : Mon Jan 17 16:41:54 2022
     13// Update Count     : 55
    1414//
    1515
    … …  
    1717#include <locale.h>                                                                             // setlocale
    1818#include <stdlib.h>                                                                             // getenv
     19#include "bits/defs.hfa"                                                                // rdtscl
    1920#include "startup.hfa"
     21
     22extern uint32_t __global_random_seed;                                   // sequential/concurrent
     23extern uint32_t __global_random_state;                                  // sequential
    2024
    2125extern "C" {
    … …  
    2327        void __cfaabi_appready_startup( void ) {
    2428                tzset();                                                                                // initialize time global variables
    25                 setlocale( LC_NUMERIC, getenv("LANG") );
    2629                #ifdef __CFA_DEBUG__
    2730                extern void heapAppStart();
    … …  
    4851        void __cfaabi_core_startup( void ) __attribute__(( constructor( STARTUP_PRIORITY_CORE ) ));
    4952        void __cfaabi_core_startup( void ) {
     53                __global_random_state = __global_random_seed = rdtscl();
    5054                __cfaabi_interpose_startup();
    5155                __cfaabi_device_startup();

  • libcfa/src/stdlib.cfa

    r5235d49 r12c1eef  
    1010// Created On       : Thu Jan 28 17:10:29 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Dec 29 15:32:44 2021
    13 // Update Count     : 512
     12// Last Modified On : Thu Jan 13 21:38:30 2022
     13// Update Count     : 593
    1414//
    1515
    1616#include "stdlib.hfa"
     17#include "bits/random.hfa"
     18#include "concurrency/invoke.h"                                                 // random_state
    1719
    1820//---------------------------------------
    … …  
    221223//---------------------------------------
    222224
    223 static uint32_t seed = 0;                                                               // current seed
    224 static thread_local uint32_t state;                                             // random state
    225 
    226 void set_seed( uint32_t seed_ ) { state = seed = seed_; }
    227 uint32_t get_seed() { return seed; }
    228 
    229225#define GENERATOR LCG
    230226
    231 inline uint32_t MarsagliaXor( uint32_t & state ) {
    232         if ( unlikely( seed == 0 ) ) set_seed( rdtscl() );
    233         else if ( unlikely( state == 0 ) ) state = seed;
    234         state ^= state << 6;
    235         state ^= state >> 21;
    236         state ^= state << 7;
    237         return state;
    238 } // MarsagliaXor
    239 
    240 inline uint32_t LCG( uint32_t & state ) {                               // linear congruential generator
    241         if ( unlikely( seed == 0 ) ) set_seed( rdtscl() );
    242         else if ( unlikely( state == 0 ) ) state = seed;
    243         return state = 36973 * (state & 65535) + (state >> 16);
    244 } // LCG
    245 
     227uint32_t __global_random_seed;                                                  // sequential/concurrent
     228uint32_t __global_random_state;                                         // sequential only
     229
     230void set_seed( PRNG & prng, uint32_t seed_ ) with( prng ) { state = seed = seed_; GENERATOR( state ); } // set seed
    246231uint32_t prng( PRNG & prng ) with( prng ) { callcnt += 1; return GENERATOR( state ); }
    247232
    248 uint32_t prng( void ) { return GENERATOR( state ); }
     233void set_seed( uint32_t seed ) { __global_random_seed = seed; GENERATOR( __global_random_state ); }
     234uint32_t get_seed() { return __global_random_seed; }
     235uint32_t prng( void ) { return GENERATOR( __global_random_state ); } // [0,UINT_MAX]
    249236
    250237//---------------------------------------

  • libcfa/src/stdlib.hfa

    r5235d49 r12c1eef  
    1010// Created On       : Thu Jan 28 17:12:35 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Dec 29 15:30:58 2021
    13 // Update Count     : 591
     12// Last Modified On : Thu Jan 13 21:34:46 2022
     13// Update Count     : 636
    1414//
    1515
    … …  
    2121#include <stdlib.h>                                                                             // *alloc, strto*, ato*
    2222#include <heap.hfa>
     23
    2324
    2425// Reduce includes by explicitly defining these routines.
    … …  
    4344//---------------------------------------
    4445
    45 // Macro because of returns
    46 #define ARRAY_ALLOC$( allocation, alignment, dim ) \
    47         if ( _Alignof(T) <= libAlign() ) return (T *)(void *)allocation( dim, (size_t)sizeof(T) ); /* C allocation */ \
    48         else return (T *)alignment( _Alignof(T), dim, sizeof(T) )
    49 
    5046static inline forall( T & | sized(T) ) {
    5147        // CFA safe equivalents, i.e., implicit size specification
    5248
    5349        T * malloc( void ) {
    54                 if ( _Alignof(T) <= libAlign() ) return (T *)(void *)malloc( (size_t)sizeof(T) ); // C allocation
     50                if ( _Alignof(T) <= libAlign() ) return (T *)malloc( sizeof(T) ); // C allocation
    5551                else return (T *)memalign( _Alignof(T), sizeof(T) );
    5652        } // malloc
    5753
    5854        T * aalloc( size_t dim ) {
    59                 ARRAY_ALLOC$( aalloc, amemalign, dim );
     55                if ( _Alignof(T) <= libAlign() ) return (T *)aalloc( dim, sizeof(T) ); // C allocation
     56                else return (T *)amemalign( _Alignof(T), dim, sizeof(T) );
    6057        } // aalloc
    6158
    6259        T * calloc( size_t dim ) {
    63                 ARRAY_ALLOC$( calloc, cmemalign, dim );
     60                if ( _Alignof(T) <= libAlign() ) return (T *)calloc( dim, sizeof(T) ); // C allocation
     61                else return (T *)cmemalign( _Alignof(T), dim, sizeof(T) );
    6462        } // calloc
    6563
    6664        T * resize( T * ptr, size_t size ) {                            // CFA resize, eliminate return-type cast
    67                 if ( _Alignof(T) <= libAlign() ) return (T *)(void *)resize( (void *)ptr, size ); // CFA resize
    68                 else return (T *)(void *)resize( (void *)ptr, _Alignof(T), size ); // CFA resize
     65                if ( _Alignof(T) <= libAlign() ) return (T *)resize( (void *)ptr, size ); // CFA resize
     66                else return (T *)resize( (void *)ptr, _Alignof(T), size ); // CFA resize
    6967        } // resize
    7068
    7169        T * realloc( T * ptr, size_t size ) {                           // CFA realloc, eliminate return-type cast
    72                 if ( _Alignof(T) <= libAlign() ) return (T *)(void *)realloc( (void *)ptr, size ); // C realloc
    73                 else return (T *)(void *)realloc( (void *)ptr, _Alignof(T), size ); // CFA realloc
     70                if ( _Alignof(T) <= libAlign() ) return (T *)realloc( (void *)ptr, size ); // C realloc
     71                else return (T *)realloc( (void *)ptr, _Alignof(T), size ); // CFA realloc
    7472        } // realloc
    7573
    … …  
    210208
    211209        forall( TT... | { T * alloc_internal$( void *, T *, size_t, size_t, S_fill(T), TT ); } ) {
    212 
    213210                T * alloc_internal$( void *       , T * Realloc, size_t Align, size_t Dim, S_fill(T) Fill, T_resize Resize, TT rest) {
    214211                return alloc_internal$( Resize, (T*)0p, Align, Dim, Fill, rest);
    … …  
    234231                return alloc_internal$( (void*)0p, (T*)0p, (_Alignof(T) > libAlign() ? _Alignof(T) : libAlign()), dim, (S_fill(T)){'0'}, all);
    235232            }
    236 
    237233        } // distribution TT
    238234} // distribution T
    … …  
    388384//---------------------------------------
    389385
     386// Sequential Pseudo Random-Number Generator : generate repeatable sequence of values that appear random.
     387//
     388// Declaration :
     389//   PRNG sprng = { 1009 } - set starting seed versus random seed
     390//   
     391// Interface :
     392//   set_seed( sprng, 1009 ) - set starting seed for ALL kernel threads versus random seed
     393//   get_seed( sprng ) - read seed
     394//   prng( sprng ) - generate random value in range [0,UINT_MAX]
     395//   prng( sprng, u ) - generate random value in range [0,u)
     396//   prng( sprng, l, u ) - generate random value in range [l,u]
     397//   calls( sprng ) - number of generated random value so far
     398//
     399// Examples : generate random number between 5-21
     400//   prng( sprng ) % 17 + 5;    values 0-16 + 5 = 5-21
     401//   prng( sprng, 16 + 1 ) + 5;
     402//   prng( sprng, 5, 21 );
     403//   calls( sprng );
     404
    390405struct PRNG {
    391406        uint32_t callcnt;                                                                       // call count
    … …  
    394409}; // PRNG
    395410
    396 extern uint32_t prng( PRNG & prng ) __attribute__(( warn_unused_result )); // [0,UINT_MAX]
     411void set_seed( PRNG & prng, uint32_t seed_ );
     412uint32_t prng( PRNG & prng ) __attribute__(( warn_unused_result )); // [0,UINT_MAX]
    397413static inline {
    398         void set_seed( PRNG & prng, uint32_t seed_ ) with( prng ) { state = seed = seed_; } // set seed
    399414        void ?{}( PRNG & prng ) { set_seed( prng, rdtscl() ); } // random seed
    400415        void ?{}( PRNG & prng, uint32_t seed ) { set_seed( prng, seed ); } // fixed seed
    … …  
    405420} // distribution
    406421
    407 extern void set_seed( uint32_t seed );                                  // set per thread seed
    408 extern uint32_t get_seed();                                                             // get seed
    409 extern uint32_t prng( void ) __attribute__(( warn_unused_result )); // [0,UINT_MAX]
     422// Concurrent Pseudo Random-Number Generator : generate repeatable sequence of values that appear random.
     423//
     424// Interface :
     425//   set_seed( 1009 ) - fixed seed for all kernel threads versus random seed
     426//   get_seed() - read seed
     427//   prng() - generate random value in range [0,UINT_MAX]
     428//   prng( u ) - generate random value in range [0,u)
     429//   prng( l, u ) - generate random value in range [l,u]
     430//
     431// Examples : generate random number between 5-21
     432//   prng() % 17 + 5;   values 0-16 + 5 = 5-21
     433//   prng( 16 + 1 ) + 5;
     434//   prng( 5, 21 );
     435
     436void set_seed( uint32_t seed_ ) OPTIONAL_THREAD;
     437uint32_t get_seed() __attribute__(( warn_unused_result ));
     438uint32_t prng( void ) __attribute__(( warn_unused_result )) OPTIONAL_THREAD; // [0,UINT_MAX]
    410439static inline {
    411         uint32_t prng( uint32_t u ) __attribute__(( warn_unused_result ));
    412         uint32_t prng( uint32_t u ) { return prng() % u; }      // [0,u)
    413         uint32_t prng( uint32_t l, uint32_t u ) __attribute__(( warn_unused_result ));
    414         uint32_t prng( uint32_t l, uint32_t u ) { return prng( u - l + 1 ) + l; } // [l,u]
     440        uint32_t prng( uint32_t u ) __attribute__(( warn_unused_result )) { return prng() % u; } // [0,u)
     441        uint32_t prng( uint32_t l, uint32_t u ) __attribute__(( warn_unused_result )) { return prng( u - l + 1 ) + l; } // [l,u]
    415442} // distribution
    416443

  • src/AST/Decl.cpp

    r5235d49 r12c1eef  
    2626#include "Node.hpp"            // for readonly
    2727#include "Type.hpp"            // for readonly
     28#include "Expr.hpp"
    2829
    2930namespace ast {
    … …  
    6566        for (auto & tp : this->type_params) {
    6667                ftype->forall.emplace_back(new TypeInstType(tp->name, tp));
     68                for (auto & ap: tp->assertions) {
     69                        ftype->assertions.emplace_back(new VariableExpr(loc, ap));
     70                }
    6771        }
    6872        this->type = ftype;

  • src/AST/Decl.hpp

    r5235d49 r12c1eef  
    3434// Must be included in *all* AST classes; should be #undef'd at the end of the file
    3535#define MUTATE_FRIEND \
    36     template<typename node_t> friend node_t * mutate(const node_t * node); \
     36        template<typename node_t> friend node_t * mutate(const node_t * node); \
    3737        template<typename node_t> friend node_t * shallowCopy(const node_t * node);
    3838
    … …  
    135135        std::vector< ptr<Expr> > withExprs;
    136136
    137 
    138137        FunctionDecl( const CodeLocation & loc, const std::string & name, std::vector<ptr<TypeDecl>>&& forall,
    139138                std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,

  • src/AST/Eval.hpp

    r5235d49 r12c1eef  
    2424template< typename... Args >
    2525UntypedExpr * call( const CodeLocation & loc, const std::string & name, Args &&... args ) {
    26         return new UntypedExpr { 
    27                 loc, new NameExpr { loc, name }, 
     26        return new UntypedExpr {
     27                loc, new NameExpr { loc, name },
    2828                std::vector< ptr< Expr > > { std::forward< Args >( args )... } };
    2929}

  • src/Validate/InitializerLength.cpp

    r5235d49 r12c1eef  
    1414//
    1515
    16 //#include "InitializerLength.hpp"
     16#include "InitializerLength.hpp"
    1717
    1818#include "AST/Expr.hpp"

  • src/Validate/InitializerLength.hpp

    r5235d49 r12c1eef  
    1414//
    1515
     16#pragma once
     17
     18namespace ast {
     19        class TranslationUnit;
     20}
     21
    1622namespace Validate {
    1723

  • tests/device/cpu.cfa

    r5235d49 r12c1eef  
    1515
    1616
     17#include <device/cpu.hfa>
     18#include <limits.hfa>
    1719#include <fstream.hfa>
    18 #include <device/cpu.hfa>
    1920#include <stdlib.hfa>
    2021
    … …  
    118119
    119120        unsigned found_level = 0;
    120         unsigned found = -1u;
     121        unsigned found = MAX;
    121122        for(i; idxs) {
    122123                unsigned idx = idxs - 1 - i;
    … …  
    136137        }
    137138
    138         /* paranoid */ verify(found != -1u);
     139        /* paranoid */ verify(found != MAX);
    139140        return found;
    140141}

  • tests/io/io-acquire.cfa

    r5235d49 r12c1eef  
    1010// Created On       : Mon Mar  1 18:40:09 2021
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Oct  6 18:04:58 2021
    13 // Update Count     : 72
     12// Last Modified On : Fri Jan 14 09:13:18 2022
     13// Update Count     : 74
    1414//
    1515
    … …  
    1818#include <mutex_stmt.hfa>
    1919
     20Duration default_preemption() { return 0; }
     21
    2022thread T {};
    2123void main( T & ) {
    … …  
    2325
    2426        for ( 100 ) {                                                                           // expression protection
    25                 mutex(sout) sout | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
     27                mutex( sout ) sout | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
    2628        }
    2729        mutex( sout ) {                                                                         // statement protection
    … …  
    5153        int a, b, c, d, e, f, g, h, i;
    5254        for ( 100 ) {                                                                           // expression protection
    53                 mutex(sin) sin | a | b | c | d | e | f | g | h | i;
     55                mutex( sin ) sin | a | b | c | d | e | f | g | h | i;
    5456        }
    5557        mutex( sin ) {                                                                          // statement protection

  • tests/unified_locking/.expect/locks.txt

    r5235d49 r12c1eef  
    1111Start Test 6: owner lock and condition variable 3 wait/notify all
    1212Done Test 6
    13 Start Test 7: fast lock and condition variable single wait/notify
     13Start Test 7: linear backoff lock and condition variable single wait/notify
    1414Done Test 7
    15 Start Test 8: fast lock and condition variable 3 wait/notify all
     15Start Test 8: linear backoff lock and condition variable 3 wait/notify all
    1616Done Test 8
    17 Start Test 9: linear backoff lock and condition variable single wait/notify
     17Start Test 9: multi acquisiton lock and condition variable multiple acquire and wait/notify
    1818Done Test 9
    19 Start Test 10: linear backoff lock and condition variable 3 wait/notify all
     19Start Test 10: owner lock and condition variable multiple acquire and wait/notify
    2020Done Test 10
    21 Start Test 11: multi acquisiton lock and condition variable multiple acquire and wait/notify
     21Start Test 11: no lock condition variable wait/notify
    2222Done Test 11
    23 Start Test 12: owner lock and condition variable multiple acquire and wait/notify
     23Start Test 12: locked condition variable wait/notify with front()
    2424Done Test 12
    25 Start Test 13: no lock condition variable wait/notify
    26 Done Test 13
    27 Start Test 14: locked condition variable wait/notify with front()
    28 Done Test 14

  • tests/unified_locking/locks.cfa

    r5235d49 r12c1eef  
    1515condition_variable( owner_lock ) c_o;
    1616
    17 fast_lock f;
    18 condition_variable( fast_lock ) c_f;
    19 
    2017linear_backoff_then_block_lock l;
    2118condition_variable( linear_backoff_then_block_lock ) c_l;
    … …  
    7471                }
    7572                unlock(s);
    76         }
    77 }
    78 
    79 thread T_C_F_WS1 {};
    80 
    81 void main( T_C_F_WS1 & this ) {
    82         for (unsigned int i = 0; i < num_times; i++) {
    83                 lock(f);
    84                 if(empty(c_f) && i != num_times - 1) {
    85                         wait(c_f,f);
    86                 }else{
    87                         notify_one(c_f);
    88                 }
    89                 unlock(f);
    90         }
    91 }
    92 
    93 thread T_C_F_WB1 {};
    94 
    95 void main( T_C_F_WB1 & this ) {
    96         for (unsigned int i = 0; i < num_times; i++) {
    97                 lock(f);
    98                 if(counter(c_f) == 3 || i == num_times - 1) {
    99                         notify_all(c_f);
    100                 }else{
    101                         wait(c_f,f);
    102                 }
    103                 unlock(f);
    10473        }
    10574}
    … …  
    317286        printf("Done Test 6\n");
    318287
    319         printf("Start Test 7: fast lock and condition variable single wait/notify\n");
    320         {
    321                 T_C_F_WS1 t1[2];
     288        printf("Start Test 7: linear backoff lock and condition variable single wait/notify\n");
     289        {
     290                T_C_L_WS1 t1[2];
    322291        }
    323292        printf("Done Test 7\n");
    324293
    325         printf("Start Test 8: fast lock and condition variable 3 wait/notify all\n");
    326         {
    327                 T_C_F_WB1 t1[4];
     294        printf("Start Test 8: linear backoff lock and condition variable 3 wait/notify all\n");
     295        {
     296                T_C_L_WB1 t1[4];
    328297        }
    329298        printf("Done Test 8\n");
    330299
    331         printf("Start Test 9: linear backoff lock and condition variable single wait/notify\n");
    332         {
    333                 T_C_L_WS1 t1[2];
     300        printf("Start Test 9: multi acquisiton lock and condition variable multiple acquire and wait/notify\n");
     301        {
     302                T_C_M_WS2 t1[2];
    334303        }
    335304        printf("Done Test 9\n");
    336305
    337         printf("Start Test 10: linear backoff lock and condition variable 3 wait/notify all\n");
    338         {
    339                 T_C_L_WB1 t1[4];
     306        printf("Start Test 10: owner lock and condition variable multiple acquire and wait/notify\n");
     307        {
     308                T_C_O_WS2 t1[2];
    340309        }
    341310        printf("Done Test 10\n");
    342311
    343         printf("Start Test 11: multi acquisiton lock and condition variable multiple acquire and wait/notify\n");
    344         {
    345                 T_C_M_WS2 t1[2];
    346         }
    347         printf("Done Test 11\n");
    348 
    349         printf("Start Test 12: owner lock and condition variable multiple acquire and wait/notify\n");
    350         {
    351                 T_C_O_WS2 t1[2];
    352         }
    353         printf("Done Test 12\n");
    354 
    355         printf("Start Test 13: no lock condition variable wait/notify\n");
     312        printf("Start Test 11: no lock condition variable wait/notify\n");
    356313        {
    357314                T_C_NLW t1;
    358315                T_C_NLS t2;
    359316        }
    360         printf("Done Test 13\n");
    361 
    362         printf("Start Test 14: locked condition variable wait/notify with front()\n");
     317        printf("Done Test 11\n");
     318
     319        printf("Start Test 12: locked condition variable wait/notify with front()\n");
    363320        {
    364321                T_C_S_WNF t1[2];
    365322        }
    366         printf("Done Test 14\n");
    367 }
     323        printf("Done Test 12\n");
     324}

  • tests/unified_locking/mutex_test.hfa

    r5235d49 r12c1eef  
    1010        thread$ * id;
    1111        uint32_t sum;
     12        uint32_t cnt;
    1213};
    1314
    … …  
    2728        {
    2829                uint32_t tsum = mo.sum;
     30                uint32_t cnt = mo.cnt;
    2931                mo.id = me;
    3032                yield(random(5));
    3133                value = ((uint32_t)random()) ^ ((uint32_t)me);
    3234                if(mo.id != me) sout | "Intruder!";
     35                mo.cnt = cnt + 1;
    3336                mo.sum = tsum + value;
    3437        }
    … …  
    5457        uint32_t sum = -32;
    5558        mo.sum = -32;
     59        mo.cnt = 0;
    5660        processor p[2];
    5761        sout | "Starting";
    … …  
    6367        }
    6468        sout | "Done!";
     69        if(mo.cnt != (13 * num_times)) sout | "Invalid cs count!" | mo.cnt | "vs "| (13 * num_times) | "(13 *" | num_times | ')';
    6570        if(sum == mo.sum) sout | "Match!";
    6671        else sout | "No Match!" | sum | "vs" | mo.sum;

  • tools/jenkins/setup.sh.in

    r5235d49 r12c1eef  
    4848                regex1='/([[:alpha:][:digit:]@/_.-]+)'
    4949                regex2='(libcfa[[:alpha:][:digit:].]+) => not found'
    50                 regex3='linux-vdso.so.1'
     50                regex3='linux-vdso.so.1|linux-gate.so.1'
    5151                if [[ $line =~ $regex1 ]]; then
    5252                        retsysdeps+=(${BASH_REMATCH[1]})
Note: See TracChangeset for help on using the changeset viewer.