Changeset 90152a4 for libcfa/src/bits/containers.hfa

Timestamp:

Aug 27, 2018, 4:40:34 PM (7 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

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

Children:

b7c89aa

Parents:

f9feab8 (diff), 305581d (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' into cleanup-dtors

File:

• libcfa/src/bits/containers.hfa (moved) (moved from src/libcfa/bits/containers.h ) (5 diffs)

libcfa/src/bits/containers.hfa

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// bits/containers.h -- Intrusive generic containers.h
+// bits/containers.hfa -- Intrusive generic containers.hfa
 //
 // Author           : Thierry Delisle
@@ -15 +15 @@
 #pragma once
 
-#include "bits/align.h"
-#include "bits/defs.h"
+#include "bits/align.hfa"
+#include "bits/defs.hfa"
 
 //-----------------------------------------------------------------------------
@@ -140 +140 @@
 
 #ifdef __cforall
+
         forall(dtype T | is_node(T))
-        static inline void ?{}( __queue(T) & this ) {
-                (this.head){ NULL };
-                (this.tail){ &this.head };
-        }
-
-        forall(dtype T | is_node(T) | sized(T))
-        static inline void append( __queue(T) & this, T * val ) {
-                verify(this.tail != NULL);
-                *this.tail = val;
-                this.tail = &get_next( *val );
+        static inline void ?{}( __queue(T) & this ) with( this ) {
+                head{ NULL };
+                tail{ &head };
+        }
+
+        forall(dtype T | is_node(T) | sized(T))
+        static inline void append( __queue(T) & this, T * val ) with( this ) {
+                verify(tail != NULL);
+                *tail = val;
+                tail = &get_next( *val );
         }
 
@@ -167 +168 @@
 
         forall(dtype T | is_node(T) | sized(T))
-        static inline T * remove( __queue(T) & this, T ** it ) {
+        static inline T * remove( __queue(T) & this, T ** it ) with( this ) {
                 T * val = *it;
                 verify( val );
@@ -173 +174 @@
                 (*it) = get_next( *val );
 
-                if( this.tail == &get_next( *val ) ) {
-                        this.tail = it;
+                if( tail == &get_next( *val ) ) {
+                        tail = it;
                 }
 
                 get_next( *val ) = NULL;
 
-                verify( (this.head == NULL) == (&this.head == this.tail) );
-                verify( *this.tail == NULL );
+                verify( (head == NULL) == (&head == tail) );
+                verify( *tail == NULL );
                 return val;
         }
-#endif
+
+        forall(dtype T | is_node(T))
+        static inline bool ?!=?( __queue(T) & this, zero_t zero ) {
+                return this.head != 0;
+        }
+#endif
+
+
+//-----------------------------------------------------------------------------
+// Doubly Linked List
+//-----------------------------------------------------------------------------
+#ifdef __cforall
+        forall(dtype TYPE | sized(TYPE))
+        #define T TYPE
+        #define __getter_t * [T * & next, T * & prev] ( T & )
+#else
+        typedef void (*__generit_c_getter_t)();
+        #define T void
+        #define __getter_t __generit_c_getter_t
+#endif
+struct __dllist {
+        T * head;
+        __getter_t __get;
+};
+#undef T
+#undef __getter_t
+
+#ifdef __cforall
+#define __dllist_t(T) __dllist(T)
+#else
+#define __dllist_t(T) struct __dllist
+#endif
+
+#ifdef __cforall
+
+        forall(dtype T | sized(T))
+        static inline [void] ?{}( __dllist(T) & this, * [T * & next, T * & prev] ( T & ) __get ) {
+                this.head{ NULL };
+                this.__get = __get;
+        }
+
+        #define next 0
+        #define prev 1
+        forall(dtype T | sized(T))
+        static inline void push_front( __dllist(T) & this, T & node ) with( this ) {
+                verify(__get);
+                if ( head ) {
+                        __get( node ).next = head;
+                        __get( node ).prev = __get( *head ).prev;
+                        // inserted node must be consistent before it is seen
+                        // prevent code movement across barrier
+                        asm( "" : : : "memory" );
+                        __get( *head ).prev = &node;
+                        T & _prev = *__get( node ).prev;
+                        __get( _prev ).next = &node;
+                }
+                else {
+                        __get( node ).next = &node;
+                        __get( node ).prev = &node;
+                }
+
+                // prevent code movement across barrier
+                asm( "" : : : "memory" );
+                head = &node;
+        }
+
+        forall(dtype T | sized(T))
+        static inline void remove( __dllist(T) & this, T & node ) with( this ) {
+                verify(__get);
+                if ( &node == head ) {
+                        if ( __get( *head ).next == head ) {
+                                head = NULL;
+                        }
+                        else {
+                                head = __get( *head ).next;
+                        }
+                }
+                __get( *__get( node ).next ).prev = __get( node ).prev;
+                __get( *__get( node ).prev ).next = __get( node ).next;
+                __get( node ).next = NULL;
+                __get( node ).prev = NULL;
+        }
+
+        forall(dtype T | sized(T))
+        static inline bool ?!=?( __dllist(T) & this, zero_t zero ) {
+                return this.head != 0;
+        }
+        #undef next
+        #undef prev
+#endif
+
+//-----------------------------------------------------------------------------
+// Tools
+//-----------------------------------------------------------------------------
+#ifdef __cforall
+
+#endif