265 lines
10 KiB
C++
265 lines
10 KiB
C++
/*
|
|
* Copyright (c) 2007, 2018, Oracle and/or its affiliates. All rights reserved.
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* This code is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 only, as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*/
|
|
|
|
#include <jni.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include "jnihelper.h"
|
|
|
|
extern "C" {
|
|
|
|
#define BOOL 0
|
|
#define BYTE 1
|
|
#define CHAR 2
|
|
#define SHORT 3
|
|
#define INT 4
|
|
#define LONG 5
|
|
#define FLOAT 6
|
|
#define DOUBLE 7
|
|
|
|
JNIEXPORT jobjectArray JNICALL
|
|
Java_nsk_stress_jni_JNIter003_jniInitArrays (JNIEnv *env, jobject jobj, jint size) {
|
|
|
|
jarray *arrayArray;
|
|
jboolean *boolBuf;
|
|
jbyte *byteBuf;
|
|
jchar *charBuf;
|
|
jshort *shortBuf;
|
|
jint *intBuf;
|
|
jlong *longBuf;
|
|
jfloat *floatBuf;
|
|
jdouble *doubleBuf;
|
|
jobjectArray objectsArray;
|
|
|
|
int i;
|
|
int SIZE=size;
|
|
const char *classname="java/lang/Object";
|
|
jclass clazz = env->FindClass(classname); CE
|
|
objectsArray = env->NewObjectArray(8,clazz, env->AllocObject(clazz));
|
|
|
|
arrayArray=(jarray *)malloc(8*sizeof(jarray)); CE
|
|
arrayArray[BOOL]=env->NewBooleanArray(SIZE); CE
|
|
arrayArray[BYTE]=env->NewByteArray(SIZE); CE
|
|
arrayArray[CHAR]=env->NewCharArray(SIZE); CE
|
|
arrayArray[SHORT]=env->NewShortArray(SIZE); CE
|
|
arrayArray[INT]=env->NewIntArray(SIZE); CE
|
|
arrayArray[LONG]=env->NewLongArray(SIZE); CE
|
|
arrayArray[FLOAT]=env->NewFloatArray(SIZE); CE
|
|
arrayArray[DOUBLE]=env->NewDoubleArray(SIZE); CE
|
|
|
|
for (i=0;i<8;i++)
|
|
{ env->SetObjectArrayElement(objectsArray,i,arrayArray[i]); CE }
|
|
|
|
boolBuf=(jboolean *)malloc(SIZE*sizeof(jboolean));
|
|
byteBuf=(jbyte *)malloc(SIZE*sizeof(jbyte));
|
|
charBuf=(jchar *)malloc(SIZE*sizeof(jchar));
|
|
shortBuf=(jshort *)malloc(SIZE*sizeof(jshort));
|
|
intBuf=(jint *)malloc(SIZE*sizeof(jint));
|
|
longBuf=(jlong *)malloc(SIZE*sizeof(jlong));
|
|
floatBuf=(jfloat *)malloc(SIZE*sizeof(jfloat));
|
|
doubleBuf=(jdouble *)malloc(SIZE*sizeof(jdouble));
|
|
|
|
for (i=0;i<SIZE;i++) {
|
|
if (i%2==0) boolBuf[i]=JNI_TRUE;
|
|
else boolBuf[i]=JNI_FALSE;
|
|
/*
|
|
byteBuf[i]=(jbyte)random();
|
|
charBuf[i]=(jchar)random();
|
|
shortBuf[i]=(jshort)random();
|
|
intBuf[i]=(jint)random();
|
|
longBuf[i]=(jlong)random();
|
|
floatBuf[i]=(jfloat)((random()));
|
|
doubleBuf[i]=(jdouble)((random()));
|
|
*/
|
|
byteBuf[i]=(jbyte)109;
|
|
charBuf[i]=(jchar)214;
|
|
shortBuf[i]=(jshort)9223;
|
|
intBuf[i]=(jint)872634;
|
|
longBuf[i]=(jlong)276458276;
|
|
floatBuf[i]=(jfloat)235.4576284;
|
|
doubleBuf[i]=(jdouble)98275.716253567;
|
|
}
|
|
env->SetBooleanArrayRegion((jbooleanArray) arrayArray[BOOL],0,i,boolBuf); CE
|
|
env->SetByteArrayRegion((jbyteArray) arrayArray[BYTE],0,i,byteBuf); CE
|
|
env->SetCharArrayRegion((jcharArray) arrayArray[CHAR],0,i,charBuf); CE
|
|
env->SetShortArrayRegion((jshortArray) arrayArray[SHORT],0,i,shortBuf); CE
|
|
env->SetIntArrayRegion((jintArray) arrayArray[INT],0,i,intBuf); CE
|
|
env->SetLongArrayRegion((jlongArray) arrayArray[LONG],0,i,longBuf); CE
|
|
env->SetFloatArrayRegion((jfloatArray) arrayArray[FLOAT],0,i,floatBuf); CE
|
|
env->SetDoubleArrayRegion((jdoubleArray) arrayArray[DOUBLE],0,i,doubleBuf); CE
|
|
|
|
free(doubleBuf);
|
|
free(floatBuf);
|
|
free(longBuf);
|
|
free(intBuf);
|
|
free(shortBuf);
|
|
free(byteBuf);
|
|
free(charBuf);
|
|
free(boolBuf);
|
|
free(arrayArray);
|
|
|
|
return objectsArray;
|
|
}
|
|
|
|
JNIEXPORT jboolean JNICALL
|
|
Java_nsk_stress_jni_JNIter003_jniBodyChangeArray (JNIEnv *env, jobject jobj,
|
|
jobjectArray orig, jobjectArray clone, jint limit) {
|
|
|
|
#define SWAP(param1, param2) tmparr=param2; param2=param1; param1=tmparr;
|
|
#define SIZE(type) env->GetArrayLength(arrayClone[type])
|
|
|
|
static volatile long count=0;
|
|
jarray *arrayOrig, *arrayClone;
|
|
jboolean *boolOrig, *boolClone;
|
|
jbyte *byteOrig, *byteClone;
|
|
jchar *charOrig, *charClone;
|
|
jshort *shortOrig, *shortClone;
|
|
jint *intOrig, *intClone;
|
|
jlong *longOrig, *longClone;
|
|
jfloat *floatOrig, *floatClone;
|
|
jdouble *doubleOrig, *doubleClone;
|
|
int i;
|
|
|
|
if ((orig==NULL) || (clone==NULL)) {
|
|
fprintf(stderr,"JNI received a NULL array from Java\n");
|
|
return JNI_FALSE;
|
|
}
|
|
if (count == limit) {
|
|
jclass clazz;
|
|
const char *classname = "nsk/stress/jni/JNIter003";
|
|
const char *setdone = "halt";
|
|
const char *setdonesig = "()V";
|
|
jmethodID jmethod;
|
|
|
|
fprintf(stderr, "Count and limit are: %ld\t%d cons.\n", count, limit);
|
|
clazz=env->FindClass(classname); CE
|
|
jmethod=env->GetMethodID(clazz, setdone, setdonesig); CE
|
|
env->CallVoidMethod(jobj, jmethod); CE
|
|
|
|
return JNI_TRUE;
|
|
}
|
|
env->MonitorEnter(jobj); CE
|
|
++count;
|
|
env->MonitorExit(jobj); CE
|
|
arrayOrig=(jarray *)malloc(8*sizeof(jarray));
|
|
arrayClone=(jarray *)malloc(8*sizeof(jarray));
|
|
for (i=0;i<8;i++) {
|
|
arrayOrig[i]=(jarray) env->GetObjectArrayElement(orig,i); CE
|
|
arrayClone[i]=(jarray) env->GetObjectArrayElement(clone,i); CE
|
|
}
|
|
|
|
/* Take the elements from Java arrays into native buffers */
|
|
/* Use Get<Type>ArrayElements */
|
|
boolOrig = env->GetBooleanArrayElements((jbooleanArray) arrayOrig[BOOL],0); CE
|
|
byteOrig = env->GetByteArrayElements((jbyteArray) arrayOrig[BYTE],0); CE
|
|
charOrig = env->GetCharArrayElements((jcharArray) arrayOrig[CHAR],0); CE
|
|
shortOrig = env->GetShortArrayElements((jshortArray) arrayOrig[SHORT],0); CE
|
|
intOrig = env->GetIntArrayElements((jintArray) arrayOrig[INT],0); CE
|
|
longOrig = env->GetLongArrayElements((jlongArray) arrayOrig[LONG],0); CE
|
|
floatOrig = env->GetFloatArrayElements((jfloatArray) arrayOrig[FLOAT],0); CE
|
|
doubleOrig = env->GetDoubleArrayElements((jdoubleArray) arrayOrig[DOUBLE],0); CE
|
|
|
|
/* Alloc some memory for cloned arrays buffers */
|
|
boolClone=(jboolean *)malloc(SIZE(BOOL)*sizeof(jboolean));
|
|
byteClone=(jbyte *)malloc(SIZE(BYTE)*sizeof(jbyte));
|
|
charClone=(jchar *)malloc(SIZE(CHAR)*sizeof(jchar));
|
|
shortClone=(jshort *)malloc(SIZE(SHORT)*sizeof(jshort));
|
|
intClone=(jint *)malloc(SIZE(INT)*sizeof(jint));
|
|
longClone=(jlong *)malloc(SIZE(LONG)*sizeof(jlong));
|
|
floatClone=(jfloat *)malloc(SIZE(FLOAT)*sizeof(jfloat));
|
|
doubleClone=(jdouble *)malloc(SIZE(DOUBLE)*sizeof(jdouble));
|
|
|
|
/* Take the elements from cloned Java arrays into native buffers */
|
|
/* Use Get<Type>ArrayRegion */
|
|
env->GetBooleanArrayRegion((jbooleanArray) arrayClone[BOOL],0,SIZE(BOOL),boolClone); CE
|
|
env->GetByteArrayRegion((jbyteArray) arrayClone[BYTE],0,SIZE(BYTE),byteClone); CE
|
|
env->GetCharArrayRegion((jcharArray) arrayClone[CHAR],0,SIZE(CHAR),charClone); CE
|
|
env->GetShortArrayRegion((jshortArray) arrayClone[SHORT],0,SIZE(SHORT),shortClone); CE
|
|
env->GetIntArrayRegion((jintArray) arrayClone[INT],0,SIZE(INT),intClone); CE
|
|
env->GetLongArrayRegion((jlongArray) arrayClone[LONG],0,SIZE(LONG),longClone); CE
|
|
env->GetFloatArrayRegion((jfloatArray) arrayClone[FLOAT],0,SIZE(FLOAT),floatClone); CE
|
|
env->GetDoubleArrayRegion((jdoubleArray) arrayClone[DOUBLE],0,SIZE(DOUBLE),doubleClone); CE
|
|
|
|
/* In this code section I should make some changes for elements into both */
|
|
/* (original and cloned) arrays and than copied new values back to Java */
|
|
|
|
/*
|
|
Can't change the pointer into the Java structure. It's illegal JNI.
|
|
SWAP(boolOrig,boolClone)
|
|
SWAP(byteOrig,byteClone)
|
|
SWAP(charOrig,charClone)
|
|
SWAP(shortOrig,shortClone)
|
|
SWAP(intOrig,intClone)
|
|
SWAP(longOrig,longClone)
|
|
SWAP(floatOrig,floatClone)
|
|
SWAP(doubleOrig,doubleClone)
|
|
*/
|
|
|
|
/* Coping new values of elements back to Java and releasing native buffers */
|
|
/* Use Set<Type>ArrayRegion */
|
|
/*
|
|
Use Orig pointers to get the original effect of the test.
|
|
env->SetBooleanArrayRegion(arrayClone[BOOL],0,SIZE(BOOL),boolClone);
|
|
env->SetByteArrayRegion(arrayClone[BYTE],0,SIZE(BYTE),byteClone);
|
|
env->SetCharArrayRegion(arrayClone[CHAR],0,SIZE(CHAR),charClone);
|
|
env->SetShortArrayRegion(arrayClone[SHORT],0,SIZE(SHORT),shortClone);
|
|
env->SetIntArrayRegion(arrayClone[INT],0,SIZE(INT),intClone);
|
|
env->SetLongArrayRegion(arrayClone[LONG],0,SIZE(LONG),longClone);
|
|
env->SetFloatArrayRegion(arrayClone[FLOAT],0,SIZE(FLOAT),floatClone);
|
|
env->SetDoubleArrayRegion(arrayClone[DOUBLE],0,SIZE(DOUBLE),doubleClone);
|
|
*/
|
|
env->SetBooleanArrayRegion((jbooleanArray) arrayClone[BOOL],0,SIZE(BOOL),boolOrig); CE
|
|
env->SetByteArrayRegion((jbyteArray) arrayClone[BYTE],0,SIZE(BYTE),byteOrig); CE
|
|
env->SetCharArrayRegion((jcharArray) arrayClone[CHAR],0,SIZE(CHAR),charOrig); CE
|
|
env->SetShortArrayRegion((jshortArray) arrayClone[SHORT],0,SIZE(SHORT),shortOrig); CE
|
|
env->SetIntArrayRegion((jintArray) arrayClone[INT],0,SIZE(INT),intOrig); CE
|
|
env->SetLongArrayRegion((jlongArray) arrayClone[LONG],0,SIZE(LONG),longOrig); CE
|
|
env->SetFloatArrayRegion((jfloatArray) arrayClone[FLOAT],0,SIZE(FLOAT),floatOrig); CE
|
|
env->SetDoubleArrayRegion((jdoubleArray) arrayClone[DOUBLE],0,SIZE(DOUBLE),doubleOrig); CE
|
|
|
|
/* Use Release<Type>ArrayElements */
|
|
env->ReleaseDoubleArrayElements((jdoubleArray) arrayOrig[DOUBLE],doubleOrig,0); CE
|
|
env->ReleaseFloatArrayElements((jfloatArray) arrayOrig[FLOAT],floatOrig,0); CE
|
|
env->ReleaseLongArrayElements((jlongArray) arrayOrig[LONG],longOrig,0); CE
|
|
env->ReleaseIntArrayElements((jintArray) arrayOrig[INT],intOrig,0); CE
|
|
env->ReleaseShortArrayElements((jshortArray) arrayOrig[SHORT],shortOrig,0); CE
|
|
env->ReleaseCharArrayElements((jcharArray) arrayOrig[CHAR],charOrig,0); CE
|
|
env->ReleaseByteArrayElements((jbyteArray) arrayOrig[BYTE],byteOrig,0); CE
|
|
env->ReleaseBooleanArrayElements((jbooleanArray) arrayOrig[BOOL],boolOrig,0); CE
|
|
free(arrayOrig);
|
|
|
|
free(doubleClone);
|
|
free(floatClone);
|
|
free(longClone);
|
|
free(intClone);
|
|
free(shortClone);
|
|
free(byteClone);
|
|
free(charClone);
|
|
free(boolClone);
|
|
free(arrayClone);
|
|
|
|
return JNI_TRUE;
|
|
}
|
|
|
|
}
|