src/java.base/share/classes/jdk/internal/misc/Unsafe.java

@@ -916,10 +916,93 @@
      */
     private void freeMemoryChecks(long address) {
         checkPointer(null, address);
     }
 
+    /**
+     * ensure writeback of a specified virtual memory address range
+     * from cache to physical memory. all bytes in the address range
+     * are guaranteed to have been written back to physical memory on
+     * return from this call i.e. subsequently executed store
+     * instructions are guaranteed not to be visible before the
+     * writeback is completed.
+     *
+     * @param address
+     *        the lowest byte address that must be guaranteed written
+     *        back to memory. bytes at lower addresses may also be
+     *        written back.
+     *
+     * @param length
+     *        the length in bytes of the region starting at address
+     *        that must be guaranteed written back to memory.
+     *        
+     * @throws RuntimeException if the arguments are invalid
+     *         (<em>Note:</em> after optimization, invalid inputs may
+     *         go undetected, which will lead to unpredictable
+     *         behavior)
+     *
+     * @since 12
+     */
+    
+    public void writebackMemory(long address, long length)
+    {
+        checkWritebackMemory(address, length);
+
+        // perform any required pre-writeback barrier
+        writebackPreSync0();
+
+        // write back one cache line at a time
+        long line = (address & CACHE_LINE_MASK);
+        long end = address + length;
+        while (line < end) {
+            writeback0(line);
+            line += CACHE_LINE_FLUSH_SIZE;
+        }
+
+        // perform any required post-writeback barrier
+        writebackPostSync0();
+    }
+
+    /**
+     * Validate the arguments to writebackMemory
+     *
+     * @throws RuntimeException if the arguments are invalid
+     *         (<em>Note:</em> after optimization, invalid inputs may
+     *         go undetected, which will lead to unpredictable
+     *         behavior)
+     */
+    private void checkWritebackMemory(long address, long length)
+    {
+        checkNativeAddress(address);
+        checkSize(length);
+    }
+    
+    /**
+     * The size of an L1 data cache line which will be a power of two.
+     */
+    private static final long CACHE_LINE_FLUSH_SIZE = (long)theUnsafe.dataCacheLineFlushSize0();
+    private static final long CACHE_LINE_MASK = ~(CACHE_LINE_FLUSH_SIZE - 1);
+
+    /**
+     * primitive operation forcing writeback of a single cache line.
+     *
+     * @param address
+     *        the start address of the cache line to be written back
+     */
+    // native used to write back an individual cache line starting at
+    // the supplied address
+    @HotSpotIntrinsicCandidate
+    private native void writeback0(long address);
+    // native used to serialise writeback operations relative to
+    // preceding memory writes
+    @HotSpotIntrinsicCandidate
+    private native void writebackPreSync0();
+    // native used to serialise writeback operations relative to
+    // following memory writes
+    @HotSpotIntrinsicCandidate
+    private native void writebackPostSync0();
+    
     /// random queries
 
     /**
      * This constant differs from all results that will ever be returned from
      * {@link #staticFieldOffset}, {@link #objectFieldOffset},

@@ -1170,11 +1253,10 @@
      * Reports the size in bytes of a native memory page (whatever that is).
      * This value will always be a power of two.
      */
     public native int pageSize();
 
-
     /// random trusted operations from JNI:
 
     /**
      * Tells the VM to define a class, without security checks.  By default, the
      * class loader and protection domain come from the caller's class.

@@ -3710,10 +3792,11 @@
     private native boolean shouldBeInitialized0(Class<?> c);
     private native void ensureClassInitialized0(Class<?> c);
     private native int arrayBaseOffset0(Class<?> arrayClass);
     private native int arrayIndexScale0(Class<?> arrayClass);
     private native int addressSize0();
+    private native int dataCacheLineFlushSize0();
     private native Class<?> defineAnonymousClass0(Class<?> hostClass, byte[] data, Object[] cpPatches);
     private native int getLoadAverage0(double[] loadavg, int nelems);
     private native boolean unalignedAccess0();
     private native boolean isBigEndian0();
 }