Changeset 7806f91 for libcfa/src

Timestamp:

Jul 25, 2025, 3:29:48 PM (2 months ago)

Author:

Mike Brooks <mlbrooks@…>

Branches:

master

Children:

1eea589f, 29c6a7d

Parents:

7640ff5

Message:

Add code for reproducing performance numbers in thesis draft of 16a843

Location:

libcfa/src

Files:

• collections/list.hfa (modified) (6 diffs)
• stdhdr/assert.h (modified) (1 diff)

libcfa/src/collections/list.hfa

@@ -80 +80 @@
 // part), by failing fast.
 
-#if defined( __x86_64 )
-        // Preferred case: tag in the most-significant bit.  Dereference has been shown to segfault consistently.
-        // Maintenance should list more architectures as "ok" here, to let them use the preferred case, when valid.
-        #define ORIGIN_TAG_BITNO ( 8 * sizeof( size_t ) - 1 )
-#else
-        // Fallback case: tag in the least-significant bit.  Dereference will often give an alignment error, but may not,
-        // e.g. if accessing a char-typed member.  32-bit x86 uses the most- significant bit for real room on the heap.
-        #define ORIGIN_TAG_BITNO 0
+#ifdef __EXPERIMENTAL_DISABLE_OTAG__ // Perf experimention alt mode
+
+    // With origin tagging disabled, iteration never reports "no more elements."
+    // In this mode, the list API is buggy.
+    // This mode is used to quantify the cost of the normal tagging scheme.
+
+    #define ORIGIN_TAG_SET(p)   (p)
+    #define ORIGIN_TAG_CLEAR(p) (p)
+    #define ORIGIN_TAG_QUERY(p) 0
+    #define ORIGIN_TAG_ASGN(p, v) (p)
+    #define ORIGIN_TAG_EITHER(p, v) (p)
+    #define ORIGIN_TAG_NEQ(v1, v2) 0
+
+#else // Normal
+
+    #if defined( __x86_64 )
+        // Preferred case: tag in the most-significant bit.  Dereference
+        // has been shown to segfault consistently.  Maintenance should
+        // list more architectures as "ok" here, to let them use the
+        // preferred case, when valid.
+        #define ORIGIN_TAG_BITNO ( 8 * sizeof( size_t ) - 1 )
+    #else
+        // Fallback case: tag in the least-significant bit.  Dereference
+        // will often give an alignment error, but may not, e.g. if
+        // accessing a char-typed member.  32-bit x86 uses the most-
+        // significant bit for real room on the heap.
+        #define ORIGIN_TAG_BITNO 0
+    #endif
+
+    #define ORIGIN_TAG_MASK (((size_t)1) << ORIGIN_TAG_BITNO)
+
+    #define ORIGIN_TAG_SET(p) ((p) |  ORIGIN_TAG_MASK)
+    #define ORIGIN_TAG_CLEAR(p) ((p) & ~ORIGIN_TAG_MASK)
+    #define ORIGIN_TAG_QUERY(p) ((p) &  ORIGIN_TAG_MASK)
+
+    #define ORIGIN_TAG_ASGN(p, v) ( \
+        verify( ! ORIGIN_TAG_QUERY(p) && "p had no tagbit" ), \
+        ORIGIN_TAG_EITHER((p), (v)) \
+    )
+
+    #define ORIGIN_TAG_EITHER(p, v) ( \
+        verify( ! ORIGIN_TAG_CLEAR(v) && "v is a pure tagbit" ), \
+        ( (p) | (v) ) \
+    )
+
+    #define ORIGIN_TAG_NEQ(v1, v2) ( \
+        verify( ! ORIGIN_TAG_CLEAR(v1) && "v1 is a pure tagbit" ), \
+        verify( ! ORIGIN_TAG_CLEAR(v2) && "v2 is a pure tagbit" ), \
+        ( (v1) ^ (v2) ) \
+    )
+
 #endif
-#define ORIGIN_TAG_MASK (((size_t)1) << ORIGIN_TAG_BITNO)
-
-#define ORIGIN_TAG_SET( p )   ((p) |  ORIGIN_TAG_MASK)
-#define ORIGIN_TAG_CLEAR( p ) ((p) & ~ORIGIN_TAG_MASK)
-#define ORIGIN_TAG_QUERY( p ) ((p) &  ORIGIN_TAG_MASK)
+
+
+
+#ifdef __EXPERIMENTAL_LOOSE_SINGLES__ // Perf experimention alt mode
+
+    // In loose-singles mode, the ability to answer an "is listed" query is disabled, as is "to insert an element,
+    // it must not be listed already" checking.  The user must know separately whether an element is listed.
+    // Other than inserting it, any list-api action on an unlisted element is undefined.  Notably, list iteration
+    // starting from an unlisted element is not defined to respond "no more elements," and may instead continue
+    // iterating from a formerly occupied list position.  This mode matches LQ usage.
+
+    #define NOLOOSE(...)
+    #define LOOSEONLY(...) __VA_ARGS__
+
+#else // Normal
+
+    #define NOLOOSE(...) __VA_ARGS__
+    #define LOOSEONLY(...)
+
+#endif
+
+
+
+
 
 forall( tE & ) {
@@ -102 +164 @@
 
         static inline void ?{}( dlink( tE ) & this ) {
+          NOLOOSE(
                 this.next = this.prev = 0p;
+          )
         }
 
@@ -129 +193 @@
 static inline forall( tE &, tLinks & | embedded( tE, tLinks, dlink( tE ) ) ) {
         bool isListed( tE & node ) {
+      NOLOOSE(
                 verify( &node != 0p );
                 dlink( tE ) & node_links = node`inner;
                 return (node_links.prev != 0p) || (node_links.next != 0p);
+          )
+          LOOSEONLY(
+        verify(false && "isListed is undefined");
+                return true;
+          )
         }
 
@@ -157 +227 @@
 
                 dlink( tE ) & linkToInsert = node`inner;
-
+      NOLOOSE(
                 verify( linkToInsert.next == 0p );
                 verify( linkToInsert.prev == 0p );
+          )
 
                 tE & list_pos_elem = *(tE *)ORIGIN_TAG_CLEAR( (size_t)&before );
@@ -180 +251 @@
 
                 dlink( tE ) & linkToInsert = node`inner;
-
+      NOLOOSE(
                 verify( linkToInsert.prev == 0p );
                 verify( linkToInsert.next == 0p );
+          )
 
                 tE & list_pos_elem = *(tE *)ORIGIN_TAG_CLEAR( (size_t)&after );
@@ -211 +283 @@
                 before_links.next = &after_raw;
                 after_links.prev = &before_raw;
+
+      NOLOOSE(
                 asm( "" : : : "memory" );
                 list_pos_links.prev = 0p;
                 list_pos_links.next = 0p;
                 asm( "" : : : "memory" );
+          )
                 return node;
         }

libcfa/src/stdhdr/assert.h

@@ -38 +38 @@
         #define warnf( expr, fmt, ... ) ({ static bool check_once##__LINE__ = false; if( false == check_once##__LINE__ && false == (expr)) { check_once##__LINE__ = true; __assert_warn_f(__VSTRINGIFY__(expr), __FILE__, __LINE__, __PRETTY_FUNCTION__, fmt, ## __VA_ARGS__ ); } })
 #else
-        #define verify(x)
-        #define verifyf(x, ...)
-        #define verifyfail(...)
-        #define warnf( expr, fmt, ... )
+        #define verify(x) 0
+        #define verifyf(x, ...) 0
+        #define verifyfail(...) 0
+        #define warnf( expr, fmt, ... ) 0
 #endif