If we do not have any WSN mote on which to run the Contiki program, we can use the Contiki simulator COOJA, actually, it should be considered as an emulator, however, in many papers and documents COOJA is called as simulator. Although COOJA has limitations, it’s still useful for reviewing and debugging. COOJA is a part of the Contiki tools, which can be found in <contiki_root>/tools/cooja;
.
A simulated (emulated) Contiki Mote in COOJA is an actual compiled and executing Contiki system. The system is controlled and analyzed by COOJA. This is performed by compiling Contiki for the native platform as a shared library, and loading the library into Java using Java Native Interfaces (JNI).
1 | Several different Contiki libraries can be compiled and loaded in the same COOJA simulation, representing different kinds of sensor nodes (heterogeneous networks). |
Most of the disadvantages of COOJA comes from its JNI, here comes comments about JNI
Advantages of JNI
- JNI enables one to write programs in native language or method when an application cannot be written entirely in the Java programming language.
- It is also used to modify an existing application which is written in another programming language so that it can be accessible to Java applications.
- It allows all Java applications to access performance- and platform-sensitive API implementations functionality in a safe and platform-independent manner.
- JNI helps to address the interoperability issues.
Disadvantages of JNI
- An application that relies on JNI loses the platform portability that Java offers. Moreover, only the applications and signed applets can call JNI.
- The JNI framework does not provide any automatic garbage collection for non-JVM memory resources allocated by code executing on the native side.
- Error checking is a must or it has the potential to crash the JNI side and the JVM.
- On Linux platforms, if the Native code registers itself as a signal handler, it will intercept the signal sent to the JVM.
- Difficult to debug runtime error in native code.
- In the process of using JNI, some minor bugs may cause errors that are difficult to reproduce and debug the entire JVM.
Considering the aforementioned disadvantages of JNI and COOJA is establish based on JNI, when we design an application which will use the JNI or run on the COOJA, the following suggestions should be keep in mind
- Native methods will not be in-lined by the JVM. Nor will they be just-in-time compiled for this specific machine – they’re already compiled.
- A Java array may be copied for access in native code, and later copied back. The cost can be linear in the size of the array. I measured JNI copying of a $100,000$ array to average about $75$ microseconds on my Windows desktop, and $82$ microseconds on Mac. Fortunately, direct access may be obtained via
GetPrimitiveArrayCritical
orNewDirectByteBuffer
. - If the method is passed an object, or needs to make a callback, then the native method will likely be making its own calls to the JVM.
- Accessing Java fields, methods and types from the native code requires something similar to reflection. Signatures are specified in strings and queried from the JVM. This is both slow and error-prone.
- Java Strings are objects, have length and are encoded. Accessing or creating a string may require an $O(n)$ copy.
Cited from Stack overflow - What makes JNI calls slow?
COOJA set up
Before running COOJA, we should configure our computer to update and check missing libraries for the COOJA application, because it is registered as a sub-module in default branch, we can configure COOJA by typing these commands:
1 | cd /<contiki-ng_path>/tools/cooja |
If this succeeds, we can run the COOJA application by typing this command
1 | ant run |
Notice that COOJA will consume a large mount of RAM resources, not all computers can do this job, like XJTLU’s uniform computers for PhD candidates. In the Contiki process/Firmware field, select our Contiki program, like the hello-world.c
file in that demo. After compiling has completed, we will be asked to enter a number of WSN motes with their positions. If done, click the Add motes button. Now we can see our motes in the network map. To run the experiment, we can click the Start button on the Simulation Control dialog. After the Start button has been clicked, the Contiki program will run on COOJA.