Changeset 804bf677

Timestamp:

Oct 13, 2021, 9:52:02 PM (3 years ago)

Author:

Michael Brooks <mlbrooks@…>

Branches:

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

Children:

7b0e8b7

Parents:

4b3b352

Message:

String hybrid: Basic cases of solo alloc now working

Files:

• libcfa/src/containers/string_res.cfa (modified) (9 diffs)
• libcfa/src/containers/string_res.hfa (modified) (1 diff)
• tests/collections/.expect/string-ctx-manage.txt (modified) (1 diff)
• tests/collections/string-ctx-manage.cfa (modified) (2 diffs)

libcfa/src/containers/string_res.cfa

@@ -48 +48 @@
 static inline void reduce( VbyteHeap &, int );                  // reduce the size of the byte area
 
-static inline void ?{}( VbyteHeap &, int = 1000 );
+static inline void ?{}( VbyteHeap &, size_t = 1000 );
 static inline void ^?{}( VbyteHeap & );
 static inline void ByteCopy( char *, int, int, char *, int, int ); // copy a block of bytes from one location in the heap to another
@@ -62 +62 @@
 // Allocate the storage for the variable sized area and intialize the heap variables.
 
-static inline void ?{}( VbyteHeap & this, int Size ) with(this) {
+static inline void ?{}( VbyteHeap & this, size_t Size ) with(this) {
 #ifdef VbyteDebug
     serr | "enter:VbyteHeap::VbyteHeap, this:" | &this | " Size:" | Size;
@@ -149 +149 @@
     (older){ ambient_string_sharectx };
     if ( mode == NEW_SHARING ) {
-        (activeHeap){ new( 1000 ) };
+        (activeHeap){ new( (size_t) 1000 ) };
     } else {
         verify( mode == NO_SHARING );
@@ -217 +217 @@
 // Empty constructor
 void ?{}(string_res &s) with(s) {
-    assert( ambient_string_sharectx->activeHeap && "Need to implement private contexts" );
-    (Handle){ * ambient_string_sharectx->activeHeap };
+    if( ambient_string_sharectx->activeHeap ) {
+        (Handle){ * ambient_string_sharectx->activeHeap };
+        (shareEditSet_owns_ulink){ false };
+    } else {
+        (Handle){ * new( (size_t) 10 ) };  // TODO: can I lazily avoid allocating for empty string
+        (shareEditSet_owns_ulink){ true };
+    }
     s.shareEditSet_prev = &s;
     s.shareEditSet_next = &s;
@@ -224 +229 @@
 
 static inline void eagerCopyCtorHelper(string_res &s, const char* rhs, size_t rhslnth) with(s) {
-    assert( ambient_string_sharectx->activeHeap && "Need to implement private contexts" );
-    (Handle){ * ambient_string_sharectx->activeHeap };
+    if( ambient_string_sharectx->activeHeap ) {
+        (Handle){ * ambient_string_sharectx->activeHeap };
+        (shareEditSet_owns_ulink){ false };
+    } else {
+        (Handle){ * new( rhslnth ) };
+        (shareEditSet_owns_ulink){ true };
+    }
     Handle.s = VbyteAlloc(*Handle.ulink, rhslnth);
     Handle.lnth = rhslnth;
@@ -248 +258 @@
 void ?{}(string_res &s, const string_res & s2, StrResInitMode mode, size_t start, size_t end ) {
 
-    assert( ambient_string_sharectx->activeHeap && "Need to implement private contexts" );
-
     verify( start <= end && end <= s2.Handle.lnth );
 
@@ -258 +266 @@
         s.Handle.lnth = end - start;
         s.Handle.ulink = ambient_string_sharectx->activeHeap;
+        (s.shareEditSet_owns_ulink){ false };
         AddThisAfter(s.Handle, s2.Handle );                     // insert this handle after rhs handle
         // ^ bug?  skip others at early point in string
@@ -396 +405 @@
             Handle.s = VbyteAlloc(*Handle.ulink, rhslnth);
             Handle.lnth = rhslnth;
+            (s.shareEditSet_owns_ulink){ false };
             for ( int i = 0; i < rhslnth; i += 1 ) {            // copy characters
                 Handle.s[i] = rhs[i];
@@ -464 +474 @@
     // s.shareEditSet_next = &s;
     // s.shareEditSet_prev = &s;
+
+    if (shareEditSet_owns_ulink && s.shareEditSet_next == &s) { // last one out
+        delete( s.Handle.ulink );
+    }
 }
 

libcfa/src/containers/string_res.hfa

@@ -43 +43 @@
 struct string_res {
     HandleNode Handle; // chars, start, end, global neighbours
+    bool shareEditSet_owns_ulink;
     string_res * shareEditSet_prev;
     string_res * shareEditSet_next;

tests/collections/.expect/string-ctx-manage.txt

@@ -3 +3 @@
 hi
 bye
+hi
 done

tests/collections/string-ctx-manage.cfa

@@ -24 +24 @@
     sout | y; // hi
 
-    x = "bye";                                                     //.... Bookmark 9/30 shallow:  surprisingly this step failed
+    x = "bye";
     y = x; // y was already in different context => eager copy
     assert( y.inner->Handle.s != x.inner->Handle.s);
@@ -30 +30 @@
 }
 
-void failSoloAlloc() {
+void soloAlloc() {
     string x = "hi";
     string_sharectx c = { NO_SHARING };
+    
+    string y = x; // y allocates into private pad, implying eager copy
+    assert( y.inner->Handle.s != x.inner->Handle.s);
+    sout | y; // hi
 
-    // want: allocation into private pad, with forced eager copy into it
-    // got: assertion failure, "Need to implement private contexts"
-    string y = x;
+    // -- following hits "need to implement actual growth"
+    //    and it passes if I modify string_res.cfa to oversize the owned heaps
+
+    // x = "bye";
+    // y = x; // into private y => eager copy
+    // assert( y.inner->Handle.s != x.inner->Handle.s);
+    // sout | y; // bye
 }
 
-volatile bool showFail = false;
 
 int main() {
     baseline();
     eagerCopy();
-    if (showFail) {
-        failSoloAlloc();
-    }
+    soloAlloc();
     printf("done\n");
 }