Discussion :

[ToTo13]

Bonjour,

j'utilise Java Native Interface pour appeler ce code C++:

Code c++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
template<class T> inline void Maximum(const T *array1, const T *array2, const size_t size, T *result)
	{
	for (size_t i=0 ; i < size ; i++)
		result[i] = array1[i] > array2[i] ? array1[i] : array2[i] ;
	}
 
#ifdef __SSE2__
template<> inline void Maximum<UINT8>(const UINT8 *array1, const UINT8 *array2, const size_t size, UINT8 *result)
	{
	__m128i r0, r1 ;
 
	for (size_t i=0 ; i < size ; i+=16)
		{
		r0 = _mm_load_si128((__m128i *) array1) ;
		r1 = _mm_load_si128((__m128i *) array2) ;
		r1 = _mm_max_epu8(r0, r1) ;
		_mm_store_si128((__m128i *) result, r1) ; // Souci intermittent ici !!!
 
		array1 += 16 ;
		array2 += 16 ;
		result += 16 ;
		}
	}
#endif

et voici les appels depuis la classe cpp, en fonction que je traite un tableau de int ou de byte :

Code c++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
JNIEXPORT void JNICALL Java_arrayTiTi_ArrayMM_MaximumUnsigned___3B_3B_3B(JNIEnv *env, jclass obj, jbyteArray Array1, jbyteArray Array2, jbyteArray Result)
	{
	jsize length = env->GetArrayLength(Array1) ;
	UINT8 *array1 = (UINT8 *)env->GetPrimitiveArrayCritical(Array1, 0) ;
	UINT8 *array2 = (UINT8 *)env->GetPrimitiveArrayCritical(Array2, 0) ;
	jboolean copyres = JNI_FALSE ;
	UINT8 *result = (UINT8 *)env->GetPrimitiveArrayCritical(Result, &copyres) ;
	Maximum(array1, array2, length, result) ;
	env->ReleasePrimitiveArrayCritical(Array1, array1, JNI_ABORT) ;
	env->ReleasePrimitiveArrayCritical(Array2, array2, JNI_ABORT) ;
	env->ReleasePrimitiveArrayCritical(Result, result, copyres == JNI_TRUE ? 0 : JNI_ABORT) ;
	}
 
JNIEXPORT void JNICALL Java_arrayTiTi_ArrayMM_Maximum___3I_3I_3I(JNIEnv *env, jclass obj,
																jintArray Array1, jintArray Array2, jintArray Result)
	{
	jsize length = env->GetArrayLength(Array1) ;
	int *array1 = (int*)env->GetPrimitiveArrayCritical(Array1, 0) ;
	int *array2 = (int*)env->GetPrimitiveArrayCritical(Array2, 0) ;
	jboolean copyres = JNI_FALSE ;
	int *result = (int*)env->GetPrimitiveArrayCritical(Result, &copyres) ;
	Maximum(array1, array2, length, result) ;
	env->ReleasePrimitiveArrayCritical(Array1, array1, JNI_ABORT) ;
	env->ReleasePrimitiveArrayCritical(Array2, array2, JNI_ABORT) ;
	env->ReleasePrimitiveArrayCritical(Result, result, copyres == JNI_TRUE ? 0 : JNI_ABORT) ;
	}

Lorsque je fais passe des tableaux d'int, la simple boucle est appelée et tout se passe sans souci.
En revanche, lorsque je passe des tableaux de byte, la boucle avec les appels SSE2 est utilisé, mais parfois (environ une fois sur six), l'appel _mm_store_si128 génère une erreur.

Est ce que quelqu'un aurait une idée pourquoi ?

[Iradrille]

Hello,

Tes tableaux sont alignés sur 16 octets ?
C'est un prérequis pour _mm_load_si128 et _mm_store_si128.

Si ce n'est pas le cas, utilises _mm_loadu_si128 et _mm_storeu_si128.

[ToTo13]

Merci, j'étais justement en train de creuser de ce coté là :-)

Question annexe : est que cela pose un problème au niveau encodage lorsque je cast les "jbyte" en UINT8 ?
Normalement l'équivalent d'un "jbyte" est un "char". Mais comme mes jbyte représentent en réalité des valeurs positives, alors je me suis laissé tenter à faire des cast en "unsigned char".

[ternel]

Un JBYTE n'est pas un char, mais un signed char, qui n'est pas un unsigned char, mais possède la même taille (requise).
La norme C++ ne demande que, en gros, que le char soit l'un ou l'autre de ces deux types.

Il existe des systèmes où les char font 64 bites, voire plus.

[Iradrille]

Question annexe : est que cela pose un problème au niveau encodage lorsque je cast les "jbyte" en UINT8 ?
Normalement l'équivalent d'un "jbyte" est un "char". Mais comme mes jbyte représentent en réalité des valeurs positives, alors je me suis laissé tenter à faire des cast en "unsigned char".

D'après la doc jbyte == char en C++.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
Table 3-1 Primitive Types and Native Equivalents
Java Type   Native Type     Description
boolean     jboolean        unsigned 8 bits
byte        jbyte           signed 8 bits
char        jchar           unsigned 16 bits
...

http://docs.oracle.com/javase/7/docs...pec/types.html

Mais si tu n'utilises que des valeurs positives que tu utilises des char ou unsigned char n’a pas d'importances.

[ternel]

Du moins, tant que les valeurs restent entre 0 et 127. Mais il semble que ce soit le cas d'un jbyte.

[ToTo13]

mon jbyte contient des valeurs entre 0 et 255, donc elles sont représentées entre -128 et 127.
Je peux les utiliser en "signed char" ou faire un cast en "unsigned char". Je viens de faire quelques milliers de tests avec des tableaux remplis aléatoirement et tout se passe très bien.