Changeset 6f7aff3 for tests

Timestamp:

Oct 19, 2021, 10:31:53 AM (3 years ago)

Author:

Michael Brooks <mlbrooks@…>

Branches:

ADT, ast-experimental, enum, master, pthread-emulation, qualifiedEnum

Children:

fe18b46

Parents:

7b0e8b7

Message:

String hybrid assignment to unshared now optimizes to overwrite instead of copy.

Location:

tests/collections

Files:

• string-api-coverage.cfa (modified) (2 diffs)
• string-ctx-manage.cfa (modified) (3 diffs)

tests/collections/string-api-coverage.cfa

@@ -1 +1 @@
 #include <containers/string.hfa>
+#include <string_sharectx.hfa>
 
 void assertWellFormedHandleList( int maxLen ) { // with(HeapArea)
@@ -25 +26 @@
 
 int main () {
+
+    #ifdef STRING_SHARING_OFF
+    sout | "string sharing disabled";
+    string_sharectx c = { NO_SHARING };
+    #endif
+
     string s = "hello";
     string s2 = "hello";

tests/collections/string-ctx-manage.cfa

@@ -3 +3 @@
 #include <string_res.hfa>
 
+// In these tests, shared heaps are never remotely full and string sizes are tiny.
+// So here, the SUT should put a yes-sharing string in a heap with lots of spare room.
+// The SUT should always keep a no-sharing string's buffer 1x--2x the string's size.
+// This check uses 3x as a heuristic split between those cases.
+void assertSpareRoomInHeap( string & s, bool expectOversized ) {
+    double bytesInHeap = DEBUG_string_bytes_in_heap(s.inner->Handle.ulink);
+    double bytesUsed =  s.inner->Handle.lnth;
+    double overhead = bytesInHeap / bytesUsed;
+    assert (overhead >= 1);
+    if ( expectOversized )
+        assert( overhead >= 3.0 );
+    else 
+        assert( overhead < 3.0 );
+}
+
 void baseline() {
     string x = "hi";
+    assertSpareRoomInHeap( x, true );
 
     string y = x; // construct y in same context, no write yet => no copy yet
+    assertSpareRoomInHeap( y, true );
     assert( y.inner->Handle.s == x.inner->Handle.s);
     sout | y; // hi
 
     x = "bye";
+    assertSpareRoomInHeap( x, true );
     y = x; // y in same context, no write yet => no copy yet
+    assertSpareRoomInHeap( y, true );
     assert( y.inner->Handle.s == x.inner->Handle.s);
     sout | y; // bye
@@ -18 +37 @@
 void eagerCopy() {
     string x = "hi";
+    assertSpareRoomInHeap( x, true );
     string_sharectx c = { NEW_SHARING };
 
     string y = x; // construct y in different context => eager copy
+    assertSpareRoomInHeap( y, true );
     assert( y.inner->Handle.s != x.inner->Handle.s);
     sout | y; // hi
 
     x = "bye";
+    assertSpareRoomInHeap( x, true );
     y = x; // y was already in different context => eager copy
+    assertSpareRoomInHeap( y, true );
     assert( y.inner->Handle.s != x.inner->Handle.s);
     sout | y; // bye
@@ -32 +55 @@
 void soloAlloc() {
     string x = "hi";
+    assertSpareRoomInHeap( x, true );
     string_sharectx c = { NO_SHARING };
     
     string y = x; // y allocates into private pad, implying eager copy
+    assertSpareRoomInHeap( y, false );
     assert( y.inner->Handle.s != x.inner->Handle.s);
-    assert( DEBUG_string_bytes_in_heap(y.inner->Handle.ulink) == y.inner->Handle.lnth );  // y is in a perfectly fitting heap
     sout | y; // hi
 
     x = "bye";
+    assertSpareRoomInHeap( x, true );
     y = x; // into private y => eager copy
+    assertSpareRoomInHeap( y, false );
     assert( y.inner->Handle.s != x.inner->Handle.s);
-//    assert( DEBUG_string_bytes_in_heap(y.inner->Handle.ulink) == y.inner->Handle.lnth );  // optimization required
     sout | y; // bye
 }