I didn't like the implementation of DS.common/MemorySegmentStatus.

So this new one takes advantage of a new FFM method.

Author: leerho

src/main/java/org/apache/datasketches/common/MemorySegmentStatus.java

@@ -20,6 +20,7 @@
 package org.apache.datasketches.common;
 
 import java.lang.foreign.MemorySegment;
+import java.util.Optional;
 
 /**
  * Methods for inquiring the status of a backing MemorySegment.
@@ -40,49 +41,38 @@ public interface MemorySegmentStatus {
   boolean isOffHeap();
 
   /**
-   * Returns true if an internally referenced MemorySegment refers to the same MemorySegment as <i>that</i>.
-   * They can either have the same off-heap memory location and size, or refer to the same on-heap array object.
+   * Returns true if an internally referenced MemorySegment has the same backing resource as <i>that</i>,
+   * or equivalently, if their two memory regions overlap.  This applies to both on-heap and off-heap MemorySegments.
    *
-   * <p>If both segment are off-heap, they both must have the same starting address and the same size.</p>
+   * <p>This returns false if either segment is <i>null</i> or not alive.</p>
    *
-   * <p>For on-heap segments, both segments must be based on or derived from the same array object and neither segment
-   * can be read-only.</p>
-   *
-   * <p>Returns false if either argument is null;</p>
+   * <p><b>Note:</b> If both segments are on-heap and not read-only, it can be determined if they were derived from
+   * the same backing memory (array).  However, this is not always possible off-heap. Because of this asymmetry, this definition
+   * of "isSameResource" is confined to the existence of an overlap.</p>
    *
    * @param that The given MemorySegment.
-   * @return true if an internally referenced MemorySegment refers to the same MemorySegment as <i>that</i>.
+   * @return true if an internally referenced MemorySegment has the same backing resource as <i>that</i>.
    */
   boolean isSameResource(final MemorySegment that);
 
   /**
-   * Returns true if the two given MemorySegments refer to the same backing resource,
-   * which is either an off-heap memory address and size, or the same on-heap array object.
-   *
-   * <p>If both segment are off-heap, they both must have the same starting address and the same size.</p>
+   * Returns true if the two given MemorySegments have to the same backing resource, or equivalently,
+   * if the two memory regions overlap.  This applies to both on-heap and off-heap MemorySegments.
    *
-   * <p>For on-heap segments, both segments must be based on or derived from the same array object and neither segment
-   * can be read-only.</p>
+   * <p>This returns false if either segment is <i>null</i> or not alive.</p>
    *
-   * <p>Returns false if either argument is null;</p>
+   * <p><b>Note:</b> If both segments are on-heap and not read-only, it can be determined if they were derived from
+   * the same backing memory (array).  However, this is not always possible off-heap. Because of this asymmetry, this definition
+   * of "isSameResource" is confined to the existence of an overlap.</p>
    *
    * @param seg1 The first given MemorySegment
    * @param seg2 The second given MemorySegment
-   * @return true if both MemorySegments are determined to be the same backing memory.
+   * @return true if the two given MemorySegments have to the same backing resource.
    */
   static boolean isSameResource(final MemorySegment seg1, final MemorySegment seg2) {
-    if ((seg1 == null) || (seg2 == null)) { return false; }
-    if (!seg1.scope().isAlive() || !seg2.scope().isAlive()) {
-      throw new IllegalArgumentException("Both arguments must be alive.");
-    }
-    final boolean seg1Native = seg1.isNative();
-    final boolean seg2Native = seg2.isNative();
-    if (seg1Native ^ seg2Native) { return false; }
-    if (seg1Native && seg2Native) { //both off heap
-      return (seg1.address() == seg2.address()) && (seg1.byteSize() == seg2.byteSize());
-    }
-    //both on heap
-    return seg1 == seg2;
+    if ((seg1 == null) || (seg2 == null) || !seg1.scope().isAlive() || !seg2.scope().isAlive()) { return false; }
+    final Optional<MemorySegment> opt = seg1.asOverlappingSlice(seg2);
+    return opt.isPresent();
   }
 
 }

src/main/java/org/apache/datasketches/theta/UpdateSketch.java

@@ -181,7 +181,7 @@ public boolean isOrdered() {
 
   @Override
   public boolean isSameResource(final MemorySegment that) {
-    return ((this instanceof DirectQuickSelectSketchR) &&  ((DirectQuickSelectSketchR)this).isSameResource(that));
+    return (this instanceof final DirectQuickSelectSketchR dqssr) && dqssr.isSameResource(that);
   }
 
   //UpdateSketch interface

src/test/java/org/apache/datasketches/theta/SketchTest.java

@@ -337,7 +337,7 @@ public void checkIsSameResource() {
     sketch.update(2);
     assertTrue(sketch.isSameResource(seg));
     final DirectCompactSketch dcos = (DirectCompactSketch) sketch.compact(true, cseg);
-    assertTrue(MemorySegmentStatus.isSameResource(dcos.getMemorySegment(),  cseg));
+    assertTrue(MemorySegmentStatus.isSameResource(dcos.getMemorySegment(), cseg));
     assertTrue(dcos.isOrdered());
     //never create 2 sketches with the same MemorySegment, so don't do as I do :)
     final DirectCompactSketch dcs = (DirectCompactSketch) sketch.compact(false, cseg);

src/test/java/org/apache/datasketches/theta/UnionImplTest.java

@@ -227,9 +227,9 @@ public void checkMoveAndResizeOffHeap() {
 
       //Here we create a 2nd Union with a heap segment
       final MemorySegment uWsegHeap = MemorySegment.ofArray(new byte[bytes / 2]);
-      final Union union2 = SetOperation.builder().buildUnion(); //on-heap union
+      final Union union2 = SetOperation.builder().buildUnion(uWsegHeap); //union with on-heap segment
       //As before, this establishes that the empty union2 has the same segment that we gave it.
-      assertTrue(union2.isSameResource(uWsegHeap)); //But Copilot complained, so here it is!
+      assertTrue(union2.isSameResource(uWsegHeap)); //Copilot complained this was absent, so here it is!
 
       //These two asserts are calling the Interface static method directly and establish
       // what should be obvious, that these are all different segments.