Removing copy with primitive arrays in Unsafe
The copy memory with primitive arrays are no longer used
anywhere, so there is no point in having them in the new
jdk.internal.misc.Unsafe class.
Bug: 203762565
Test: art/test/testrunner/testrunner.py -t 2235-JdkUnsafeTest
Change-Id: Iebe88fdfd37bdd337a9573cabf5661eefa03cdb8
diff --git a/runtime/native/jdk_internal_misc_Unsafe.cc b/runtime/native/jdk_internal_misc_Unsafe.cc
index 6acf4a5..6935332 100644
--- a/runtime/native/jdk_internal_misc_Unsafe.cc
+++ b/runtime/native/jdk_internal_misc_Unsafe.cc
@@ -49,17 +49,6 @@
ThrowRuntimeException("Bad size: %" PRIu64, size);
return false;
}
-
- // Checks a JNI argument `offset` fits inside a size_t and is less than the size. This method
- // and throws a RuntimeException if not (see jdk/internal/misc/Unsafe.java comments).
- bool ValidJniOffsetArgument(jlong offset, jlong size) REQUIRES_SHARED(Locks::mutator_lock_) {
- const jlong maybe_truncated_offset = static_cast<jlong>(static_cast<size_t>(offset));
- if (LIKELY(offset >= 0 && offset < size && offset == maybe_truncated_offset)) {
- return true;
- }
- ThrowRuntimeException("Bad offset %" PRIu64 " size %" PRIu64, offset, size);
- return false;
- }
} // namespace
static jboolean Unsafe_compareAndSetInt(JNIEnv* env, jobject, jobject javaObj, jlong offset,
@@ -372,113 +361,6 @@
memcpy(reinterpret_cast<void *>(dst), reinterpret_cast<void *>(src), memcpy_size);
}
-template<typename T>
-static void copyToArray(jlong srcAddr,
- ObjPtr<mirror::PrimitiveArray<T>> array,
- size_t array_offset,
- size_t size)
- REQUIRES_SHARED(Locks::mutator_lock_) {
- const T* src = reinterpret_cast<T*>(srcAddr);
- size_t sz = size / sizeof(T);
- size_t of = array_offset / sizeof(T);
- for (size_t i = 0; i < sz; ++i) {
- array->Set(i + of, *(src + i));
- }
-}
-
-template<typename T>
-static void copyFromArray(jlong dstAddr,
- ObjPtr<mirror::PrimitiveArray<T>> array,
- size_t array_offset,
- size_t size)
- REQUIRES_SHARED(Locks::mutator_lock_) {
- T* dst = reinterpret_cast<T*>(dstAddr);
- size_t sz = size / sizeof(T);
- size_t of = array_offset / sizeof(T);
- for (size_t i = 0; i < sz; ++i) {
- *(dst + i) = array->Get(i + of);
- }
-}
-
-static void Unsafe_copyMemoryToPrimitiveArray(JNIEnv *env,
- jobject unsafe ATTRIBUTE_UNUSED,
- jlong srcAddr,
- jobject dstObj,
- jlong dstOffset,
- jlong size) {
- ScopedObjectAccess soa(env);
- if (size == 0) {
- return;
- }
- // size is nonnegative and fits into size_t
- if (!ValidJniSizeArgument(size)) {
- DCHECK(soa.Self()->IsExceptionPending());
- return;
- }
- if (!ValidJniOffsetArgument(dstOffset, size)) {
- DCHECK(soa.Self()->IsExceptionPending());
- return;
- }
- const size_t copy_bytes = static_cast<size_t>(size);
- const size_t dst_offset = static_cast<size_t>(dstOffset);
- ObjPtr<mirror::Object> dst = soa.Decode<mirror::Object>(dstObj);
- ObjPtr<mirror::Class> component_type = dst->GetClass()->GetComponentType();
- if (component_type->IsPrimitiveByte() || component_type->IsPrimitiveBoolean()) {
- // Note: Treating BooleanArray as ByteArray.
- copyToArray(srcAddr, ObjPtr<mirror::ByteArray>::DownCast(dst), dst_offset, copy_bytes);
- } else if (component_type->IsPrimitiveShort() || component_type->IsPrimitiveChar()) {
- // Note: Treating CharArray as ShortArray.
- copyToArray(srcAddr, ObjPtr<mirror::ShortArray>::DownCast(dst), dst_offset, copy_bytes);
- } else if (component_type->IsPrimitiveInt() || component_type->IsPrimitiveFloat()) {
- // Note: Treating FloatArray as IntArray.
- copyToArray(srcAddr, ObjPtr<mirror::IntArray>::DownCast(dst), dst_offset, copy_bytes);
- } else if (component_type->IsPrimitiveLong() || component_type->IsPrimitiveDouble()) {
- // Note: Treating DoubleArray as LongArray.
- copyToArray(srcAddr, ObjPtr<mirror::LongArray>::DownCast(dst), dst_offset, copy_bytes);
- } else {
- ThrowIllegalArgumentException("not a primitive array");
- }
-}
-
-static void Unsafe_copyMemoryFromPrimitiveArray(JNIEnv *env,
- jobject unsafe ATTRIBUTE_UNUSED,
- jobject srcObj,
- jlong srcOffset,
- jlong dstAddr,
- jlong size) {
- ScopedObjectAccess soa(env);
- if (size == 0) {
- return;
- }
- // size is nonnegative and fits into size_t
- if (!ValidJniSizeArgument(size)) {
- DCHECK(soa.Self()->IsExceptionPending());
- return;
- }
- if (!ValidJniOffsetArgument(srcOffset, size)) {
- DCHECK(soa.Self()->IsExceptionPending());
- return;
- }
- const size_t copy_bytes = static_cast<size_t>(size);
- const size_t src_offset = static_cast<size_t>(srcOffset);
- ObjPtr<mirror::Object> src = soa.Decode<mirror::Object>(srcObj);
- ObjPtr<mirror::Class> component_type = src->GetClass()->GetComponentType();
- if (component_type->IsPrimitiveByte() || component_type->IsPrimitiveBoolean()) {
- // Note: Treating BooleanArray as ByteArray.
- copyFromArray(dstAddr, ObjPtr<mirror::ByteArray>::DownCast(src), src_offset, copy_bytes);
- } else if (component_type->IsPrimitiveShort() || component_type->IsPrimitiveChar()) {
- // Note: Treating CharArray as ShortArray.
- copyFromArray(dstAddr, ObjPtr<mirror::ShortArray>::DownCast(src), src_offset, copy_bytes);
- } else if (component_type->IsPrimitiveInt() || component_type->IsPrimitiveFloat()) {
- // Note: Treating FloatArray as IntArray.
- copyFromArray(dstAddr, ObjPtr<mirror::IntArray>::DownCast(src), src_offset, copy_bytes);
- } else if (component_type->IsPrimitiveLong() || component_type->IsPrimitiveDouble()) {
- // Note: Treating DoubleArray as LongArray.
- copyFromArray(dstAddr, ObjPtr<mirror::LongArray>::DownCast(src), src_offset, copy_bytes);
- } else {
- ThrowIllegalArgumentException("not a primitive array");
- }
-}
static jboolean Unsafe_getBoolean(JNIEnv* env, jobject, jobject javaObj, jlong offset) {
ScopedFastNativeObjectAccess soa(env);
ObjPtr<mirror::Object> obj = soa.Decode<mirror::Object>(javaObj);
@@ -634,8 +516,6 @@
FAST_NATIVE_METHOD(Unsafe, freeMemory, "(J)V"),
FAST_NATIVE_METHOD(Unsafe, setMemory, "(JJB)V"),
FAST_NATIVE_METHOD(Unsafe, copyMemory, "(JJJ)V"),
- FAST_NATIVE_METHOD(Unsafe, copyMemoryToPrimitiveArray, "(JLjava/lang/Object;JJ)V"),
- FAST_NATIVE_METHOD(Unsafe, copyMemoryFromPrimitiveArray, "(Ljava/lang/Object;JJJ)V"),
FAST_NATIVE_METHOD(Unsafe, getBoolean, "(Ljava/lang/Object;J)Z"),
FAST_NATIVE_METHOD(Unsafe, getByte, "(Ljava/lang/Object;J)B"),
diff --git a/test/2235-JdkUnsafeTest/src/Main.java b/test/2235-JdkUnsafeTest/src/Main.java
index de00155..88eded3 100644
--- a/test/2235-JdkUnsafeTest/src/Main.java
+++ b/test/2235-JdkUnsafeTest/src/Main.java
@@ -70,7 +70,6 @@
testCompareAndSet(unsafe);
testGetAndPutVolatile(unsafe);
testGetAcquireAndPutRelease(unsafe);
- testCopyMemoryPrimitiveArrays(unsafe);
}
private static void testArrayBaseOffset(Unsafe unsafe) {
@@ -380,38 +379,6 @@
"Unsafe.getObjectAcquire(Object, long)");
}
- // Regression test for "copyMemory" operations hitting a DCHECK() for float/double arrays.
- private static void testCopyMemoryPrimitiveArrays(Unsafe unsafe) {
- int size = 4 * 1024;
- long memory = jdkUnsafeTestMalloc(size);
-
- int floatSize = 4;
- float[] inputFloats = new float[size / floatSize];
- for (int i = 0; i != inputFloats.length; ++i) {
- inputFloats[i] = ((float)i) + 0.5f;
- }
- float[] outputFloats = new float[size / floatSize];
- unsafe.copyMemoryFromPrimitiveArray(inputFloats, 0, memory, size);
- unsafe.copyMemoryToPrimitiveArray(memory, outputFloats, 0, size);
- for (int i = 0; i != inputFloats.length; ++i) {
- check(inputFloats[i], outputFloats[i], "unsafe.copyMemory/float");
- }
-
- int doubleSize = 8;
- double[] inputDoubles = new double[size / doubleSize];
- for (int i = 0; i != inputDoubles.length; ++i) {
- inputDoubles[i] = ((double)i) + 0.5;
- }
- double[] outputDoubles = new double[size / doubleSize];
- unsafe.copyMemoryFromPrimitiveArray(inputDoubles, 0, memory, size);
- unsafe.copyMemoryToPrimitiveArray(memory, outputDoubles, 0, size);
- for (int i = 0; i != inputDoubles.length; ++i) {
- check(inputDoubles[i], outputDoubles[i], "unsafe.copyMemory/double");
- }
-
- jdkUnsafeTestFree(memory);
- }
-
private static class TestClass {
public int intVar = 0;
public long longVar = 0;