Boosted Java to Native Interface (JNI)

Table des matières
 Présentation et/ou rappel de JNI
 Wrapper C++
 Objectif (quoi)
 Aperçu du code (comment)
 En parallèle
 TypeTrait
 Template Specialization (full, partial)
 Template meta-programming
 SFINAE
 Variadic templates

Durant la présentation…
S’il vous plait
Évitez de poser des questions
…sauf si vous en avez

JNI (Java to Native Interface)
Java
C, C++,
C#,Fortran,
Haskell
(n’importe quel
language qui
supporte la C
calling
convention)

Exemple (Java)
class JniTest
{
/**
Implemented in c++
*/
native boolean nativeMethod(String s);
/**
Called from c++
*/
void javaMethod(int i, float f) {
System.out.println("Hello from native!");
}
static void main(String args) {
new JniTest().nativeMethod("Ni!");
}
static {
System.loadLibrary("MyNativeLibrary");
}
}

Exemple (C++)
JNIEXPORT jboolean JNICALL Java_JniTest_nativeMethod
(JNIEnv* env, jobject obj, jstring s)
{
std::cout << env->GetStringUTFChars(s,0) << std::endl;
jclass clazz = env->FindClass("JniTest");
jmethodID m = env->GetMethodID(clazz, “javaMethod", "(ID)V");
std::thread([=]
{
env->CallStaticObjectMethod(clazz, m, 42, "1.0", 3.14);
}).detach();
return JNI_TRUE;
}
Voyez-vous un bug ?
Et pourtant, ce code compile sans erreur et sans warning!

Solutions existantes
 Générateurs de code
 GIWS
 JACE
 Codemesh JunC++ion
 Wrapper + générateur
 android-cpp-sdk
 Autres (appel de code natif à partir de Java)
 SWIG
 JNIWrapper

L’objectif
 Sans générateur de code
 Sans fichier de configuration
 Sans code d’initialisation
 Sans gras trans
myClass.invoke<void(jint, jfloat)>("javaMethod", 42, 1.0);
Type de la function
Sert à générer la signature JNI
ET à valider la liste des
arguments
Les arguments passés à
la fonction
Le nombre et les types sont
validés à la compilation
Le nom de la
méthode Java
Lance une exception si
elle n’existe pas

Plan de match
1. Génération de la signature JNI (“(IF)V”)
2. Interface d’invocation (invoke())
3. Invocation (env->CallStaticVoidMethod())

Génération de la signature
 Projeter (mapper) un type en string
jint -> "I"
(type) (string)
 Décomposition du function type
void(jint,jfloat) -> Ret = void
P1 = jint
P2 = jfloat
 Bâtir la signature
void(jint, jfloat) -> "(IF)V"

Projeter un type en string
 Solution: TypeTrait
template<class T>
struct JniTypeTrait;
template<> struct JniTypeTrait<jfloat>
{
static const char* signature() {return "F";}
};
template<> struct JniTypeTrait<jint>
{
static const char* signature() {return "I";}
};
// Exemple
const char* signature_int = JniTypeTrait<jint>::signature();
template<> struct JniTypeTrait<void>
{
static const char* signature() {return "V";}
};
// …ainsi de suite pour les autres types

Décomposition du fonction type
Des meta-fonctions ??? Une liste de types ???
typedef boost::mpl::at_c<ParameterTypes, 0>::type P1;
typedef boost::mpl::at_c<ParameterTypes, 1>::type P2;
typedef boost::function_types::parameter_types<F>::type ParameterTypes;
typedef boost::function_types::result_type<F>::type ReturnType;
typedef void(F)(jint, jfloat);

Template Metaprogramming
 Effectuer des calculs par à la compilation
 Les calculs se basent sur des types et des
constantes
 Le résultat est une constante ou du code
 Turing Complete!
 Possible d’effectuer n’importe quelle computation
 Pas de variable!
 Pas de loops. Seulement de la récursion.
 Familiarité avec le paradigme fonctionnel

Exemple: Suite de Fibonacci
template<int n> struct Fibo {
enum {value = Fibo<n-2>::value + Fibo<n-1>::value};
};
template<> struct Fibo<0> {
enum {value = 1};
};
template<> struct Fibo<1> {
enum {value = 1};
};
// Exemples d’utilisation
BOOST_STATIC_ASSERT(Fibo<7>::value == 21);
std::cout << Fibo<12>::value << std::endl;
int array[Fibo<5>::value];

Boost.MPL
// Example #1: vector and push_back
typedef vector<float,double,long double> floats;
typedef push_back<floats,int>::type types;
BOOST_MPL_ASSERT(( is_same< at_c<types,3>::type, int > ));
// Example #2: transform
typedef vector<char, short, int, long, float, double> types;
typedef vector<char*,short*,int*,long*,float*,double*> pointers;
typedef transform< types,boost::add_pointer<_1> >::type result;
BOOST_MPL_ASSERT(( equal<result, pointers> ));
// Example #3: find_if
typedef vector<char,int,unsigned,long,unsigned long> types;
typedef find_if<types, is_same<_1, unsigned> >::type iter;
BOOST_MPL_ASSERT(( is_same< deref<iter>::type, unsigned > ));
BOOST_MPL_ASSERT_RELATION( iter::pos::value, ==, 2 );

Function Type to JNI Signature
std::string buf;
buf += "(";
buf += ")";
buf += JniTypeTrait<ReturnType>::signature();
[&] (auto t) {
buf += JniTypeTrait<decltype(t)>::signature();
}
boost::mpl::for_each<ParameterTypes>(
);
NB: Les polymorphic lambdas (avec auto) ont été introduits dans
C++14 (qui est actuellement en cours de standardisation). Ils sont
disponibles dansVS2013 CTP, GCC 4.9 et Clang 3.4

Plan de match
2. Interface d’invocation (invoke())

Invocation (interface)
 Rappel de l’enjeux:Vérification compile-time
du nombre et du type des arguments
obj.invoke<void(jint, jfloat)>("func", 1); // Error!
obj.invoke<void(jint, jfloat)>("func", 1, 2.0, 3); // Error!
obj.invoke<void(jint, jfloat)>("func", "1", "2.0"); // Error!
obj.invoke<void(jint, jfloat)>("func", 1, 1.0); // OK

Invocation (interface)
template<class F>
typename JniMethod<F>::ReturnType invoke(
const char* methodName
{
// ...
}
template<class F>
const char* methodName,
typename boost::mpl::at_c<typename JniMethod<F>::ParameterTypes, 0>::type p1)
{
// ...
}
template<class F>
const char* methodName,
typename boost::mpl::at_c<typename JniMethod<F>::ParameterTypes, 0>::type p1,
typename boost::mpl::at_c<typename JniMethod<F>::ParameterTypes, 1>::type p2)
{
// ...
}

Question quiz
 Sachant que boost::mpl::at_c<Seq, n> n’est
valide que pour des valeurs de n comprise entre 0
et boost::mpl::size<Seq>::value,
 Comment se peut-il y avoir des overloads de
invoke() pour chaque nombre d’arguments sans
erreur de compilation ?
typedef boost::mpl::vector<int> TypeList;
typedef boost::mpl::at_c<TypeList, 2>::type foo; // Error!

Réponse: SFINAE
 Substitution Failure Is Not An Error
If an invalid argument or return type is formed during the instantiation
of a function template, the instantiation is removed from the overload
resolution set instead of causing a compilation error.
http://boost.org/doc/libs/1_55_0/libs/utility/enable_if.html
 Exemple:
int negate(int i) {
return -i;
}
template<class F>
typename F::result_type negate(const F& f) {
return -f();
}

SFINAE (application)
template<class T>
std::size_t size_in_bits(T t,
typename std::enable_if<std::is_arithmetic<T>>::type* dummy = 0)
{
return 8 * sizeof(T);
}
template<class T>
std::size_t size_in_bits(T t)
{
return 8 * sizeof(T);
}
size_in_bits(42); // 32. OK
size_in_bits(std::string(“yo”)); // 256. OK, mais...?!?
size_in_bits(42); // 32. OK
size_in_bits(std::string(“yo”)); // ERROR. Unable to instantiate template...

Plan de match
3. Invocation (env->CallStaticVoidMethod())

Invocation (implementation)
OK, mais ce n’est pas tout!
CallIntMethod()
Et si ReturnType vaut autre
chose que jint ??
auto r = env_->CallIntMethod(object_, method, p1);
env_.checkException();
return r;

Invocation (variations sur ReturnType)
typedef JniTypeTrait<typename JniMethod<F>::ReturnType> Trait;
((*env_).*Trait::callFunction())
// pointer-to-member-function type (to simplify callFunction() declaration)
typedef jint (JNIEnv::*CallFunctionType)(jobject, jmethodID, ...);
// return the JNIEnv member function to call to return jint
static CallFunctionType callFunction() {return &JNIEnv::CallIntMethod;}

Invocation (cas de ReturnType=void)
Il reste un problème:
auto r = env_->CallVoidMethod(object_, method, p1);
>> ERROR! auto cannot deduce type from void

Invocation (cas de ReturnType=void)
template<class ReturnType, class ParameterTypes>
struct Invoker
{
ReturnType operator()()
{
auto r = ((*env_).*CallFunc_)(object_, method_);
return r;
}
};
template<class ParameterTypes>
struct Invoker<void, ParameterTypes>
{
void operator()()
{
env_->CallVoidMethod(object_, method_);
}
}; Et les paramètres dans tout ça ?

Invocation (paramètres)
template<class... P>
P... params
params...
Variadic templates ?

Variadic templates
template<class Head, class... Tail>
void print(const Head& head, Tail... tail)
{
std::cout << head << " ";
print(tail...);
}
template<class Head>
void print(const Head& head)
{
std::cout << head << std::endl;
}
// Exemple
print(2, "abc", 3.1415);
// resultat:
// 2 abc 3.1415
Template parameter pack
expansion

Voilà!
 Autres fonctionnalités:
 Gestion des références (locales vs globales)
 Gestion des exceptions
 Scope de fonction et de thread
 Facilitateur pour les Strings
 Surveillez les commits dans Lithium
(git@git.innobec.com:innobec/lithium.git)
obj.invoke<void(jint, jfloat)>("javaMethod", 42, 1.0);

Boosted Java to Native Interface (JNI)

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

Similaire à Boosted Java to Native Interface (JNI)

Similaire à Boosted Java to Native Interface (JNI) (20)

Boosted Java to Native Interface (JNI)

Notes de l'éditeur