Changeset 4b3b352

Timestamp:

Oct 7, 2021, 2:13:46 PM (3 years ago)

Author:

Michael Brooks <mlbrooks@…>

Branches:

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

Children:

804bf677

Parents:

0f781fb8

Message:

String hybrid has working separated sharing contexts

Files:

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

libcfa/src/containers/string.cfa

@@ -92 +92 @@
 }
 
-string ?=?(string & this, string other) {
+string & ?=?(string & this, string & other) { //// <---- straw man change
     (*this.inner) = (*other.inner);
     return this;

libcfa/src/containers/string.hfa

@@ -41 +41 @@
 void ?=?(string &s, const string &other);
 void ?=?(string &s, char other);
-string ?=?(string &s, string other);  // string tolerates memcpys; still saw calls to autogen 
-
+string & ?=?(string &s, string &other);  // surprising ret seems to help avoid calls to autogen
+//string ?=?( string &, string ) = void;
 void ^?{}(string &s);
 

libcfa/src/containers/string_res.cfa

@@ -223 +223 @@
 }
 
-// Constructor from a raw buffer and size
-void ?{}(string_res &s, const char* rhs, size_t rhslnth) with(s) {
+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 };
@@ -236 +235 @@
 }
 
+// Constructor from a raw buffer and size
+void ?{}(string_res &s, const char* rhs, size_t rhslnth) with(s) {
+    eagerCopyCtorHelper(s, rhs, rhslnth);
+}
+
 // String literal constructor
 void ?{}(string_res &s, const char* rhs) {
@@ -245 +249 @@
 
     assert( ambient_string_sharectx->activeHeap && "Need to implement private contexts" );
-    assert( s2.Handle.ulink == ambient_string_sharectx->activeHeap && "need to implement context crossing");
 
     verify( start <= end && end <= s2.Handle.lnth );
 
-    (s.Handle){};
-    s.Handle.s = s2.Handle.s + start;
-    s.Handle.lnth = end - start;
-    s.Handle.ulink = ambient_string_sharectx->activeHeap;
-    AddThisAfter(s.Handle, s2.Handle );                 // insert this handle after rhs handle
-    // ^ bug?  skip others at early point in string
+    if (s2.Handle.ulink == ambient_string_sharectx->activeHeap) {
+        // same heap: allow overlap
+        (s.Handle){};
+        s.Handle.s = s2.Handle.s + start;
+        s.Handle.lnth = end - start;
+        s.Handle.ulink = ambient_string_sharectx->activeHeap;
+        AddThisAfter(s.Handle, s2.Handle );                     // insert this handle after rhs handle
+        // ^ bug?  skip others at early point in string
     
-    if (mode == COPY_VALUE) {
-        // make s alone in its shareEditSet
-        s.shareEditSet_prev = &s;
-        s.shareEditSet_next = &s;
+        if (mode == COPY_VALUE) {
+            // make s alone in its shareEditSet
+            s.shareEditSet_prev = &s;
+            s.shareEditSet_next = &s;
+        } else {
+            verify( mode == SHARE_EDITS );
+
+            // s2 is logically const but not implementation const
+            string_res & s2mod = (string_res &) s2;
+
+            // insert s after s2 on shareEditSet
+            s.shareEditSet_next = s2mod.shareEditSet_next;
+            s.shareEditSet_prev = &s2mod;
+            s.shareEditSet_next->shareEditSet_prev = &s;
+            s.shareEditSet_prev->shareEditSet_next = &s;
+        }
     } else {
-        verify( mode == SHARE_EDITS );
-
-        // s2 is logically const but not implementation const
-        string_res & s2mod = (string_res &) s2;
-
-        // insert s after s2 on shareEditSet
-        s.shareEditSet_next = s2mod.shareEditSet_next;
-        s.shareEditSet_prev = &s2mod;
-        s.shareEditSet_next->shareEditSet_prev = &s;
-        s.shareEditSet_prev->shareEditSet_next = &s;
-    }
-}
-
-void assign(string_res &this, const char* buffer, size_t bsize) {
-
-    // traverse the incumbent share-edit set (SES) to recover the range of a base string to which `this` belongs
-    string_res * shareEditSetStartPeer = & this;
-    string_res * shareEditSetEndPeer = & this;
-    for (string_res * editPeer = this.shareEditSet_next; editPeer != &this; editPeer = editPeer->shareEditSet_next) {
-        if ( editPeer->Handle.s < shareEditSetStartPeer->Handle.s ) {
-            shareEditSetStartPeer = editPeer;
-        }
-        if ( shareEditSetEndPeer->Handle.s + shareEditSetEndPeer->Handle.lnth < editPeer->Handle.s + editPeer->Handle.lnth) {
-            shareEditSetEndPeer = editPeer;
-        }
-    }
-
-    // full string is from start of shareEditSetStartPeer thru end of shareEditSetEndPeer
-    // `this` occurs in the middle of it, to be replaced
-    // build up the new text in `pasting`
-
-    string_res pasting = {
-        shareEditSetStartPeer->Handle.s,                   // start of SES
-        this.Handle.s - shareEditSetStartPeer->Handle.s }; // length of SES, before this
-    append( pasting,
-        buffer,                                            // start of replacement for this
-        bsize );                                           // length of replacement for this
-    append( pasting,
-        this.Handle.s + this.Handle.lnth,                  // start of SES after this
-        shareEditSetEndPeer->Handle.s + shareEditSetEndPeer->Handle.lnth -
-        (this.Handle.s + this.Handle.lnth) );              // length of SES, after this
-
-    // The above string building can trigger compaction.
-    // The reference points (that are arguments of the string building) may move during that building.
-    // From this point on, they are stable.
-    // So now, capture their values for use in the overlap cases, below.
-    // Do not factor these definitions with the arguments used above.
+        // crossing heaps: eager copy
+        assert( mode == COPY_VALUE && "need to solidify context-crossing rules for requesting shared edits");
+        eagerCopyCtorHelper(s, s2.Handle.s + start, end - start);
+        verify(s.shareEditSet_prev == &s);
+        verify(s.shareEditSet_next == &s);
+    }
+}
+
+static void assignEditSet(string_res & this, string_res * shareEditSetStartPeer, string_res * shareEditSetEndPeer,
+    char * resultSesStart,
+    size_t resultSesLnth,
+    HandleNode * resultPadPosition, size_t bsize ) {
 
     char * beforeBegin = shareEditSetStartPeer->Handle.s;
@@ -317 +299 @@
     size_t oldLnth = this.Handle.lnth;
 
-    this.Handle.s = pasting.Handle.s + beforeLen;
+    this.Handle.s = resultSesStart + beforeLen;
     this.Handle.lnth = bsize;
-    MoveThisAfter( this.Handle, pasting.Handle );
+    MoveThisAfter( this.Handle, *resultPadPosition );
 
     // adjust all substring string and handle locations, and check if any substring strings are outside the new base string
-    char *limit = pasting.Handle.s + pasting.Handle.lnth;
+    char *limit = resultSesStart + resultSesLnth;
     for (string_res * p = this.shareEditSet_next; p != &this; p = p->shareEditSet_next) {
         verify (p->Handle.s >= beforeBegin);
@@ -353 +335 @@
             // take start as start-anchored
             size_t startOffsetFromStart = p->Handle.s - beforeBegin;
-            p->Handle.s = pasting.Handle.s + startOffsetFromStart;
+            p->Handle.s = resultSesStart + startOffsetFromStart;
         } else {
             verify ( p->Handle.s < afterBegin );
@@ -371 +353 @@
             }
         }
-        MoveThisAfter( p->Handle, pasting.Handle );     // move substring handle to maintain sorted order by string position
-    }
+        MoveThisAfter( p->Handle, *resultPadPosition ); // move substring handle to maintain sorted order by string position
+    }
+}
+
+static void assign_(string_res &this, const char* buffer, size_t bsize, const string_res & valSrc) {
+
+    // traverse the incumbent share-edit set (SES) to recover the range of a base string to which `this` belongs
+    string_res * shareEditSetStartPeer = & this;
+    string_res * shareEditSetEndPeer = & this;
+    for (string_res * editPeer = this.shareEditSet_next; editPeer != &this; editPeer = editPeer->shareEditSet_next) {
+        if ( editPeer->Handle.s < shareEditSetStartPeer->Handle.s ) {
+            shareEditSetStartPeer = editPeer;
+        }
+        if ( shareEditSetEndPeer->Handle.s + shareEditSetEndPeer->Handle.lnth < editPeer->Handle.s + editPeer->Handle.lnth) {
+            shareEditSetEndPeer = editPeer;
+        }
+    }
+
+    verify( shareEditSetEndPeer->Handle.s >= shareEditSetStartPeer->Handle.s );
+    size_t editSetLength = shareEditSetEndPeer->Handle.s + shareEditSetEndPeer->Handle.lnth - shareEditSetStartPeer->Handle.s;
+    verify( editSetLength >= this.Handle.lnth );
+
+
+    if ( this.Handle.lnth == editSetLength                // the entire run of the share-edit set is being overwritten: SES's result will only use characters from the source string
+        && & valSrc                                       // sourcing from a managed string
+        && valSrc.Handle.ulink == this.Handle.ulink  ) {  // sourcing from same heap
+
+        assignEditSet(this, shareEditSetStartPeer, shareEditSetEndPeer, 
+            valSrc.Handle.s,
+            valSrc.Handle.lnth,
+            &((string_res&)valSrc).Handle, bsize);
+        
+    } else {
+
+        // full string is from start of shareEditSetStartPeer thru end of shareEditSetEndPeer
+        // `this` occurs in the middle of it, to be replaced
+        // build up the new text in `pasting`
+
+        // super private string ctor: ignore ambient context
+        void ?{}( string_res &s, VbyteHeap & heap, const char* rhs, size_t rhslnth ) with(s) {
+            (Handle){ heap };
+            Handle.s = VbyteAlloc(*Handle.ulink, rhslnth);
+            Handle.lnth = rhslnth;
+            for ( int i = 0; i < rhslnth; i += 1 ) {            // copy characters
+                Handle.s[i] = rhs[i];
+            } // for
+            s.shareEditSet_prev = &s;
+            s.shareEditSet_next = &s;
+        }
+
+        // we are only overwriting a proper substring of some string: need to mash characters from old and new together
+        // OR we are importing characters: need to copy eagerly
+        string_res pasting = {
+            * this.Handle.ulink,                               // maintain same heap, regardless of context
+            shareEditSetStartPeer->Handle.s,                   // start of SES
+            this.Handle.s - shareEditSetStartPeer->Handle.s }; // length of SES, before this
+        append( pasting,
+            buffer,                                            // start of replacement for this
+            bsize );                                           // length of replacement for this
+        append( pasting,
+            this.Handle.s + this.Handle.lnth,                  // start of SES after this
+            shareEditSetEndPeer->Handle.s + shareEditSetEndPeer->Handle.lnth -
+            (this.Handle.s + this.Handle.lnth) );              // length of SES, after this
+
+        // The above string building can trigger compaction.
+        // The reference points (that are arguments of the string building) may move during that building.
+        // From this point on, they are stable.
+
+        assignEditSet(this, shareEditSetStartPeer, shareEditSetEndPeer, 
+            pasting.Handle.s,
+            pasting.Handle.lnth,
+            &pasting.Handle, bsize);
+    }
+
+    // So now, capture their values for use in the overlap cases, below.
+    // Do not factor these definitions with the arguments used in string building above.
+
+}
+
+void assign(string_res &this, const char* buffer, size_t bsize) {
+    assign_(this, buffer, bsize, *0p);
 }
 
@@ -385 +446 @@
 // Copy assignment operator
 void ?=?(string_res & this, const string_res & rhs) with( this ) {
-    assign(this, rhs.Handle.s, rhs.Handle.lnth);
+    assign_(this, rhs.Handle.s, rhs.Handle.lnth, rhs);
 }
 

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

@@ +1 @@
+hi
+bye
+hi
+bye
 done

tests/collections/string-ctx-manage.cfa

@@ -1 +1 @@
 #include <string.hfa>
 #include <string_sharectx.hfa>
+#include <string_res.hfa>
 
-// The functionality for these tests isn't written yet.
-// But its interface compiles and the cases it drives are detected.
+void baseline() {
+    string x = "hi";
 
-void failEagerCopy() {
+    string y = x; // construct y in same context, no write yet => no copy yet
+    assert( y.inner->Handle.s == x.inner->Handle.s);
+    sout | y; // hi
+
+    x = "bye";
+    y = x; // y in same context, no write yet => no copy yet
+    assert( y.inner->Handle.s == x.inner->Handle.s);
+    sout | y; // bye
+}
+
+void eagerCopy() {
     string x = "hi";
-    string_sharectx c = { NO_SHARING };
+    string_sharectx c = { NEW_SHARING };
 
-    // want: implied forced eager copy
-    // got: assertion failure, "need to implement context crossing"
-    string y = x;
+    string y = x; // construct y in different context => eager copy
+    assert( y.inner->Handle.s != x.inner->Handle.s);
+    sout | y; // hi
+
+    x = "bye";                                                     //.... Bookmark 9/30 shallow:  surprisingly this step failed
+    y = x; // y was already in different context => eager copy
+    assert( y.inner->Handle.s != x.inner->Handle.s);
+    sout | y; // bye
 }
 
@@ -26 +42 @@
 
 int main() {
+    baseline();
+    eagerCopy();
     if (showFail) {
-        failEagerCopy();
         failSoloAlloc();
     }