Changeset ab1b971 for libcfa/src/bits

Timestamp:

Jan 21, 2021, 8:47:31 PM (4 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

ea561c9

Parents:

7d01186d

Message:

blocking_lock & multiple_acquisition_lock can now be used without libcfa-thread.
Doing so will have all functions be no-ops for these locks.
If libcfa-thread is linked in, these locks will behave as proper user-level locking.

Location:

libcfa/src/bits

Files:

• collection.hfa (modified) (2 diffs)
• sequence.hfa (modified) (8 diffs)
• weakso_locks.cfa (added)
• weakso_locks.hfa (added)

libcfa/src/bits/collection.hfa

@@ +1 @@
+//
+// Cforall Version 1.0.0 Copyright (C) 2021 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// bits/collection.hfa -- PUBLIC
+// Intrusive singly-linked list
+//
+// Author           : Colby Alexander Parsons & Peter A. Buhr
+// Created On       : Thu Jan 21 19:46:50 2021
+// Last Modified By :
+// Last Modified On :
+// Update Count     :
+//
+
 #pragma once
-#include <stdio.h> // REMOVE THIS AFTER DEBUGGING
-
 
 struct Colable {
-        struct Colable * next;                                                                          // next node in the list
+        // next node in the list
         // invariant: (next != 0) <=> listed()
+        struct Colable * next;
 };
 #ifdef __cforall
@@ -53 +68 @@
         Collection & ?=?( const Collection & ) = void;          // no assignment
 
-        void ?{}( Collection & collection ) with( collection ) {        
+        void ?{}( Collection & collection ) with( collection ) {
                 root = 0p;
         } // post: empty()

libcfa/src/bits/sequence.hfa

@@ +1 @@
+//
+// Cforall Version 1.0.0 Copyright (C) 2021 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// bits/sequence.hfa -- PUBLIC
+// Intrusive doubly-linked list
+//
+// Author           : Colby Alexander Parsons & Peter A. Buhr
+// Created On       : Thu Jan 21 19:46:50 2021
+// Last Modified By :
+// Last Modified On :
+// Update Count     :
+//
+
 #pragma once
 
@@ -6 +22 @@
 struct Seqable {
         __cfa_anonymous_object(Colable);
-        struct Seqable * back;                                                                          // pointer to previous node in the list
+        // pointer to previous node in the list
+        struct Seqable * back;
 };
 
@@ -27 +44 @@
                 return sq->back;
         }
-
-        // // wrappers to make Collection have T
-        // forall( T & ) {
-        //      T *& Back( T * n ) {
-        //              return (T *)Back( (Seqable *)n );
-        //      }
-        // } // distribution
 } // distribution
 
@@ -43 +53 @@
 // and the back field of the last node points at the first node (circular).
 
-forall( T & | { T *& Back ( T * ); T *& Next ( T * ); } ) {
+forall( T & ) {
         struct Sequence {
-                inline Collection;                                                              // Plan 9 inheritance
+                // Plan 9 inheritance
+                inline Collection;
         };
 
         static inline {
+                void ?{}( Sequence(T) &, const Sequence(T) & ) = void; // no copy
+                Sequence(T) & ?=?( const Sequence(T) & ) = void; // no assignment
+
+                void ?{}( Sequence(T) & s ) with( s ) {
+                        ((Collection &)s){};
+                }       // post: isEmpty()
+        }
+
+        static inline forall(| { T *& Back ( T * ); T *& Next ( T * ); }) {
                 // wrappers to make Collection have T
                 T & head( Sequence(T) & s ) with( s ) {
                         return *(T *)head( (Collection &)s );
                 } // post: empty() & head() == 0 | !empty() & head() in *s
-
-                void ?{}( Sequence(T) &, const Sequence(T) & ) = void; // no copy
-                Sequence(T) & ?=?( const Sequence(T) & ) = void; // no assignment
-
-                void ?{}( Sequence(T) & s ) with( s ) { 
-                        ((Collection &)s){};
-                }       // post: isEmpty()
 
                 // Return a pointer to the last sequence element, without removing it.
@@ -145 +158 @@
                         return n;
                 } // post: n->listed() & *n in *s & succ(n) == bef
-                
+
                 // pre: n->listed() & *n in *s
                 T & remove( Sequence(T) & s, T & n ) with( s ) { // O(1)
@@ -285 +298 @@
 
         static inline {
-                void ?{}( SeqIterRev(T) & si ) with( si ) {     
+                void ?{}( SeqIterRev(T) & si ) with( si ) {
                         ((ColIter &)si){};
                         seq = 0p;
@@ -291 +304 @@
 
                 // Create a iterator active in sequence s.
-                void ?{}( SeqIterRev(T) & si, Sequence(T) & s ) with( si ) {    
+                void ?{}( SeqIterRev(T) & si, Sequence(T) & s ) with( si ) {
                         ((ColIter &)si){};
                         seq = &s;
@@ -297 +310 @@
                 } // post: elts = null
 
-                void ?{}( SeqIterRev(T) & si, Sequence(T) & s, T & start ) with( si ) { 
+                void ?{}( SeqIterRev(T) & si, Sequence(T) & s, T & start ) with( si ) {
                         ((ColIter &)si){};
                         seq = &s;