1 / 41

Foreign Function Interface

Foreign Function Interface. More Specifically JNI Justin Catterson. Most languages have a foreign function interface. ADA C++ Java Ruby Python Haskell Perl etc. What is a Foreign Function Interface?. Simply an interface which allows languages to interact with one another.

gomer
Download Presentation

Foreign Function Interface

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. Foreign Function Interface More Specifically JNI Justin Catterson

  2. Most languages have a foreign function interface • ADA • C++ • Java • Ruby • Python • Haskell • Perl • etc. What is a Foreign Function Interface? Simply an interface which allows languages to interact with one another

  3. Reasons for needing Foreign Function Interfaces • Reuse of Legacy Code • Add libraries to language (Object Oriented) • Performance

  4. JNI (Java Native Interface) Released in 1997 Used to call native methods Used to embed a Java Virtual Machine into native applications Suns JDK 1.4.2 contains over 600,00 lines of native C code

  5. Issues with JNI • Software Security • Loss of Portability • Mapping is not easy • Only supports C/C++ can do Ada, Fortran, COBOL but it is more difficult • Strong knowledge in both Java and C • Overhead?

  6. When should I use JNI? When to use • Java API doesn’t support certain features required by application • Want to access an existing library • Implement time-critical sections in a low level language • Multiple processes are taking up too much memory When NOT to use • When you could communicate with native language through TCP/IP connection • Could connect to database using JDBC • Distributed object technology such as Java IDL API

  7. Goals of JNI • Binary Compatibility • Little overhead • Native methods full use of JVM • Not the only FFI available for Java

  8. Design Principles • Make control flow as simplistic as possible • Keep native code minimal (Error checking) • Isolate native code (“Porting layer”)

  9. Basic steps Java to Cthrough command prompt • Add to the system variable path the location of your JDK bin (ie. C:\Program Files (x86)\Java\jdk1.6.0_20\bin) • Write java class with at least one method declared native (ie. Public native void hello() ) • Add call to System.loadLibrary (ie. Static { System.loadLibrary(“hello”);} • Compile java code using javac

  10. Basic steps Java to Cthrough command prompt Create header file for the c using javah Write native method for hello with microsoft visual studio, execute the vcvarsall.bat in the vc directory of visual studio Compile native file into a dll (using cl -Iinclude -Iinclude\win32 -MD -LD hello.cpp -Fejnihello.dll) –l is where the include and include\win32 directories are from the jdk Run the java program

  11. Run example jni

  12. Extra Parameters? • JNIEnv pointer contains the location of the function table • If method is (java static), the method belongs to the java class that contains the native function

  13. How do we use an existing native library? One-to-one mapping public class C { public static native intatol(String str); } JNIExportjint JNICALL Java_C_atol(JNIEnv *env, jclasscls, jstringstr) { const char *cstr = env->GetStringUTFChars(str, 0); if (cstr == NULL) { return 0; // out of memory } int result = atol(cstr); env->ReleaseStringUTFChars(str, cstr); return result; }

  14. C++ to Java (Embed JVM into C++) • Write the Java code • Compile java • Write C++ • Compile C++ • run the exe (Ensure you have the JVM dll directory in the system variable path)

  15. Run example cToJava

  16. JNI functions • http://download.oracle.com/javase/1.5.0/docs/guide/jni/spec/functions.html

  17. JNI and Performance • Typically accepted C and C++ is faster than Java • Is it expensive to make the call through JNI?

  18. Experiment Run benchmark tests to measure execution time between two algorithms in Java and C++ • HeapSort ( Memory ) • Discrete Fast Fourier Transform ( Heavy Math)

  19. Discrete Fast Fourier Transform • Check java’s performance for mathematical computations • If you are interested in learning more • http://home.comcast.net/~szemengtan/LinearSystems/fft.pdf

  20. HeapSort • Array sizes of 250, 1000, and 10000. To check the impact of array sizes on Java and JNI • Vary number of iterations to check start-up cost

  21. Results

  22. Why the performance hit at size 10,000 for JNI?

  23. Not expensive enough to not use Still has cost associated pending the JIT 800-1350 ns per call + 25 to 30ns for each argument (DawidKurzyniec and VaidySunderam)

  24. How to handle overhead cost? • JVM memory and native memory space transfer (hash map store recently accessed fieldids and methods) • Arrays primary concern ( Try to avoid passing them) • Pending VM may make copy

  25. Types • Primitive • Reference

  26. Primitive Types

  27. Reference Types (opaque refrences) All JNI objects inherit from jObject Treated as pointers

  28. Opaque References • Local • Global • Weak

  29. Local References • Content that is created from a native method will only exist during the execution of the native method. Memory corruptions Or system crashes Attempted to use invalid Local address jstring MyNewString(JNIEnv *env, jchar *chars, jintlen) { static jclassstringClass = NULL; jmethodID cid; jcharArrayelemArr; jstring result; if (stringClass == NULL) { stringClass = (*env)->FindClass(env, "java/lang/String"); if (stringClass == NULL) { return NULL; /* exception thrown */ }} /* It is wrong to use the cached stringClass here, because it may be invalid. */ cid = (*env)->GetMethodID(env, stringClass, "<init>", "([C)V"); ... elemArr = (*env)->NewCharArray(env, len); ... result = (*env)->NewObject(env, stringClass, cid, elemArr); (*env)->DeleteLocalRef(env, elemArr); return result; }

  30. Global References • Exists until the programmer deletes the object • No GC jstring MyNewString(JNIEnv *env, jchar *chars, jintlen) { static jclassstringClass = NULL; ... if (stringClass == NULL) { jclasslocalRefCls = (*env)->FindClass(env, "java/lang/String"); if (localRefCls == NULL) { return NULL; /* exception thrown */ } /* Create a global reference */ stringClass = (*env)->NewGlobalRef(env, localRefCls); /* The local reference is no longer useful */ (*env)->DeleteLocalRef(env, localRefCls); /* Is the global reference created successfully? */ if (stringClass == NULL) { return NULL; /* out of memory exception thrown */ } } ... } NewGlobalRef

  31. Weak References JNIEXPORT void JNICALL Java_mypkg_MyCls_f(JNIEnv *env, jobject self) { static jclass myCls2 = NULL; if (myCls2 == NULL) { jclass myCls2Local = (*env)->FindClass(env, "mypkg/MyCls2"); if (myCls2Local == NULL) { return; /* can’t find class */ } myCls2 = NewWeakGlobalRef(env, myCls2Local); if (myCls2 == NULL) { return; /* out of memory */ } } ... /* use myCls2 */ } • Similar to Global references • Valid across native methods and threads • Don’t care if object gets GC

  32. Threading and JNI • JNIenv pointer cannot cache must pass pointer associated with the specific thread • Local references valid only for thread that created it, pass global references • Synchronization use MoniterEnter/MoniterExit

  33. Problems • Safety Guarantees • Safe Language + Unsafe Language = unsafe • C code is unsafe, you may read/write to any memory address • C code can pass objects of wrong type back to Java and therefore violate Java's type checks • Memory Mangement ( calls to release)

  34. How Read/Write problems occur • Private? Constants? • From references, C can see private data and change the values of constants • Interface pointers, this is how C can use Java’s functions. C can overwrite the entries in the function table. • Array Index out of bounds, accidently read/write directly to Java’s heap

  35. Solution? • Safe interoperation (Remote Prodecure Calls) • Ccured (pointer arithmetic solutions) • SafeJNI (wrap JNI api calls) • Jeannie

  36. Remote Procedure Calls • Place components in different address space • Significant overhead

  37. Ccured • Internal safety for C code • Separates pointers by usage • Helps remove array index out of bounds errors

  38. Applications • Real-Time Embedded • Use Java for upper levels (UI, threading, networking) • Have C++/C interface with hardware and signaling, support already exists

  39. Android NDK C • Hardware sensors • Platform operations • 3D libraries Android (JavaME) -- Linux

  40. Conclusions • Use JNI to expand language libraries/ use legacy programs • JNI useful for embedded systems • Java can be easily abused using JNI • Keep native methods in the same “package”

  41. References • 1] Sheng Liang (June 1999). The Java Native Interface Programmer’s Guide and Specification. Retrieved from http://java.sun.com/docs/books/jni/download/jni.pdf • [2] Gang Tan; Andrew W. Appel; SrimatChakradhar; AnandRaghunathan; Srivaths Ravi; Daniel Wang (2006). Safe Java Native Interface.Retrieved from http://www.cs.princeton.edu/~appel/papers/safejni.pdf • [3] Scott Stricker(March 2002). Java Programming with JNI. • Retrieved from http://www.ibm.com/developerworks/java/tutorials/j-jni/ • [4] DawidKurzyniec; VaidySunderam. Efficient Cooperation between Java and Native • Codes - JNI Performance Benchmark. • Retrieved from http://janet-project.sourceforge.net/papers/jnibench.pdf • [5] Demetrius L. Davis. To JNI or not to JNI? • Retrieved from http://www.ewp.rpi.edu/hartford/~rhb/cs_seminar_2004/SessionC3/davis.pdf • [6] PreethamChandrian (August 2011). Efficient Java Native Interface for Android based Mobile Devices. • Retrieved from http://repository.asu.edu/items/9315

More Related