Changes in / [75d874a:0e16a2d]


Ignore:
Files:
1 added
20 edited

Legend:

Unmodified
Added
Removed

  • doc/theses/mike_brooks_MMath/list.tex

    r75d874a r0e16a2d  
    1313
    1414
     15
    1516\section{Design Issues}
    1617\label{toc:lst:issue}
    … …  
    1920
    2021All design-issue discussions assume the following invariants.
    21 \PAB{They are stated here to clarify that none of the discussed design issues refers to one of these.}
     22They are stated here to clarify that none of the discussed design issues refers to one of these.
    2223Alternatives to the assumptions are discussed under Future Work (Section~\ref{toc:lst:futwork}).
    2324\begin{itemize}
    … …  
    2930          The system has freedom over how to represent these links.
    3031          The library is not providing applied wrapper operations that consume a user's hand-implemented list primitives.
    31     \item \PAB{These issues are compared at a requirement/functional level.}
     32    \item These issues are compared at a requirement/functional level.
    3233\end{itemize}
    3334
    3435Two preexisting linked-list libraries are used throughout, to show examples of the concepts being defined,
    3536and further libraries are introduced as needed.
     37A general comparison of libraries' abilities is given under Related Work (Section~\ref{toc:lst:relwork}).
    3638\begin{description}
    3739    \item[LQ] Linux Queue library\cite{lst:linuxq} of @<sys/queue.h>@.
    3840    \item[STL] C++ Standard Template Library's @std::list@\cite{lst:stl}
    3941\end{description}
    40 A general comparison of libraries' abilities is given under Related Work (Section~\ref{toc:lst:relwork}).
    4142
    4243The fictional type @req@ (request) is the user's payload in examples.
    … …  
    5758
    5859The wrapped style admits the further distinction between wrapping a reference and wrapping a value.
    59 This distinction is pervasive in all STL collections; @list<req *>@ wraps a reference; @list<req>@ wraps a value.
    60 (For this discussion, @list<req &>@ is similar to @list<req *>@.)
     60This distinction is pervasive in all STL collections; @list<req*>@ wraps a reference; @list<req>@ wraps a value.
     61(For this discussion, @list<req&>@ is similar to @list<req*>@.)
    6162This difference is one of user style, not framework capability.
    62 Figure~\ref{fig:lst-issues-attach} compares the three styles.
    63 
    64 \begin{comment}
     63
    6564\begin{figure}
    6665    \begin{tabularx}{\textwidth}{Y|Y|Y}\lstinputlisting[language=C  , firstline=20, lastline=39]{lst-issues-intrusive.run.c}
    … …  
    7877        (a) & (b) & (c)
    7978    \end{tabularx}
    80 \caption{
     79    \caption{
    8180        Three styles of link attachment: (a)~intrusive, (b)~wrapped reference, and (c)~wrapped value.
    8281        The diagrams show the memory layouts that result after the code runs, eliding the head object \lstinline{reqs};
    … …  
    8887        (TODO: cite? found in  /usr/include/c++/7/bits/stl\_list.h )
    8988    }
    90      \label{fig:lst-issues-attach}
    91 \end{figure}
    92 \end{comment}
    93 
    94 \begin{figure}
    95 \centering
    96 \newsavebox{\myboxA}                                    % used with subfigure
    97 \newsavebox{\myboxB}
    98 \newsavebox{\myboxC}
    99 
    100 \begin{lrbox}{\myboxA}
    101 \begin{tabular}{@{}l@{}}
    102 \lstinputlisting[language=C, firstline=20, lastline=39]{lst-issues-intrusive.run.c} \\
    103 \ \\
    104 \includegraphics[page=1]{lst-issues-attach.pdf}
    105 \end{tabular}
    106 \end{lrbox}
    107 
    108 \begin{lrbox}{\myboxB}
    109 \begin{tabular}{@{}l@{}}
    110 \lstinputlisting[language=C++, firstline=20, lastline=39]{lst-issues-wrapped-byref.run.cpp} \\
    111 \ \\
    112 \includegraphics[page=2]{lst-issues-attach.pdf}
    113 \end{tabular}
    114 \end{lrbox}
    115 
    116 \begin{lrbox}{\myboxC}
    117 \begin{tabular}{@{}l@{}}
    118 \lstinputlisting[language=C++, firstline=20, lastline=39]{lst-issues-wrapped-emplaced.run.cpp} \\
    119 \ \\
    120 \includegraphics[page=3]{lst-issues-attach.pdf}
    121 \end{tabular}
    122 \end{lrbox}
    123 
    124 \subfloat[Intrusive]{\label{f:Intrusive}\usebox\myboxA}
    125 \hspace{10pt}
    126 \vrule
    127 \hspace{10pt}
    128 \subfloat[Wrapped reference]{\label{f:WrappedRef}\usebox\myboxB}
    129 \hspace{10pt}
    130 \vrule
    131 \hspace{10pt}
    132 \subfloat[Wrapped value]{\label{f:WrappedValue}\usebox\myboxC}
    133 
    134 \caption{
    135         Three styles of link attachment: \protect\subref*{f:Intrusive}~intrusive, \protect\subref*{f:WrappedRef}~wrapped
    136         reference, and \protect\subref*{f:WrappedValue}~wrapped value.
    137         The diagrams show the memory layouts that result after the code runs, eliding the head object \lstinline{reqs};
    138         head objects are discussed in Section~\ref{toc:lst:issue:ident}.
    139         In \protect\subref*{f:Intrusive}, the field \lstinline{req.x} names a list direction;
    140         these are discussed in Section~\ref{toc:lst:issue:derection}.
    141         In \protect\subref*{f:WrappedRef} and \protect\subref*{f:WrappedValue}, the type \lstinline{node} represents a
    142         system-internal type, which is \lstinline{std::_List_node} in the GNU implementation.
    143         (TODO: cite? found in  /usr/include/c++/7/bits/stl\_list.h )
    144     }
    14589    \label{fig:lst-issues-attach}
    14690\end{figure}
     91
     92
     93Figure~\ref{fig:lst-issues-attach} compares the three styles.
    14794
    14895The advantage of intrusive attachment is the control that it gives the user over memory layout.
    … …  
    15097Both wrapped attachment styles imply system-induced heap allocations.
    15198Such an allocation has a lifetime that matches the item's membership in the list.
    152 In \subref*{f:Intrusive} and \subref*{f:WrappedRef}, one @req@ object can enter and leave a list many times.
    153 In \subref*{f:WrappedRef}, it implies a dynamic allocation/deallocation for each enter/leave; in \subref*{f:Intrusive}, it does not.
     99In (a) and (b), one @req@ object can enter and leave a list many times.
     100In (b), doing do implies a dynamic allocation for each time joining; in (a), it does not.
    154101
    155102A further aspect of layout control is allowing the user to specify the location of the link fields within the @req@ object.
    … …  
    163110Another subtle advantage of intrusive arrangement is that
    164111a reference to a user-level item (@req@) is sufficient to navigate or manage the item's membership.
    165 In LQ, \subref*{f:Intrusive}, a @req@ pointer is the right argument type for operations @LIST_NEXT@ or @LIST_REMOVE@;
     112In LQ, (a), a @req@ pointer is the right argument type for operations @LIST_NEXT@ or @LIST_REMOVE@;
    166113there is no distinguishing a @req@ from ``a @req@ in a list.''
    167 The same is not true of STL, \subref*{f:WrappedRef} or \subref*{f:WrappedValue}.
     114The same is not true of STL, (b) or (c).
    168115There, the analogous operations work on a parameter of type @list<T>::iterator@;
    169116they are @iterator::operator++()@, @iterator::operator*()@, and @list::erase(iterator)@.
    170 There is no mapping from @req &@ to @list<req>::iterator@, except for linear search.
     117There is no mapping from @req&@ to @list<req>::iterator@, except for linear search.
    171118
    172119The advantage of wrapped attachment is the abstraction of a data item from its list membership(s).
    173120In the wrapped style, the @req@ type can come from a library that serves many independent uses,
    174121which generally have no need for listing.
    175 Then, a novel use can still put @req@ in a (further) list, without requiring any upstream change in the @req@ library.
     122Then, a novel use can still put @req@ in a (further) list, without requiring any upstream change in the @re@ library.
    176123In intrusive attachment, the ability to be listed must be planned during the definition of @req@.
    177 Similarly, style \subref*{f:WrappedRef} allows for one @req@ to occur at several positions in one list.
    178 Styles \subref*{f:Intrusive} and \subref*{f:WrappedValue} do not support this ability.
    179 \PAB{But style \subref*{f:WrappedValue} can sort of mimic this effect by have multiple copies of \lstinline{req} in the list, modulo changes to the copies are not seen by the original.}
     124Similarly, style (b) allows for one @req@ to occur at several positions in one list.
     125Styles (a) and (c) do not support this ability.
    180126
    181127\begin{figure}
    … …  
    189135        the LQ C macros do not expand to valid C++ when instantiated with template parameters---there is no \lstinline{struct El}.
    190136        When using a custom-patched version of LQ to work around this issue,
    191         the programs of Figure~\ref{f:WrappedRef} and \protect\subref*{f:WrappedValue} work with this shim in place of real STL.
     137        the programs of Figure~\ref{fig:lst-issues-attach}~(b) and (c) work with this shim in place of real STL.
    192138        Their executions lead to the same memory layouts.
    193139    }
    … …  
    201147
    202148So intrusion is a lower-level listing primitive.
    203 And so, the system design choice is not between forcing users to use intrusion or wrapping.
     149And so, the system design choice is not between forcing users to use intrusion and forcing them to use wrapping.
    204150The choice is whether or not to provide access to an allocation-free layer of functionality.
    205151A wrapped-primitive library like STL forces users to incur the costs of wrapping, whether or not they access its benefits.
    … …  
    207153
    208154
     155
     156
    209157\subsection{Directionality: Single vs.\ Multi-Static vs.\ Dynamic}
    210158\label{toc:lst:issue:derection}
    211159
    212 \PAB{I'm not sure about the term \newterm{Directionality}. Directionality to me, means going forward or backwards through a list.
    213 Would \newterm{dimensionality} work? Think of each list containing the node as a different dimension in which the node sits.}
    214 
    215160Directionality deals with the question:
    216161In how many different lists can an item be stored, at a given time?
    217162
    218 Consider STL in the wrapped-value arrangement of Figure~\ref{f:WrappedValue}.
     163
     164Consider STL in the wrapped-value arrangement of Figure~\ref{fig:lst-issues-attach}~(c).
    219165The STL API completely hides its @node@ type from a user; the user cannot configure this choice or impose a custom one.
    220166STL's @node@ type offers the sole set of links shown in the diagram.
    221 Therefore, every @req@ in existence is allocated either to belong to an occurrence of the diagrammed arrangement,
     167Therefore, every @req@ in existence was allocated either to belong to an occurrence of the diagrammed arrangement,
    222168or to be apart from all occurrences of it.
    223169In the first case, the @req@ belongs to exactly one list (of the style in question).
    … …  
    225171
    226172\begin{figure}
     173    \label{fig:lst-issues-multi-static}
    227174    \parbox[t]{3.5in} {
    228175        \lstinputlisting[language=C++, firstline=20, lastline=60]{lst-issues-multi-static.run.c}
    … …  
    240187        The zoomed-in diagram portion shows the field-level state that results from running the LQ code.
    241188    }
    242     \label{fig:lst-issues-multi-static}
    243189\end{figure}
    244190
    … …  
    259205The corresponding flexibility of wrapped attachment means
    260206the STL wrapped-reference arrangement supports an item being a member of arbitrarily many lists.
    261 This support also applies to the wrapped-value list because the @req@ is copied,
     207This support also applies to the hybrid in which an item's allocation is within a wrapped-value list,
    262208but wrapped-reference lists provide further link directions.
    263 \PAB{Explain how}
    264209STL with wrapped references supports dynamic link directions.
    265 \PAB{Expand}
    266 
    267 When allowing multiple static directions, frameworks differ in their ergonomics for
    268 the typical case: when the user needs only one direction, vs.\ the atypical case, when the user needs several.
     210
     211When allowing multiple static directions,frameworks differ in their ergonomics for
     212the typical case, when the user needs only one direction, vs.\ the atypical case, when the user needs several.
     213
    269214LQ's ergonomics are well-suited to the uncommon case of multiple list directions.
    270215Its intrusion declaration and insertion operation both use a mandatory explicit parameter naming the direction.
    271216This decision works well in Figure~\ref{fig:lst-issues-multi-static}, where the names @by_pri@ and @by_rqr@ work well,
    272 but it clutters Figure~\ref{f:Intrusive}, where a contrived name must be invented and used.
    273 The example uses @x@; @reqs@ would be a more readily ignored choice. \PAB{wording?}
     217but it clutters Figure~\ref{fig:lst-issues-attach}~(a), where a contrived name must be invented and used.
     218The example uses @x@; @reqs@ would be a more readily ignored choice.
    274219
    275220\uCpp offers an intrusive list that makes the opposite choice.  TODO: elaborate on inheritance for first direction and acrobatics for subsequent directions.
    276221
    277222
     223
     224
    278225\subsection{User integration: Preprocessed vs.\ Type-System Mediated}
    279226
    280227% example of poor error message due to LQ's preprocessed integration
    281 % programs/lst-issues-multi-static.run.c:46:1: error: expected identifier or '(' before 'do'
     228% programs/lst-issues-multi-static.run.c:46:1: error: expected identifier or ‘(’ before ‘do’
    282229%    46 | LIST_INSERT_HEAD(&reqs_rtr_42, &r42b, by_rqr);
    283230%       | ^~~~~~~~~~~~~~~~
    … …  
    292239an item found in a list (type @req@, of variables like @r1@), and
    293240a list (type @reql@ or @list<req>@, of variables like @reqs@ or @reqs_rqr_42@).
    294 \see{Figure~\ref{fig:lst-issues-attach} and Figure~\ref{fig:lst-issues-multi-static}}
    295 The latter type is a head, and these examples are of headed lists.
     241The latter type is a head, and these examples are of are headed lists.
    296242
    297243A bespoke ``pointer to next @req@'' implementation often omits the latter type.
    … …  
    300246In headed thinking, there are length-zero lists (heads with no elements), and an element can be listed or not listed.
    301247In ad-hoc thinking, there are no length-zero lists and every element belongs to a list of length at least one.
    302 \PAB{Create a figure for this.}
    303248
    304249By omitting the head, elements can enter into an adjacency relationship,
    … …  
    338283identifies a list using an explicit head.
    339284
    340 The \CFA list library's version of the running @req@ example is in Figure~\ref{fig:lst-features-intro}.
    341 Its link attachment is intrusive and the resulting memory layout is pure-stack, just as for the LQ version of Figure~\ref{f:Intrusive}.
    342 The framework-provided type @dlink(...)@ provides the links.
    343 The user inserts the links into the @req@ structure by using \CFA inline-inheritance (TODO: reference introduction).
    344 Inline inheritance means the type of the field is @dlink(req)@, the field is unnamed, a reference to a @req@ is implicitly convertible to @dlink@.\footnote{
     285
     286\begin{figure}
     287    \label{fig:lst-features-intro}
     288    \lstinputlisting[language=CFA, firstline=20, lastline=32]{lst-features-intro.run.cfa}
     289    \caption[Multiple link directions in \CFA list library]{
     290        Demonstration of the running \lstinline{req} example, done using the \CFA list library\protect\footnotemark.
     291        This example does the same job that Figure~\ref{fig:lst-issues-attach} shows three ways.
     292    }
     293\end{figure}
     294\footnotetext{
    345295    The \CFA list examples elide the \lstinline{P9_EMBEDDED} annotations that (TODO: xref P9E future work) proposes to obviate.
    346296    Thus, these examples illustrate a to-be state, free of what is to be historic clutter.
    347297    The elided portions are immaterial to the discussion and the examples work with the annotations provided.
    348     The \CFA test suite (TODO:cite?) includes equivalent demonstrations, with the annotations included.}
    349 These links have a nontrivial, user-specified location within the @req@ structure;
    350 this convention encapsulates the implied pointer arithmetic safely.
    351 
    352 \begin{figure}
    353     \lstinputlisting[language=CFA, firstline=20, lastline=32]{lst-features-intro.run.cfa}
    354     \caption[Multiple link directions in \CFA list library]{
    355         Demonstration of the running \lstinline{req} example, done using the \CFA list library.
    356         This example does the same job that Figure~\ref{fig:lst-issues-attach} shows three ways.
    357     }
    358     \label{fig:lst-features-intro}
    359 \end{figure}
    360 
    361 \begin{figure}
    362 \centering
    363 \begin{tabular}{@{}ll@{}}
    364 \begin{tabular}{@{}l@{}}
    365     \lstinputlisting[language=CFA, firstline=20, lastline=25]{lst-features-multidir.run.cfa} \\
     298    The \CFA test suite (TODO:cite?) includes equivalent demonstrations, with the annotations included.
     299}.
     300
     301My \CFA list library's version of the running @req@ example is in Figure~\ref{fig:lst-features-intro}.
     302Its link attachment is intrusive and the resulting memory layout is pure-stack, just as for the LQ version of Figure~\ref{fig:lst-issues-attach}-(a).
     303The framework-provided type @dlink(-)@ provides the links.
     304The user puts links into the @req@ structure by inline-inheriting (TODO: reference introduction) this type.
     305Which means: the type of the field is @dlink(req)@; the field is unnamed; a reference to a @req@ is implicitly convertible to @dlink@.
     306As these links have a nontrivial, user-specified location within the @req@ structure, this conversion also encapsulates the implied pointer arithmetic safely.
     307
     308\begin{figure}
     309    \label{fig:lst-features-multidir}
     310    \lstinputlisting[language=CFA, firstline=20, lastline=25]{lst-features-multidir.run.cfa}
    366311    \lstinputlisting[language=CFA, firstline=40, lastline=67]{lst-features-multidir.run.cfa}
    367     \end{tabular}
    368         &
    369         \lstinputlisting[language=C++, firstline=20, lastline=60]{lst-issues-multi-static.run.c}
    370         \end{tabular}
    371 
    372 \caption{
     312    \caption{
    373313        Demonstration of multiple static link directions done in the \CFA list library.
    374314        This example does the same job as Figure~\ref{fig:lst-issues-multi-static}.
    375315    }
    376     \label{fig:lst-features-multidir}
    377 \end{figure}
    378 
    379 Figure~\ref{fig:lst-features-multidir} shows how the \CFA library supports multi-static link directionality.
     316\end{figure}
     317
     318The \CFA library supports multi-static link directionality.  Figure~\ref{fig:lst-features-multidir} illustrates how.
    380319The declaration of @req@ now has two inline-inheriting @dlink@ occurrences.
    381 The first of these lines gives a type named @req.by_pri@, @req@ inherits from it, and it inherits from @dlink@.
    382 The second line @req.by_rqr@ is similar to @req.by_pri@.
     320The first of these lines gives a type named @req.by_pri@; @req@ inherits from it; it inherits from @dlink@.
     321The second line gives a similar @req.by_rqr@.
    383322Thus, there is a diamond, non-virtual, inheritance from @req@ to @dlink@, with @by_pri@ and @by_rqr@ being the mid-level types.
    384323Disambiguation occurs in the declarations of the list-head objects.
    385324The type of the variable @reqs_pri_global@ is @dlist(req, req.by_pri)@,
    386325meaning operations called on @reqs_pri_global@ are implicitly disambiguated.
    387 In the example, the calls @insert_first(reqs_pri_global, ...)@ imply, ``here, we are working by priority.''
     326In the example, the calls @insert_first(reqs_pri_global, ...)@ imply, ``here, we're working by priority.''
    388327
    389328The \CFA library also supports the common case, of single directionality, more naturally than LQ. 
    390329Figure~\ref{fig:lst-features-intro} shows a single-direction list done with no contrived name for the link direction,
    391 where Figure~\ref{f:Intrusive} adds the unnecessary name, @x@.
     330where Figure~\ref{fig:lst-issues-attach}-(a) adds the unnecessary name, @x@.
    392331In \CFA, a user doing a single direction (Figure~\ref{fig:lst-features-intro})
    393 sets up a simple inheritance with @dlink@, and declares a list head to have the simpler type @dlist(...)@.
     332sets up a simple inheritance with @dlink@, and declares a list head to have the simpler type @dlist(-)@.
    394333While a user doing multiple link directions (Figure~\ref{fig:lst-features-multidir})
    395 sets up a diamond inheritance with @dlink@, and declares a list head to have the more-informed type @dlist(..., DIR)@.
     334sets up a diamond inheritance with @dlink@, and declares a list head to have the more-informed type @dlist(-, DIR)@.
    396335
    397336The \CFA library offers a type-system mediated integration with user code.
    … …  
    409348
    410349
     350
     351
     352
    411353\subsection{Iteration}
    412354

  • doc/theses/mike_brooks_MMath/uw-ethesis.tex

    r75d874a r0e16a2d  
    6060% For hyperlinked PDF, suitable for viewing on a computer, use this:
    6161\documentclass[letterpaper,12pt,titlepage,oneside,final]{book}
    62 \usepackage{times}
    6362\usepackage[T1]{fontenc}        % Latin-1 => 256-bit characters, => | not dash, <> not Spanish question marks
    6463
    … …  
    8887\usepackage{comment} % Removes large sections of the document.
    8988\usepackage{tabularx}
    90 \usepackage[labelformat=simple,aboveskip=0pt,farskip=0pt,font=normalsize]{subfig}
    91 \renewcommand\thesubfigure{(\alph{subfigure})}
     89\usepackage{subfigure}
    9290
    9391\usepackage{algorithm}
    9492\usepackage{algpseudocode}
     93
     94\usepackage{pbox}
    9595
    9696% Hyperlinks make it very easy to navigate an electronic document.
    … …  
    117117    citecolor=blue,        % color of links to bibliography
    118118    filecolor=magenta,      % color of file links
    119     urlcolor=blue,           % color of external links
    120     breaklinks=true
     119    urlcolor=blue           % color of external links
    121120}
    122121\ifthenelse{\boolean{PrintVersion}}{   % for improved print quality, change some hyperref options
    … …  
    181180\CFAStyle                                               % CFA code-style
    182181\lstset{language=CFA}                                   % default language
    183 \lstset{basicstyle=\linespread{0.9}\sf}                 % CFA typewriter font
     182\lstset{basicstyle=\linespread{0.9}\tt}                 % CFA typewriter font
    184183\lstset{inputpath={programs}}
    185184\newcommand{\PAB}[1]{{\color{red}PAB: #1}}
    186185
    187 \newcommand{\uCpp}{$\mu$\CC}
     186
     187\newcommand{\uCpp}{$\mu${C}{\kern-.1em\hbox{\large\texttt{+\kern-.25em+}}}}
    188188
    189189%======================================================================

  • libcfa/src/bits/random.hfa

    r75d874a r0e16a2d  
    1010// Created On       : Fri Jan 14 07:18:11 2022
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Mar 20 21:45:24 2023
    13 // Update Count     : 186
     12// Last Modified On : Mon Mar 20 10:01:40 2023
     13// Update Count     : 180
    1414//
    1515
    … …  
    131131#ifdef __cforall                                                                                // don't include in C code (invoke.h)
    132132
     133// Splitmix64
    133134// https://rosettacode.org/wiki/Pseudo-random_numbers/Splitmix64
    134 //
    135 // Splitmix64 is not recommended for demanding random number requirements, but is often used to calculate initial states
    136 // for other more complex pseudo-random number generators (see https://prng.di.unimi.it).
    137 // Also https://rosettacode.org/wiki/Pseudo-random_numbers/Splitmix64.
     135// Splitmix64 is not recommended for demanding random number requirements,
     136// but is often used to calculate initial states for other more complex
     137// pseudo-random number generators.                             
    138138static inline uint64_t splitmix64( uint64_t & state ) {
    139139    state += 0x9e3779b97f4a7c15;
    … …  
    149149} // splitmix64_set_seed
    150150
     151// Splitmix32
    151152// https://github.com/bryc/code/blob/master/jshash/PRNGs.md#splitmix32
    152 //
    153 // Splitmix32 is not recommended for demanding random number requirements, but is often used to calculate initial states
    154 // for other more complex pseudo-random number generators (see https://prng.di.unimi.it).
    155 
     153// Splitmix32 is not recommended for demanding random number requirements,
     154// but is often used to calculate initial states for other more complex
     155// pseudo-random number generators.
     156// SplitMix32 is a 32 bit variant of Splitmix64
    156157static inline uint32_t splitmix32( uint32_t & state ) {
    157158    state += 0x9e3779b9;
    … …  
    168169
    169170#ifdef __SIZEOF_INT128__
    170 //--------------------------------------------------
    171 static inline uint64_t lehmer64( __uint128_t & state ) {
    172         __uint128_t ret = state;
    173         state *= 0x_da94_2042_e4dd_58b5;
    174         return ret >> 64;
    175 } // lehmer64
    176 
    177 static inline void lehmer64_set_seed( __uint128_t & state, uint64_t seed ) {
    178         // The seed needs to be coprime with the 2^64 modulus to get the largest period, so no factors of 2 in the seed.
    179         state = splitmix64( seed );                                                     // prime
    180 } // lehmer64_set_seed
    181 
    182 //--------------------------------------------------
    183 static inline uint64_t wyhash64( uint64_t & state ) {
    184         uint64_t ret = state;
    185         state += 0x_60be_e2be_e120_fc15;
    186         __uint128_t tmp;
    187         tmp = (__uint128_t) ret * 0x_a3b1_9535_4a39_b70d;
    188         uint64_t m1 = (tmp >> 64) ^ tmp;
    189         tmp = (__uint128_t)m1 * 0x_1b03_7387_12fa_d5c9;
    190         uint64_t m2 = (tmp >> 64) ^ tmp;
    191         return m2;
    192 } // wyhash64
    193 
    194 static inline void wyhash64_set_seed( uint64_t & state, uint64_t seed ) {
    195         state = splitmix64( seed );                                                     // prime
    196 } // wyhash64_set_seed
     171        //--------------------------------------------------
     172        static inline uint64_t lehmer64( __uint128_t & state ) {
     173                __uint128_t ret = state;
     174                state *= 0x_da94_2042_e4dd_58b5;
     175                return ret >> 64;
     176        } // lehmer64
     177
     178        static inline void lehmer64_set_seed( __uint128_t & state, uint64_t seed ) {
     179                // The seed needs to be coprime with the 2^64 modulus to get the largest period, so no factors of 2 in the seed.
     180                state = seed;
     181                lehmer64( state );                                                              // prime
     182        } // lehmer64_set_seed
     183
     184        //--------------------------------------------------
     185        static inline uint64_t wyhash64( uint64_t & state ) {
     186                uint64_t ret = state;
     187                state += 0x_60be_e2be_e120_fc15;
     188                __uint128_t tmp;
     189                tmp = (__uint128_t) ret * 0x_a3b1_9535_4a39_b70d;
     190                uint64_t m1 = (tmp >> 64) ^ tmp;
     191                tmp = (__uint128_t)m1 * 0x_1b03_7387_12fa_d5c9;
     192                uint64_t m2 = (tmp >> 64) ^ tmp;
     193                return m2;
     194        } // wyhash64
    197195#endif // __SIZEOF_INT128__
    198196
    … …  
    229227
    230228static inline void xoshiro256pp_set_seed( xoshiro256pp_t & state, uint64_t seed ) {
    231     // To attain repeatable seeding, compute seeds separately because the order of argument evaluation is undefined.
    232     uint64_t seed1 = splitmix64( seed );                                // prime
     229    // these are done explicitly in this order to attain repeatable seeding.
     230    // do not call splitmix64 directly in the state init since order of argument evaluation
     231    // may not be consistent leading to irreproducible seeding
     232    uint64_t seed1 = splitmix64( seed );
    233233    uint64_t seed2 = splitmix64( seed );
    234234    uint64_t seed3 = splitmix64( seed );
    235235    uint64_t seed4 = splitmix64( seed );
    236236        state = (xoshiro256pp_t){ seed1, seed2, seed3, seed4 };
     237        xoshiro256pp( state );                                                          // prime
    237238} // xoshiro256pp_set_seed
    238239
    … …  
    268269
    269270static inline void xoshiro128pp_set_seed( xoshiro128pp_t & state, uint32_t seed ) {
    270     // To attain repeatable seeding, compute seeds separately because the order of argument evaluation is undefined.
    271     uint32_t seed1 = splitmix32( seed );                                // prime
     271    // these are done explicitly in this order to attain repeatable seeding.
     272    // do not call splitmix32 directly in the state init since order of argument evaluation
     273    // may not be consistent leading to irreproducible seeding
     274    uint32_t seed1 = splitmix32( seed );
    272275    uint32_t seed2 = splitmix32( seed );
    273276    uint32_t seed3 = splitmix32( seed );
    274277    uint32_t seed4 = splitmix32( seed );
    275278        state = (xoshiro128pp_t){ seed1, seed2, seed3, seed4 };
     279        xoshiro128pp( state );                                                          // prime
    276280} // xoshiro128pp_set_seed
    277281
    … …  
    286290
    287291static inline void xorshift_13_7_17_set_seed( uint64_t & state, uint64_t seed ) {
    288         state = splitmix64( seed );                                                     // prime
     292        state = seed;
     293        xorshift_13_7_17( state );                                                      // prime
    289294} // xorshift_13_7_17_set_seed
    290295
    … …  
    303308
    304309static inline void xorshift_6_21_7_set_seed( uint32_t & state, uint32_t seed ) {
    305     state = splitmix32( seed );                                                 // prime
     310        state = seed;
     311        xorshift_6_21_7( state );                                                       // prime
    306312} // xorshift_6_21_7_set_seed
    307313
    … …  
    317323
    318324static inline void xorshift_12_25_27_set_seed( uint64_t & state, uint64_t seed ) {
    319         state = splitmix64( seed );                                                     // prime
     325        state = seed;
     326        xorshift_12_25_27( state );                                                     // prime
    320327} // xorshift_12_25_27_set_seed
    321328
    … …  
    338345
    339346static inline void kiss_64_set_seed( kiss_64_t & rs, uint64_t seed ) with(rs) {
    340         z = 1; w = 1; jsr = 4; jcong = splitmix64( seed );      // prime
     347        z = 1; w = 1; jsr = 4; jcong = seed;
     348        kiss_64( rs );                                                                          // prime
    341349} // kiss_64_set_seed
    342350
    … …  
    366374
    367375static inline void xorwow_set_seed( xorwow_t & rs, uint32_t seed ) {
    368     // To attain repeatable seeding, compute seeds separately because the order of argument evaluation is undefined.
    369     uint32_t seed1 = splitmix32( seed );                                // prime
     376    // these are done explicitly in this order to attain repeatable seeding.
     377    // do not call splitmix32 directly in the state init since order of argument evaluation
     378    // may not be consistent leading to irreproducible seeding
     379    uint32_t seed1 = splitmix32( seed );
    370380    uint32_t seed2 = splitmix32( seed );
    371381    uint32_t seed3 = splitmix32( seed );
    372382    uint32_t seed4 = splitmix32( seed );
    373383        rs = (xorwow_t){ seed1, seed2, seed3, seed4, 0 };
     384        xorwow( rs );                                                                           // prime
    374385} // xorwow_set_seed
    375386
    … …  
    377388// Used in __tls_rand_fwd
    378389#define M  (1_l64u << 48_l64u)
    379 #define A  (25_214_903_917_l64u)
    380 #define AI (18_446_708_753_438_544_741_l64u)
     390#define A  (25214903917_l64u)
     391#define AI (18446708753438544741_l64u)
    381392#define C  (11_l64u)
    382393#define D  (16_l64u)

  • libcfa/src/concurrency/channel.hfa

    r75d874a r0e16a2d  
    22
    33#include <locks.hfa>
    4 #include <list.hfa>
    5 
    6 #define __COOP_CHANNEL
     4
     5struct no_reacq_lock {
     6    inline exp_backoff_then_block_lock;
     7};
     8
     9// have to override these by hand to get around plan 9 inheritance bug where resolver can't find the appropriate routine to call
     10static inline void   ?{}( no_reacq_lock & this ) { ((exp_backoff_then_block_lock &)this){}; }
     11static inline bool   try_lock(no_reacq_lock & this) { return try_lock(((exp_backoff_then_block_lock &)this)); }
     12static inline void   lock(no_reacq_lock & this) { lock(((exp_backoff_then_block_lock &)this)); }
     13static inline void   unlock(no_reacq_lock & this) { unlock(((exp_backoff_then_block_lock &)this)); }
     14static inline void   on_notify(no_reacq_lock & this, struct thread$ * t ) { on_notify(((exp_backoff_then_block_lock &)this), t); }
     15static inline size_t on_wait(no_reacq_lock & this) { return on_wait(((exp_backoff_then_block_lock &)this)); }
     16// override wakeup so that we don't reacquire the lock if using a condvar
     17static inline void   on_wakeup( no_reacq_lock & this, size_t recursion ) {}
     18
     19#define __PREVENTION_CHANNEL
    720#ifdef __PREVENTION_CHANNEL
    821forall( T ) {
    922struct channel {
    10     size_t size, count, front, back;
     23    size_t size;
     24    size_t front, back, count;
    1125    T * buffer;
    1226    thread$ * chair;
    … …  
    7387        return;
    7488    }
    75     insert_( chan, elem );
     89    else insert_( chan, elem );
    7690
    7791    unlock( mutex_lock );
    … …  
    96110
    97111    // wait if buffer is empty, work will be completed by someone else
    98     if ( count == 0 ) {
     112    if ( count == 0 ) { 
    99113        chair = active_thread();
    100114        chair_elem = &retval;
    … …  
    107121    memcpy((void *)&retval, (void *)&buffer[front], sizeof(T));
    108122    count -= 1;
    109     front++;
    110     if ( front == size ) front = 0;
     123    front = (front + 1) % size;
    111124
    112125    if ( chair != 0p ) {
    … …  
    129142
    130143#ifdef __COOP_CHANNEL
    131 
    132 // link field used for threads waiting on channel
    133 struct wait_link {
    134     // used to put wait_link on a dl queue
    135     inline dlink(wait_link);
    136 
    137     // waiting thread
    138     struct thread$ * t;
    139 
    140     // shadow field
    141     void * elem;
    142 };
    143 P9_EMBEDDED( wait_link, dlink(wait_link) )
    144 
    145 static inline void ?{}( wait_link & this, thread$ * t, void * elem ) {
    146     this.t = t;
    147     this.elem = elem;
    148 }
    149 
    150144forall( T ) {
    151 
    152145struct channel {
    153146    size_t size;
    154147    size_t front, back, count;
    155148    T * buffer;
    156     dlist( wait_link ) prods, cons;
    157     exp_backoff_then_block_lock mutex_lock;
     149    fast_cond_var( no_reacq_lock ) prods, cons;
     150    no_reacq_lock mutex_lock;
    158151};
    159152
    … …  
    171164static inline size_t get_count( channel(T) & chan ) with(chan) { return count; }
    172165static inline size_t get_size( channel(T) & chan ) with(chan) { return size; }
    173 static inline bool has_waiters( channel(T) & chan ) with(chan) { return !cons`isEmpty || !prods`isEmpty; }
    174 static inline bool has_waiting_consumers( channel(T) & chan ) with(chan) { return !cons`isEmpty; }
    175 static inline bool has_waiting_producers( channel(T) & chan ) with(chan) { return !prods`isEmpty; }
     166static inline bool has_waiters( channel(T) & chan ) with(chan) { return !empty( cons ) || !empty( prods ); }
     167static inline bool has_waiting_consumers( channel(T) & chan ) with(chan) { return !empty( cons ); }
     168static inline bool has_waiting_producers( channel(T) & chan ) with(chan) { return !empty( prods ); }
    176169
    177170static inline void insert_( channel(T) & chan, T & elem ) with(chan) {
    … …  
    182175}
    183176
    184 static inline void wake_one( dlist( wait_link ) & queue ) {
    185     wait_link & popped = try_pop_front( queue );
    186     unpark( popped.t );
    187 }
    188 
    189 static inline void block( dlist( wait_link ) & queue, void * elem_ptr, exp_backoff_then_block_lock & lock ) {
    190     wait_link w{ active_thread(), elem_ptr };
    191     insert_last( queue, w );
    192     unlock( lock );
    193     park();
    194 }
    195177
    196178static inline void insert( channel(T) & chan, T elem ) with(chan) {
    … …  
    198180
    199181    // have to check for the zero size channel case
    200     if ( size == 0 && !cons`isEmpty ) {
    201         memcpy(cons`first.elem, (void *)&elem, sizeof(T));
    202         wake_one( cons );
     182    if ( size == 0 && !empty( cons ) ) {
     183        memcpy((void *)front( cons ), (void *)&elem, sizeof(T));
     184        notify_one( cons );
    203185        unlock( mutex_lock );
    204186        return;
    … …  
    206188
    207189    // wait if buffer is full, work will be completed by someone else
    208     if ( count == size ) {
    209         block( prods, &elem, mutex_lock );
     190    if ( count == size ) { 
     191        wait( prods, mutex_lock, (uintptr_t)&elem );
    210192        return;
    211193    } // if
    212194
    213     if ( count == 0 && !cons`isEmpty ) {
    214         memcpy(cons`first.elem, (void *)&elem, sizeof(T)); // do waiting consumer work
    215         wake_one( cons );
    216     } else insert_( chan, elem );
     195    if ( count == 0 && !empty( cons ) )
     196        // do waiting consumer work
     197        memcpy((void *)front( cons ), (void *)&elem, sizeof(T));
     198    else insert_( chan, elem );
    217199   
     200    notify_one( cons );
    218201    unlock( mutex_lock );
    219202}
    … …  
    224207
    225208    // have to check for the zero size channel case
    226     if ( size == 0 && !prods`isEmpty ) {
    227         memcpy((void *)&retval, (void *)prods`first.elem, sizeof(T));
    228         wake_one( prods );
     209    if ( size == 0 && !empty( prods ) ) {
     210        memcpy((void *)&retval, (void *)front( prods ), sizeof(T));
     211        notify_one( prods );
    229212        unlock( mutex_lock );
    230213        return retval;
    … …  
    232215
    233216    // wait if buffer is empty, work will be completed by someone else
    234     if (count == 0) {
    235         block( cons, &retval, mutex_lock );
     217    if (count == 0) { 
     218        wait( cons, mutex_lock, (uintptr_t)&retval );
    236219        return retval;
    237220    }
    … …  
    242225    front = (front + 1) % size;
    243226
    244     if (count == size - 1 && !prods`isEmpty ) {
    245         insert_( chan, *(T *)prods`first.elem );  // do waiting producer work
    246         wake_one( prods );
    247     }
    248 
     227    if (count == size - 1 && !empty( prods ) )
     228        insert_( chan, *((T *)front( prods )) );  // do waiting producer work
     229
     230    notify_one( prods );
    249231    unlock( mutex_lock );
    250232    return retval;
    251233}
     234
    252235} // forall( T )
    253236#endif

  • libcfa/src/concurrency/io.cfa

    r75d874a r0e16a2d  
    295295                                // make sure the target hasn't stopped existing since last time
    296296                                HELP: if(target < ctxs_count) {
    297                                         // calculate it's age and how young it could be before we give up on helping
     297                                        // calculate it's age and how young it could be before we give ip on helping
    298298                                        const __readyQ_avg_t cutoff = calc_cutoff(ctsc, ctx->cq.id, ctxs_count, io.data, io.tscs, __shard_factor.io, false);
    299299                                        const __readyQ_avg_t age = moving_average(ctsc, io.tscs[target].t.tv, io.tscs[target].t.ma, false);

  • libcfa/src/concurrency/io/call.cfa.in

    r75d874a r0e16a2d  
    8989#if defined(CFA_HAVE_PREADV2)
    9090        struct iovec;
    91         extern ssize_t preadv2 (int fd, const struct iovec * iov, int iovcnt, off_t offset, int flags);
     91        extern ssize_t preadv2 (int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags);
    9292#endif
    9393#if defined(CFA_HAVE_PWRITEV2)
    9494        struct iovec;
    95         extern ssize_t pwritev2(int fd, const struct iovec * iov, int iovcnt, off_t offset, int flags);
     95        extern ssize_t pwritev2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags);
    9696#endif
    9797
    … …  
    108108        struct msghdr;
    109109        struct sockaddr;
    110         extern ssize_t sendmsg(int sockfd, const struct msghdr * msg, int flags);
    111         extern ssize_t recvmsg(int sockfd, struct msghdr * msg, int flags);
    112         extern ssize_t send(int sockfd, const void * buf, size_t len, int flags);
    113         extern ssize_t recv(int sockfd, void * buf, size_t len, int flags);
     110        extern ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags);
     111        extern ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags);
     112        extern ssize_t send(int sockfd, const void *buf, size_t len, int flags);
     113        extern ssize_t recv(int sockfd, void *buf, size_t len, int flags);
    114114
    115115        extern int fallocate(int fd, int mode, off_t offset, off_t len);
    116116        extern int posix_fadvise(int fd, off_t offset, off_t len, int advice);
    117         extern int madvise(void * addr, size_t length, int advice);
    118 
    119         extern int openat(int dirfd, const char * pathname, int flags, mode_t mode);
     117        extern int madvise(void *addr, size_t length, int advice);
     118
     119        extern int openat(int dirfd, const char *pathname, int flags, mode_t mode);
    120120        extern int close(int fd);
    121121
    122         extern ssize_t read (int fd, void * buf, size_t count);
     122        extern ssize_t read (int fd, void *buf, size_t count);
    123123
    124124        struct epoll_event;
    125         extern int epoll_ctl(int epfd, int op, int fd, struct epoll_event * event);
    126 
    127         extern ssize_t splice(int fd_in, __off64_t * off_in, int fd_out, __off64_t * off_out, size_t len, unsigned int flags);
     125        extern int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
     126
     127        extern ssize_t splice(int fd_in, __off64_t *off_in, int fd_out, __off64_t *off_out, size_t len, unsigned int flags);
    128128        extern ssize_t tee(int fd_in, int fd_out, size_t len, unsigned int flags);
    129129}
    … …  
    224224calls = [
    225225        # CFA_HAVE_IORING_OP_READV
    226         Call('READV', 'ssize_t preadv2(int fd, const struct iovec * iov, int iovcnt, off_t offset, int flags)', {
     226        Call('READV', 'ssize_t preadv2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags)', {
    227227                'fd'  : 'fd',
    228                 'addr': '(typeof(sqe->addr))iov',
     228                'off' : 'offset',
     229                'addr': '(uintptr_t)iov',
    229230                'len' : 'iovcnt',
    230                 'off' : 'offset',
    231                 'rw_flags' : 'flags'
    232231        }, define = 'CFA_HAVE_PREADV2'),
    233232        # CFA_HAVE_IORING_OP_WRITEV
    234         Call('WRITEV', 'ssize_t pwritev2(int fd, const struct iovec * iov, int iovcnt, off_t offset, int flags)', {
     233        Call('WRITEV', 'ssize_t pwritev2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags)', {
    235234                'fd'  : 'fd',
    236                 'addr': '(typeof(sqe->addr))iov',
    237                 'len' : 'iovcnt',
    238235                'off' : 'offset',
    239                 'rw_flags' : 'flags'
     236                'addr': '(uintptr_t)iov',
     237                'len' : 'iovcnt'
    240238        }, define = 'CFA_HAVE_PWRITEV2'),
    241239        # CFA_HAVE_IORING_OP_FSYNC
    … …  
    244242        }),
    245243        # CFA_HAVE_IORING_OP_EPOLL_CTL
    246         Call('EPOLL_CTL', 'int epoll_ctl(int epfd, int op, int fd, struct epoll_event * event)', {
     244        Call('EPOLL_CTL', 'int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)', {
    247245                'fd': 'epfd',
     246                'addr': 'fd',
    248247                'len': 'op',
    249                 'addr': 'fd',
    250                 'off': '(typeof(sqe->off))event'
     248                'off': '(uintptr_t)event'
    251249        }),
    252250        # CFA_HAVE_IORING_OP_SYNC_FILE_RANGE
    … …  
    258256        }),
    259257        # CFA_HAVE_IORING_OP_SENDMSG
    260         Call('SENDMSG', 'ssize_t sendmsg(int sockfd, const struct msghdr * msg, int flags)', {
    261                 'fd': 'sockfd',
    262                 'addr': '(typeof(sqe->addr))(struct msghdr *)msg',
     258        Call('SENDMSG', 'ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags)', {
     259                'fd': 'sockfd',
     260                'addr': '(uintptr_t)(struct msghdr *)msg',
    263261                'len': '1',
    264262                'msg_flags': 'flags'
    265263        }),
    266264        # CFA_HAVE_IORING_OP_RECVMSG
    267         Call('RECVMSG', 'ssize_t recvmsg(int sockfd, struct msghdr * msg, int flags)', {
    268                 'fd': 'sockfd',
    269                 'addr': '(typeof(sqe->addr))(struct msghdr *)msg',
     265        Call('RECVMSG', 'ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags)', {
     266                'fd': 'sockfd',
     267                'addr': '(uintptr_t)(struct msghdr *)msg',
    270268                'len': '1',
    271269                'msg_flags': 'flags'
    272270        }),
    273271        # CFA_HAVE_IORING_OP_SEND
    274         Call('SEND', 'ssize_t send(int sockfd, const void * buf, size_t len, int flags)', {
    275                 'fd': 'sockfd',
    276                 'addr': '(typeof(sqe->addr))buf',
     272        Call('SEND', 'ssize_t send(int sockfd, const void *buf, size_t len, int flags)', {
     273                'fd': 'sockfd',
     274                'addr': '(uintptr_t)buf',
    277275                'len': 'len',
    278276                'msg_flags': 'flags'
    279277        }),
    280278        # CFA_HAVE_IORING_OP_RECV
    281         Call('RECV', 'ssize_t recv(int sockfd, void * buf, size_t len, int flags)', {
    282                 'fd': 'sockfd',
    283                 'addr': '(typeof(sqe->addr))buf',
     279        Call('RECV', 'ssize_t recv(int sockfd, void *buf, size_t len, int flags)', {
     280                'fd': 'sockfd',
     281                'addr': '(uintptr_t)buf',
    284282                'len': 'len',
    285283                'msg_flags': 'flags'
    … …  
    288286        Call('ACCEPT', 'int accept4(int sockfd, __SOCKADDR_ARG addr, socklen_t * restrict addrlen, int flags)', {
    289287                'fd': 'sockfd',
    290                 'addr': '(typeof(sqe->addr))&addr',
    291                 'addr2': '(typeof(sqe->addr2))addrlen',
     288                'addr': '(uintptr_t)&addr',
     289                'addr2': '(uintptr_t)addrlen',
    292290                'accept_flags': 'flags'
    293291        }),
    … …  
    295293        Call('CONNECT', 'int connect(int sockfd, __CONST_SOCKADDR_ARG addr, socklen_t addrlen)', {
    296294                'fd': 'sockfd',
    297                 'addr': '(typeof(sqe->addr))&addr',
     295                'addr': '(uintptr_t)&addr',
    298296                'off': 'addrlen'
    299297        }),
    … …  
    301299        Call('FALLOCATE', 'int fallocate(int fd, int mode, off_t offset, off_t len)', {
    302300                'fd': 'fd',
     301                'addr': '(uintptr_t)len',
    303302                'len': 'mode',
    304                 'off': 'offset',
    305                 'addr': 'len'
     303                'off': 'offset'
    306304        }),
    307305        # CFA_HAVE_IORING_OP_FADVISE
    … …  
    313311        }),
    314312        # CFA_HAVE_IORING_OP_MADVISE
    315         Call('MADVISE', 'int madvise(void * addr, size_t length, int advice)', {
    316                 'addr': '(typeof(sqe->addr))addr',
     313        Call('MADVISE', 'int madvise(void *addr, size_t length, int advice)', {
     314                'addr': '(uintptr_t)addr',
    317315                'len': 'length',
    318316                'fadvise_advice': 'advice'
    319317        }),
    320318        # CFA_HAVE_IORING_OP_OPENAT
    321         Call('OPENAT', 'int openat(int dirfd, const char * pathname, int flags, mode_t mode)', {
     319        Call('OPENAT', 'int openat(int dirfd, const char *pathname, int flags, mode_t mode)', {
    322320                'fd': 'dirfd',
    323                 'addr': '(typeof(sqe->addr))pathname',
    324                 'open_flags': 'flags;',
    325                 'len': 'mode'
     321                'addr': '(uintptr_t)pathname',
     322                'len': 'mode',
     323                'open_flags': 'flags;'
    326324        }),
    327325        # CFA_HAVE_IORING_OP_OPENAT2
    328         Call('OPENAT2', 'int openat2(int dirfd, const char * pathname, struct open_how * how, size_t size)', {
     326        Call('OPENAT2', 'int openat2(int dirfd, const char *pathname, struct open_how * how, size_t size)', {
    329327                'fd': 'dirfd',
    330                 'addr': '(typeof(sqe->addr))pathname',
    331                 'off': '(typeof(sqe->off))how',
    332                 'len': 'sizeof(*how)'
     328                'addr': 'pathname',
     329                'len': 'sizeof(*how)',
     330                'off': '(uintptr_t)how',
    333331        }, define = 'CFA_HAVE_OPENAT2'),
    334332        # CFA_HAVE_IORING_OP_CLOSE
    … …  
    337335        }),
    338336        # CFA_HAVE_IORING_OP_STATX
    339         Call('STATX', 'int statx(int dirfd, const char * pathname, int flags, unsigned int mask, struct statx * statxbuf)', {
     337        Call('STATX', 'int statx(int dirfd, const char *pathname, int flags, unsigned int mask, struct statx *statxbuf)', {
    340338                'fd': 'dirfd',
    341                 'addr': '(typeof(sqe->addr))pathname',
    342                 'statx_flags': 'flags',
     339                'off': '(uintptr_t)statxbuf',
     340                'addr': 'pathname',
    343341                'len': 'mask',
    344                 'off': '(typeof(sqe->off))statxbuf'
     342                'statx_flags': 'flags'
    345343        }, define = 'CFA_HAVE_STATX'),
    346344        # CFA_HAVE_IORING_OP_READ
    347345        Call('READ', 'ssize_t read(int fd, void * buf, size_t count)', {
    348346                'fd': 'fd',
    349                 'addr': '(typeof(sqe->addr))buf',
     347                'addr': '(uintptr_t)buf',
    350348                'len': 'count'
    351349        }),
    … …  
    353351        Call('WRITE', 'ssize_t write(int fd, void * buf, size_t count)', {
    354352                'fd': 'fd',
    355                 'addr': '(typeof(sqe->addr))buf',
     353                'addr': '(uintptr_t)buf',
    356354                'len': 'count'
    357355        }),
    358356        # CFA_HAVE_IORING_OP_SPLICE
    359         Call('SPLICE', 'ssize_t splice(int fd_in, __off64_t * off_in, int fd_out, __off64_t * off_out, size_t len, unsigned int flags)', {
     357        Call('SPLICE', 'ssize_t splice(int fd_in, __off64_t *off_in, int fd_out, __off64_t *off_out, size_t len, unsigned int flags)', {
    360358                'splice_fd_in': 'fd_in',
    361                 'splice_off_in': 'off_in ? (typeof(sqe->splice_off_in))*off_in : (typeof(sqe->splice_off_in))-1',
     359                'splice_off_in': 'off_in ? (__u64)*off_in : (__u64)-1',
    362360                'fd': 'fd_out',
    363                 'off': 'off_out ? (typeof(sqe->off))*off_out : (typeof(sqe->off))-1',
     361                'off': 'off_out ? (__u64)*off_out : (__u64)-1',
    364362                'len': 'len',
    365363                'splice_flags': 'flags'

  • libcfa/src/concurrency/locks.hfa

    r75d874a r0e16a2d  
    253253static inline void on_wakeup(clh_lock & this, size_t recursion ) { lock(this); }
    254254
     255
    255256//-----------------------------------------------------------------------------
    256257// Exponential backoff then block lock
    … …  
    271272        this.lock_value = 0;
    272273}
     274static inline void ^?{}( exp_backoff_then_block_lock & this ) {}
     275// static inline void ?{}( exp_backoff_then_block_lock & this, exp_backoff_then_block_lock this2 ) = void;
     276// static inline void ?=?( exp_backoff_then_block_lock & this, exp_backoff_then_block_lock this2 ) = void;
    273277
    274278static inline bool internal_try_lock(exp_backoff_then_block_lock & this, size_t & compare_val) with(this) {
    275         return __atomic_compare_exchange_n(&lock_value, &compare_val, 1, false, __ATOMIC_ACQUIRE, __ATOMIC_RELAXED);
     279        if (__atomic_compare_exchange_n(&lock_value, &compare_val, 1, false, __ATOMIC_ACQUIRE, __ATOMIC_RELAXED)) {
     280                return true;
     281        }
     282        return false;
    276283}
    277284
    … …  
    279286
    280287static inline bool try_lock_contention(exp_backoff_then_block_lock & this) with(this) {
    281         return !__atomic_exchange_n(&lock_value, 2, __ATOMIC_ACQUIRE);
     288        if (__atomic_exchange_n(&lock_value, 2, __ATOMIC_ACQUIRE) == 0) {
     289                return true;
     290        }
     291        return false;
    282292}
    283293
    284294static inline bool block(exp_backoff_then_block_lock & this) with(this) {
    285     lock( spinlock __cfaabi_dbg_ctx2 );
    286     if (__atomic_load_n( &lock_value, __ATOMIC_SEQ_CST) != 2) {
    287         unlock( spinlock );
    288         return true;
    289     }
    290     insert_last( blocked_threads, *active_thread() );
    291     unlock( spinlock );
     295        lock( spinlock __cfaabi_dbg_ctx2 ); // TODO change to lockfree queue (MPSC)
     296        if (lock_value != 2) {
     297                unlock( spinlock );
     298                return true;
     299        }
     300        insert_last( blocked_threads, *active_thread() );
     301        unlock( spinlock );
    292302        park( );
    293303        return true;
    … …  
    297307        size_t compare_val = 0;
    298308        int spin = 4;
    299 
    300309        // linear backoff
    301310        for( ;; ) {
    … …  
    315324static inline void unlock(exp_backoff_then_block_lock & this) with(this) {
    316325    if (__atomic_exchange_n(&lock_value, 0, __ATOMIC_RELEASE) == 1) return;
    317     lock( spinlock __cfaabi_dbg_ctx2 );
    318     thread$ * t = &try_pop_front( blocked_threads );
    319     unlock( spinlock );
    320     unpark( t );
     326        lock( spinlock __cfaabi_dbg_ctx2 );
     327        thread$ * t = &try_pop_front( blocked_threads );
     328        unlock( spinlock );
     329        unpark( t );
    321330}
    322331

  • src/AST/Print.cpp

    r75d874a r0e16a2d  
    369369                                --indent;
    370370                        }
    371                 }
    372 
    373                 if ( ! node->withExprs.empty() ) {
    374                         // Not with a clause, but the 'with clause'.
    375                         ++indent;
    376                         os << " with clause" << endl << indent;
    377                         printAll( node->withExprs );
    378                         --indent;
    379371                }
    380372

  • src/Common/module.mk

    r75d874a r0e16a2d  
    2020        Common/CodeLocationTools.hpp \
    2121        Common/CodeLocationTools.cpp \
     22        Common/Debug.h \
    2223        Common/DeclStats.hpp \
    2324        Common/DeclStats.cpp \

  • src/Common/utility.h

    r75d874a r0e16a2d  
    190190}
    191191
     192template< typename... Params >
     193void warn( const Params & ... params ) {
     194        std::cerr << "Warning: ";
     195        toString_single( std::cerr, params... );
     196        std::cerr << std::endl;
     197}
     198
    192199// determines if pref is a prefix of str
    193200static inline bool isPrefix( const std::string & str, const std::string & pref, unsigned int start = 0 ) {

  • src/InitTweak/FixInit.cc

    r75d874a r0e16a2d  
    12331233                }
    12341234
     1235                template< typename Visitor, typename... Params >
     1236                void error( Visitor & v, CodeLocation loc, const Params &... params ) {
     1237                        SemanticErrorException err( loc, toString( params... ) );
     1238                        v.errors.append( err );
     1239                }
     1240
    12351241                template< typename... Params >
    12361242                void GenStructMemberCalls::emit( CodeLocation loc, const Params &... params ) {
    1237                         SemanticErrorException err( loc, toString( params... ) );
    1238                         errors.append( err );
     1243                        // toggle warnings vs. errors here.
     1244                        // warn( params... );
     1245                        error( *this, loc, params... );
    12391246                }
    12401247

  • src/InitTweak/FixInitNew.cpp

    r75d874a r0e16a2d  
    13031303        }
    13041304
     1305        template< typename Visitor, typename... Params >
     1306        void error( Visitor & v, CodeLocation loc, const Params &... params ) {
     1307                SemanticErrorException err( loc, toString( params... ) );
     1308                v.errors.append( err );
     1309        }
     1310
    13051311        template< typename... Params >
    13061312        void GenStructMemberCalls::emit( CodeLocation loc, const Params &... params ) {
    1307                 SemanticErrorException err( loc, toString( params... ) );
    1308                 errors.append( err );
     1313                // toggle warnings vs. errors here.
     1314                // warn( params... );
     1315                error( *this, loc, params... );
    13091316        }
    13101317

  • src/Parser/parser.yy

    r75d874a r0e16a2d  
    1010// Created On       : Sat Sep  1 20:22:55 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Mar 22 21:26:01 2023
    13 // Update Count     : 6002
     12// Last Modified On : Tue Mar 14 09:37:58 2023
     13// Update Count     : 5990
    1414//
    1515
    … …  
    270270        SemanticError( yylloc, ::toString( "Identifier \"", identifier, "\" cannot appear before a ", kind, ".\n"
    271271                                   "Possible cause is misspelled storage/CV qualifier, misspelled typename, or missing generic parameter." ) );
    272 } // IdentifierBeforeType
    273 
    274 static bool TypedefForall( DeclarationNode * decl ) {
    275         if ( decl->type->forall || (decl->type->kind == TypeData::Aggregate && decl->type->aggregate.params) ) {
    276                 SemanticError( yylloc, "forall qualifier in typedef is currently unimplemented." );
    277                 return true;
    278         } // if
    279         return false;
    280272} // IdentifierBeforeType
    281273
    … …  
    504496%type<decl> typedef_name typedef_declaration typedef_expression
    505497
    506 %type<decl> variable_type_redeclarator variable_type_ptr variable_type_array variable_type_function
    507 %type<decl> general_function_declarator function_type_redeclarator function_type_array function_type_no_ptr function_type_ptr
     498%type<decl> variable_type_redeclarator type_ptr type_array type_function
    508499
    509500%type<decl> type_parameter_redeclarator type_parameter_ptr type_parameter_array type_parameter_function
    … …  
    19661957        TYPEDEF type_specifier declarator
    19671958                {
     1959                        // if type_specifier is an anon aggregate => name
    19681960                        typedefTable.addToEnclosingScope( *$3->name, TYPEDEFname, "4" );
    1969                         if ( TypedefForall( $2 ) ) $$ = nullptr;
    1970                         else $$ = $3->addType( $2 )->addTypedef();              // watchout frees $2 and $3
     1961                        $$ = $3->addType( $2 )->addTypedef();           // watchout frees $2 and $3
    19711962                }
    19721963        | typedef_declaration pop ',' push declarator
    … …  
    19781969                {
    19791970                        typedefTable.addToEnclosingScope( *$4->name, TYPEDEFname, "6" );
    1980                         if ( TypedefForall( $1 ) ) $$ = nullptr;
    1981                         else $$ = $4->addQualifiers( $1 )->addType( $3 )->addTypedef();
     1971                        $$ = $4->addQualifiers( $1 )->addType( $3 )->addTypedef();
    19821972                }
    19831973        | type_specifier TYPEDEF declarator
    19841974                {
    19851975                        typedefTable.addToEnclosingScope( *$3->name, TYPEDEFname, "7" );
    1986                         if ( TypedefForall( $1 ) ) $$ = nullptr;
    1987                         else $$ = $3->addType( $1 )->addTypedef();
     1976                        $$ = $3->addType( $1 )->addTypedef();
    19881977                }
    19891978        | type_specifier TYPEDEF type_qualifier_list declarator
    19901979                {
    19911980                        typedefTable.addToEnclosingScope( *$4->name, TYPEDEFname, "8" );
    1992                         if ( TypedefForall( $3 ) ) $$ = nullptr;
    1993                         else $$ = $4->addQualifiers( $1 )->addType( $1 )->addTypedef();
     1981                        $$ = $4->addQualifiers( $1 )->addType( $1 )->addTypedef();
    19941982                }
    19951983        ;
    … …  
    20282016                // A semantic check is required to ensure asm_name only appears on declarations with implicit or explicit static
    20292017                // storage-class
    2030         variable_declarator asm_name_opt initializer_opt
     2018        declarator asm_name_opt initializer_opt
    20312019                { $$ = $1->addAsmName( $2 )->addInitializer( $3 ); }
    2032         | variable_type_redeclarator asm_name_opt initializer_opt
    2033                 { $$ = $1->addAsmName( $2 )->addInitializer( $3 ); }
    2034 
    2035         | general_function_declarator asm_name_opt
    2036                 { $$ = $1->addAsmName( $2 )->addInitializer( nullptr ); }
    2037         | general_function_declarator asm_name_opt '=' VOID
    2038                 { $$ = $1->addAsmName( $2 )->addInitializer( new InitializerNode( true ) ); }
    2039 
    20402020        | declaring_list ',' attribute_list_opt declarator asm_name_opt initializer_opt
    20412021                { $$ = $1->appendList( $4->addQualifiers( $3 )->addAsmName( $5 )->addInitializer( $6 ) ); }
    2042         ;
    2043 
    2044 general_function_declarator:
    2045         function_type_redeclarator
    2046         | function_declarator
    20472022        ;
    20482023
    … …  
    25682543                // A semantic check is required to ensure bit_subrange only appears on integral types.
    25692544                { $$ = $1->addBitfield( $2 ); }
    2570         | function_type_redeclarator bit_subrange_size_opt
    2571                 // A semantic check is required to ensure bit_subrange only appears on integral types.
    2572                 { $$ = $1->addBitfield( $2 ); }
    25732545        ;
    25742546
    … …  
    32233195                        $$ = $2->addFunctionBody( $4, $3 )->addType( $1 );
    32243196                }
    3225         | declaration_specifier function_type_redeclarator with_clause_opt compound_statement
     3197        | declaration_specifier variable_type_redeclarator with_clause_opt compound_statement
    32263198                {
    32273199                        rebindForall( $1, $2 );
    … …  
    32593231        | variable_type_redeclarator
    32603232        | function_declarator
    3261         | function_type_redeclarator
    32623233        ;
    32633234
    … …  
    35103481        ;
    35113482
    3512 // This pattern parses a declaration for a variable that redefines a type name, e.g.:
     3483// This pattern parses a declaration for a variable or function prototype that redefines a type name, e.g.:
    35133484//
    35143485//              typedef int foo;
    … …  
    35163487//                 int foo; // redefine typedef name in new scope
    35173488//              }
     3489//
     3490// The pattern precludes declaring an array of functions versus a pointer to an array of functions, and returning arrays
     3491// and functions versus pointers to arrays and functions.
    35183492
    35193493paren_type:
    … …  
    35303504        paren_type attribute_list_opt
    35313505                { $$ = $1->addQualifiers( $2 ); }
    3532         | variable_type_ptr
    3533         | variable_type_array attribute_list_opt
     3506        | type_ptr
     3507        | type_array attribute_list_opt
    35343508                { $$ = $1->addQualifiers( $2 ); }
    3535         | variable_type_function attribute_list_opt
     3509        | type_function attribute_list_opt
    35363510                { $$ = $1->addQualifiers( $2 ); }
    35373511        ;
    35383512
    3539 variable_type_ptr:
     3513type_ptr:
    35403514        ptrref_operator variable_type_redeclarator
    35413515                { $$ = $2->addPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
    35423516        | ptrref_operator type_qualifier_list variable_type_redeclarator
    35433517                { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
    3544         | '(' variable_type_ptr ')' attribute_list_opt          // redundant parenthesis
     3518        | '(' type_ptr ')' attribute_list_opt                           // redundant parenthesis
    35453519                { $$ = $2->addQualifiers( $4 ); }
    3546         | '(' attribute_list variable_type_ptr ')' attribute_list_opt // redundant parenthesis
     3520        | '(' attribute_list type_ptr ')' attribute_list_opt // redundant parenthesis
    35473521                { $$ = $3->addQualifiers( $2 )->addQualifiers( $5 ); }
    35483522        ;
    35493523
    3550 variable_type_array:
     3524type_array:
    35513525        paren_type array_dimension
    35523526                { $$ = $1->addArray( $2 ); }
    3553         | '(' variable_type_ptr ')' array_dimension
     3527        | '(' type_ptr ')' array_dimension
    35543528                { $$ = $2->addArray( $4 ); }
    3555         | '(' attribute_list variable_type_ptr ')' array_dimension
     3529        | '(' attribute_list type_ptr ')' array_dimension
    35563530                { $$ = $3->addQualifiers( $2 )->addArray( $5 ); }
    3557         | '(' variable_type_array ')' multi_array_dimension     // redundant parenthesis
     3531        | '(' type_array ')' multi_array_dimension                      // redundant parenthesis
    35583532                { $$ = $2->addArray( $4 ); }
    3559         | '(' attribute_list variable_type_array ')' multi_array_dimension // redundant parenthesis
     3533        | '(' attribute_list type_array ')' multi_array_dimension // redundant parenthesis
    35603534                { $$ = $3->addQualifiers( $2 )->addArray( $5 ); }
    3561         | '(' variable_type_array ')'                                           // redundant parenthesis
     3535        | '(' type_array ')'                                                            // redundant parenthesis
    35623536                { $$ = $2; }
    3563         | '(' attribute_list variable_type_array ')'            // redundant parenthesis
     3537        | '(' attribute_list type_array ')'                                     // redundant parenthesis
    35643538                { $$ = $3->addQualifiers( $2 ); }
    35653539        ;
    35663540
    3567 variable_type_function:
    3568         '(' variable_type_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
    3569                 { $$ = $2->addParamList( $6 ); }
    3570         | '(' attribute_list variable_type_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
    3571                 { $$ = $3->addQualifiers( $2 )->addParamList( $7 ); }
    3572         | '(' variable_type_function ')'                                        // redundant parenthesis
    3573                 { $$ = $2; }
    3574         | '(' attribute_list variable_type_function ')'         // redundant parenthesis
    3575                 { $$ = $3->addQualifiers( $2 ); }
    3576         ;
    3577 
    3578 // This pattern parses a declaration for a function prototype that redefines a type name.  It precludes declaring an
    3579 // array of functions versus a pointer to an array of functions, and returning arrays and functions versus pointers to
    3580 // arrays and functions.
    3581 
    3582 function_type_redeclarator:
    3583         function_type_no_ptr attribute_list_opt
    3584                 { $$ = $1->addQualifiers( $2 ); }
    3585         | function_type_ptr
    3586         | function_type_array attribute_list_opt
    3587                 { $$ = $1->addQualifiers( $2 ); }
    3588         ;
    3589 
    3590 function_type_no_ptr:
     3541type_function:
    35913542        paren_type '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
    35923543                { $$ = $1->addParamList( $4 ); }
    3593         | '(' function_type_ptr ')' '(' push parameter_type_list_opt pop ')'
     3544        | '(' type_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
    35943545                { $$ = $2->addParamList( $6 ); }
    3595         | '(' attribute_list function_type_ptr ')' '(' push parameter_type_list_opt pop ')'
     3546        | '(' attribute_list type_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
    35963547                { $$ = $3->addQualifiers( $2 )->addParamList( $7 ); }
    3597         | '(' function_type_no_ptr ')'                                          // redundant parenthesis
     3548        | '(' type_function ')'                                                         // redundant parenthesis
    35983549                { $$ = $2; }
    3599         | '(' attribute_list function_type_no_ptr ')'           // redundant parenthesis
    3600                 { $$ = $3->addQualifiers( $2 ); }
    3601         ;
    3602 
    3603 function_type_ptr:
    3604         ptrref_operator function_type_redeclarator
    3605                 { $$ = $2->addPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
    3606         | ptrref_operator type_qualifier_list function_type_redeclarator
    3607                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
    3608         | '(' function_type_ptr ')' attribute_list_opt
    3609                 { $$ = $2->addQualifiers( $4 ); }
    3610         | '(' attribute_list function_type_ptr ')' attribute_list_opt
    3611                 { $$ = $3->addQualifiers( $2 )->addQualifiers( $5 ); }
    3612         ;
    3613 
    3614 function_type_array:
    3615         '(' function_type_ptr ')' array_dimension
    3616                 { $$ = $2->addArray( $4 ); }
    3617         | '(' attribute_list function_type_ptr ')' array_dimension
    3618                 { $$ = $3->addQualifiers( $2 )->addArray( $5 ); }
    3619         | '(' function_type_array ')' multi_array_dimension     // redundant parenthesis
    3620                 { $$ = $2->addArray( $4 ); }
    3621         | '(' attribute_list function_type_array ')' multi_array_dimension // redundant parenthesis
    3622                 { $$ = $3->addQualifiers( $2 )->addArray( $5 ); }
    3623         | '(' function_type_array ')'                                           // redundant parenthesis
    3624                 { $$ = $2; }
    3625         | '(' attribute_list function_type_array ')'            // redundant parenthesis
     3550        | '(' attribute_list type_function ')'                          // redundant parenthesis
    36263551                { $$ = $3->addQualifiers( $2 ); }
    36273552        ;

  • src/SynTree/FunctionDecl.cc

    r75d874a r0e16a2d  
    8787        } // if
    8888
    89         if ( !withExprs.empty() ) {
    90                 os << indent << "... with clause" << std::endl;
    91                 os << indent + 1;
    92                 printAll( withExprs, os, indent + 1 );
    93         }
    94 
    9589        if ( statements ) {
    9690                os << indent << "... with body" << endl << indent+1;

  • tests/.expect/PRNG.x64.txt

    r75d874a r0e16a2d  
    11
    22                    PRNG()     PRNG(5)   PRNG(0,5)
    3       13944458589275087071           3           2
    4         129977468648444256           0           4
    5        2357727400298891021           2           2
    6        8855179187835660146           3           3
    7        9957620185645882382           4           1
    8       13396406983727409795           0           5
    9        3342782395220265920           0           5
    10        1707651271867677937           1           0
    11       16402561450140881681           0           1
    12       17838519215740313729           4           2
    13        7425936020594490136           4           0
    14        4174865704721714670           3           5
    15       16055269689200152092           0           2
    16       15091270195803594018           1           5
    17       11807315541476180798           1           1
    18       10697186588988060306           4           1
    19       14665526411527044929           3           2
    20       11289342279096164771           2           5
    21       16126980828050300615           1           4
    22        7821578301767524260           4           1
     3       2629641414891406278           3           0
     4      11972157801652581900           3           5
     5       9470682093934978437           2           2
     6        316134424938305673           2           2
     7       5572275127081588144           0           3
     8      12394954141290188855           2           2
     9      15386440704589550620           2           1
     10       5760167266331356361           2           5
     11       8021670258373873290           2           5
     12       8813161879342109574           1           4
     13      10525294799876107814           2           0
     14      14801827301969351008           3           0
     15      17016612914230924215           0           0
     16       5485205801221744751           3           2
     17       6143666691223938511           4           0
     18      15086131934315954459           4           5
     19       4547668615176940328           4           5
     20      17718351571399359777           0           5
     21       2636252641646208341           4           0
     22      12820158953704882599           0           4
    2323seed 1009
    2424
    … …  
    3333
    3434                    prng()     prng(5)   prng(0,5)
    35       13944458589275087071           3           2
    36         129977468648444256           0           4
    37        2357727400298891021           2           2
    38        8855179187835660146           3           3
    39        9957620185645882382           4           1
    40       13396406983727409795           0           5
    41        3342782395220265920           0           5
    42        1707651271867677937           1           0
    43       16402561450140881681           0           1
    44       17838519215740313729           4           2
    45        7425936020594490136           4           0
    46        4174865704721714670           3           5
    47       16055269689200152092           0           2
    48       15091270195803594018           1           5
    49       11807315541476180798           1           1
    50       10697186588988060306           4           1
    51       14665526411527044929           3           2
    52       11289342279096164771           2           5
    53       16126980828050300615           1           4
    54        7821578301767524260           4           1
     35       2629641414891406278           3           0
     36      11972157801652581900           3           5
     37       9470682093934978437           2           2
     38        316134424938305673           2           2
     39       5572275127081588144           0           3
     40      12394954141290188855           2           2
     41      15386440704589550620           2           1
     42       5760167266331356361           2           5
     43       8021670258373873290           2           5
     44       8813161879342109574           1           4
     45      10525294799876107814           2           0
     46      14801827301969351008           3           0
     47      17016612914230924215           0           0
     48       5485205801221744751           3           2
     49       6143666691223938511           4           0
     50      15086131934315954459           4           5
     51       4547668615176940328           4           5
     52      17718351571399359777           0           5
     53       2636252641646208341           4           0
     54      12820158953704882599           0           4
    5555seed 1009
    5656
    … …  
    6565
    6666                   prng(t)   prng(t,5) prng(t,0,5)
    67       13944458589275087071           3           2
    68         129977468648444256           0           4
    69        2357727400298891021           2           2
    70        8855179187835660146           3           3
    71        9957620185645882382           4           1
    72       13396406983727409795           0           5
    73        3342782395220265920           0           5
    74        1707651271867677937           1           0
    75       16402561450140881681           0           1
    76       17838519215740313729           4           2
    77        7425936020594490136           4           0
    78        4174865704721714670           3           5
    79       16055269689200152092           0           2
    80       15091270195803594018           1           5
    81       11807315541476180798           1           1
    82       10697186588988060306           4           1
    83       14665526411527044929           3           2
    84       11289342279096164771           2           5
    85       16126980828050300615           1           4
    86        7821578301767524260           4           1
     67       2629641414891406278           3           0
     68      11972157801652581900           3           5
     69       9470682093934978437           2           2
     70        316134424938305673           2           2
     71       5572275127081588144           0           3
     72      12394954141290188855           2           2
     73      15386440704589550620           2           1
     74       5760167266331356361           2           5
     75       8021670258373873290           2           5
     76       8813161879342109574           1           4
     77      10525294799876107814           2           0
     78      14801827301969351008           3           0
     79      17016612914230924215           0           0
     80       5485205801221744751           3           2
     81       6143666691223938511           4           0
     82      15086131934315954459           4           5
     83       4547668615176940328           4           5
     84      17718351571399359777           0           5
     85       2636252641646208341           4           0
     86      12820158953704882599           0           4
    8787seed 1009
    8888

  • tests/.expect/PRNG.x86.txt

    r75d874a r0e16a2d  
    11
    22                    PRNG()     PRNG(5)   PRNG(0,5)
    3                 2884683541           0           0
    4                 3465286746           2           4
    5                 3268922916           0           1
    6                 2396374907           3           0
    7                 2135076892           4           1
    8                  944377718           3           1
    9                 2204845346           3           3
    10                 3736609533           0           4
    11                 4063231336           0           2
    12                 1075394776           0           2
    13                  712844808           4           0
    14                 4246343110           3           1
    15                 3793873837           2           1
    16                 3690340337           1           4
    17                  319207944           1           4
    18                 1815791072           3           5
    19                 2581617261           1           5
    20                 3873329448           1           3
    21                  832631329           4           0
    22                  651551615           3           5
     3                    130161           1           1
     4                4074541490           0           0
     5                 927506267           0           3
     6                1991273445           1           3
     7                 669918146           2           3
     8                 519546860           1           1
     9                1136699882           4           3
     10                2130185384           3           1
     11                 992239050           0           5
     12                2250903111           0           1
     13                1544429724           3           2
     14                1591091660           3           3
     15                2511657707           2           4
     16                1065770984           2           4
     17                2412763405           4           4
     18                1834447239           4           2
     19                 360289337           0           4
     20                2449452027           1           1
     21                3370425396           2           1
     22                3109103043           0           3
    2323seed 1009
    2424
    2525Sequential
    26 trials 100000000 buckets 100000 min 858 max 1147 avg 1000.0 std 31.5 rstd 3.2%
     26trials 100000000 buckets 100000 min 867 max 1135 avg 1000.0 std 31.7 rstd 3.2%
    2727
    2828Concurrent
    29 trials 100000000 buckets 100000 min 858 max 1147 avg 1000.0 std 31.5 rstd 3.2%
    30 trials 100000000 buckets 100000 min 858 max 1147 avg 1000.0 std 31.5 rstd 3.2%
    31 trials 100000000 buckets 100000 min 858 max 1147 avg 1000.0 std 31.5 rstd 3.2%
    32 trials 100000000 buckets 100000 min 858 max 1147 avg 1000.0 std 31.5 rstd 3.2%
     29trials 100000000 buckets 100000 min 867 max 1135 avg 1000.0 std 31.7 rstd 3.2%
     30trials 100000000 buckets 100000 min 867 max 1135 avg 1000.0 std 31.7 rstd 3.2%
     31trials 100000000 buckets 100000 min 867 max 1135 avg 1000.0 std 31.7 rstd 3.2%
     32trials 100000000 buckets 100000 min 867 max 1135 avg 1000.0 std 31.7 rstd 3.2%
    3333
    3434                    prng()     prng(5)   prng(0,5)
    35                 2884683541           0           0
    36                 3465286746           2           4
    37                 3268922916           0           1
    38                 2396374907           3           0
    39                 2135076892           4           1
    40                  944377718           3           1
    41                 2204845346           3           3
    42                 3736609533           0           4
    43                 4063231336           0           2
    44                 1075394776           0           2
    45                  712844808           4           0
    46                 4246343110           3           1
    47                 3793873837           2           1
    48                 3690340337           1           4
    49                  319207944           1           4
    50                 1815791072           3           5
    51                 2581617261           1           5
    52                 3873329448           1           3
    53                  832631329           4           0
    54                  651551615           3           5
     35                    130161           1           1
     36                4074541490           0           0
     37                 927506267           0           3
     38                1991273445           1           3
     39                 669918146           2           3
     40                 519546860           1           1
     41                1136699882           4           3
     42                2130185384           3           1
     43                 992239050           0           5
     44                2250903111           0           1
     45                1544429724           3           2
     46                1591091660           3           3
     47                2511657707           2           4
     48                1065770984           2           4
     49                2412763405           4           4
     50                1834447239           4           2
     51                 360289337           0           4
     52                2449452027           1           1
     53                3370425396           2           1
     54                3109103043           0           3
    5555seed 1009
    5656
    5757Sequential
    58 trials 100000000 buckets 100000 min 858 max 1147 avg 1000.0 std 31.5 rstd 3.2%
     58trials 100000000 buckets 100000 min 867 max 1135 avg 1000.0 std 31.7 rstd 3.2%
    5959
    6060Concurrent
    61 trials 100000000 buckets 100000 min 858 max 1147 avg 1000.0 std 31.5 rstd 3.2%
    62 trials 100000000 buckets 100000 min 858 max 1147 avg 1000.0 std 31.5 rstd 3.2%
    63 trials 100000000 buckets 100000 min 858 max 1147 avg 1000.0 std 31.5 rstd 3.2%
    64 trials 100000000 buckets 100000 min 858 max 1147 avg 1000.0 std 31.5 rstd 3.2%
     61trials 100000000 buckets 100000 min 867 max 1135 avg 1000.0 std 31.7 rstd 3.2%
     62trials 100000000 buckets 100000 min 867 max 1135 avg 1000.0 std 31.7 rstd 3.2%
     63trials 100000000 buckets 100000 min 867 max 1135 avg 1000.0 std 31.7 rstd 3.2%
     64trials 100000000 buckets 100000 min 867 max 1135 avg 1000.0 std 31.7 rstd 3.2%
    6565
    6666                   prng(t)   prng(t,5) prng(t,0,5)
    67                 2884683541           0           0
    68                 3465286746           2           4
    69                 3268922916           0           1
    70                 2396374907           3           0
    71                 2135076892           4           1
    72                  944377718           3           1
    73                 2204845346           3           3
    74                 3736609533           0           4
    75                 4063231336           0           2
    76                 1075394776           0           2
    77                  712844808           4           0
    78                 4246343110           3           1
    79                 3793873837           2           1
    80                 3690340337           1           4
    81                  319207944           1           4
    82                 1815791072           3           5
    83                 2581617261           1           5
    84                 3873329448           1           3
    85                  832631329           4           0
    86                  651551615           3           5
     67                    130161           1           1
     68                4074541490           0           0
     69                 927506267           0           3
     70                1991273445           1           3
     71                 669918146           2           3
     72                 519546860           1           1
     73                1136699882           4           3
     74                2130185384           3           1
     75                 992239050           0           5
     76                2250903111           0           1
     77                1544429724           3           2
     78                1591091660           3           3
     79                2511657707           2           4
     80                1065770984           2           4
     81                2412763405           4           4
     82                1834447239           4           2
     83                 360289337           0           4
     84                2449452027           1           1
     85                3370425396           2           1
     86                3109103043           0           3
    8787seed 1009
    8888
    8989Sequential
    90 trials 100000000 buckets 100000 min 858 max 1147 avg 1000.0 std 31.5 rstd 3.2%
     90trials 100000000 buckets 100000 min 867 max 1135 avg 1000.0 std 31.7 rstd 3.2%
    9191
    9292Concurrent
    93 trials 100000000 buckets 100000 min 858 max 1147 avg 1000.0 std 31.5 rstd 3.2%
    94 trials 100000000 buckets 100000 min 858 max 1147 avg 1000.0 std 31.5 rstd 3.2%
    95 trials 100000000 buckets 100000 min 858 max 1147 avg 1000.0 std 31.5 rstd 3.2%
    96 trials 100000000 buckets 100000 min 858 max 1147 avg 1000.0 std 31.5 rstd 3.2%
     93trials 100000000 buckets 100000 min 867 max 1135 avg 1000.0 std 31.7 rstd 3.2%
     94trials 100000000 buckets 100000 min 867 max 1135 avg 1000.0 std 31.7 rstd 3.2%
     95trials 100000000 buckets 100000 min 867 max 1135 avg 1000.0 std 31.7 rstd 3.2%
     96trials 100000000 buckets 100000 min 867 max 1135 avg 1000.0 std 31.7 rstd 3.2%

  • tests/.expect/nested_function.x86.txt

    r75d874a r0e16a2d  
    1 total 245
     1total 105

  • tests/concurrent/channels/parallel_harness.hfa

    r75d874a r0e16a2d  
    100100
    101101int test( size_t Processors, size_t Channels, size_t Producers, size_t Consumers, size_t ChannelSize ) {
    102     size_t Clusters = Processors;
     102    size_t Clusters = 1;
    103103    // create a cluster
    104104    cluster clus[Clusters];
    … …  
    108108    }
    109109
    110     channels = aalloc( Channels );
     110    channels = anew( Channels );
    111111
    112112    // sout | "Processors: " | Processors | " ProdsPerChan: " | Producers | " ConsPerChan: " | Consumers | "Channels: " | Channels | " Channel Size: " | ChannelSize;
    … …  
    150150       
    151151    }
    152 
     152    // for ( i; Channels ) {
     153    //     // sout | get_count( channels[i] );
     154    //     if ( get_count( channels[i] ) < Consumers ){
     155    //         #ifdef BIG
     156    //         bigObject b{0};
     157    //         #endif
     158    //         for ( j; Consumers ) {
     159    //             #ifdef BIG
     160    //             insert( channels[i], b );
     161    //             #else
     162    //             insert( channels[i], 0 );
     163    //             #endif
     164    //         }
     165    //     }
     166    // }
    153167    sout | "cons";
    154168    for ( i; Consumers * Channels ) {

  • tests/concurrent/pthread/.expect/bounded_buffer.x64.txt

    r75d874a r0e16a2d  
    1 producer total value is 39780
    2 consumer total value is 39780
     1producer total value is 38160
     2consumer total value is 38160

  • tests/concurrent/pthread/.expect/bounded_buffer.x86.txt

    r75d874a r0e16a2d  
    1 producer total value is 1770
    2 consumer total value is 1770
     1producer total value is 45060
     2consumer total value is 45060
Note: See TracChangeset for help on using the changeset viewer.