src/hotspot/share/prims/unsafe.cpp

*** 40,49 ****
--- 40,50 ----
  #include "runtime/globals.hpp"
  #include "runtime/interfaceSupport.inline.hpp"
  #include "runtime/jniHandles.inline.hpp"
  #include "runtime/orderAccess.hpp"
  #include "runtime/reflection.hpp"
+ #include "runtime/sharedRuntime.hpp"
  #include "runtime/thread.hpp"
  #include "runtime/threadSMR.hpp"
  #include "runtime/vm_version.hpp"
  #include "services/threadService.hpp"
  #include "utilities/align.hpp"
*** 440,449 ****
--- 441,518 ----
        Copy::conjoint_swap(src, dst, sz, esz);
      } JVM_END
    }
  } UNSAFE_END
  
+ UNSAFE_LEAF (void, Unsafe_WriteBack0(JNIEnv *env, jobject unsafe, jlong line)) {
+ #ifndef PRODUCT
+   if (TraceMemoryWriteback) {
+     tty->print_cr("Unsafe: writeback 0x%p", addr_from_java(line));
+   }
+ #endif
+ 
+   // guard against currently unimplemented cases
+ #if !defined(LINUX) || !(defined(AARCH64) || defined(AMD64))
+   // TODO - implement for solaris/AIX/BSD/WINDOWS and for 32 bit
+   JNU_ThrowRuntimeException(env, "writeback is not implemented");
+   return IOS_THROWN;
+ #else
+   void (*wb)(void *);
+   void *a = addr_from_java(line);
+   wb = (void (*)(void *)) StubRoutines::data_cache_writeback();
+   assert(wb != NULL, "generate writeback stub!");
+   (*wb)(a);
+ #endif
+ } UNSAFE_END
+ 
+ static void doWriteBackSync0(bool isPre)
+ {
+   void (*wbsync)(int);
+   wbsync = (void (*)(int)) StubRoutines::data_cache_writeback_sync();
+   assert(wbsync != NULL, "generate writeback sync stub!");
+   (*wbsync)(isPre);
+ }
+ 
+ UNSAFE_LEAF (void, Unsafe_WriteBackPreSync0(JNIEnv *env, jobject unsafe)) {
+ #ifndef PRODUCT
+   if (TraceMemoryWriteback) {
+       tty->print_cr("Unsafe: writeback pre-sync");
+   }
+ #endif
+ #if !defined(LINUX) || !(defined(AARCH64) || defined(AMD64))
+   // TODO - implement for solaris/AIX/BSD/WINDOWS and for 32 bit
+   JNU_ThrowRuntimeException(env, "writeback sync is not implemented");
+   return IOS_THROWN;
+ #else
+   doWriteBackSync0(true);
+ #endif
+ } UNSAFE_END
+ 
+ UNSAFE_LEAF (void, Unsafe_WriteBackPostSync0(JNIEnv *env, jobject unsafe)) {
+ #ifndef PRODUCT
+   if (TraceMemoryWriteback) {
+     tty->print_cr("Unsafe: writeback pre-sync");
+   }
+ #endif
+ #if !defined(LINUX) || !(defined(AARCH64) || defined(AMD64))
+   // TODO - implement for solaris/AIX/BSD/WINDOWS and for 32 bit
+   JNU_ThrowRuntimeException(env, "writeback sync is not implemented");
+   return IOS_THROWN;
+ #else
+   doWriteBackSync0(false);
+ #endif
+ } UNSAFE_END
+ 
+ UNSAFE_LEAF(jint, Unsafe_DataCacheLineFlushSize0()) {
+   jint size = (jint)VM_Version::data_cache_line_flush_size();
+   // TODO -- ensure every CPU actually sets this
+   if (size == 0) {
+     size = (jint)DEFAULT_CACHE_LINE_SIZE;
+   }
+   return size;
+ } UNSAFE_END
+ 
  ////// Random queries
  
  UNSAFE_LEAF(jint, Unsafe_AddressSize0(JNIEnv *env, jobject unsafe)) {
    return sizeof(void*);
  } UNSAFE_END
*** 1059,1068 ****
--- 1128,1138 ----
      {CC "staticFieldOffset0", CC "(" FLD ")J",           FN_PTR(Unsafe_StaticFieldOffset0)},
      {CC "staticFieldBase0",   CC "(" FLD ")" OBJ,        FN_PTR(Unsafe_StaticFieldBase0)},
      {CC "ensureClassInitialized0", CC "(" CLS ")V",      FN_PTR(Unsafe_EnsureClassInitialized0)},
      {CC "arrayBaseOffset0",   CC "(" CLS ")I",           FN_PTR(Unsafe_ArrayBaseOffset0)},
      {CC "arrayIndexScale0",   CC "(" CLS ")I",           FN_PTR(Unsafe_ArrayIndexScale0)},
+     {CC "dataCacheLineFlushSize0", CC "()I",             FN_PTR(Unsafe_DataCacheLineFlushSize0)},
      {CC "addressSize0",       CC "()I",                  FN_PTR(Unsafe_AddressSize0)},
      {CC "pageSize",           CC "()I",                  FN_PTR(Unsafe_PageSize)},
  
      {CC "defineClass0",       CC "(" DC_Args ")" CLS,    FN_PTR(Unsafe_DefineClass0)},
      {CC "allocateInstance",   CC "(" CLS ")" OBJ,        FN_PTR(Unsafe_AllocateInstance)},
*** 1079,1088 ****
--- 1149,1161 ----
  
      {CC "getLoadAverage0",    CC "([DI)I",               FN_PTR(Unsafe_GetLoadAverage0)},
  
      {CC "copyMemory0",        CC "(" OBJ "J" OBJ "JJ)V", FN_PTR(Unsafe_CopyMemory0)},
      {CC "copySwapMemory0",    CC "(" OBJ "J" OBJ "JJJ)V", FN_PTR(Unsafe_CopySwapMemory0)},
+     {CC "writeback0",         CC "(" "J" ")V",           FN_PTR(Unsafe_WriteBack0)},
+     {CC "writebackPreSync0",     CC "()V",               FN_PTR(Unsafe_WriteBackPreSync0)},
+     {CC "writebackPostSync0",     CC "()V",              FN_PTR(Unsafe_WriteBackPostSync0)},
      {CC "setMemory0",         CC "(" OBJ "JJB)V",        FN_PTR(Unsafe_SetMemory0)},
  
      {CC "defineAnonymousClass0", CC "(" DAC_Args ")" CLS, FN_PTR(Unsafe_DefineAnonymousClass0)},
  
      {CC "shouldBeInitialized0", CC "(" CLS ")Z",         FN_PTR(Unsafe_ShouldBeInitialized0)},