Is it possible under java to use Shared Memory like in c? (http://www.cs.cf.ac.uk/Dave/C/node27.html)

 

 

Not in pure Java, but possible using JNI.

 

 

I believe class data sharing (CDS) has been introduced in 1.5.

 

 

Class Data Sharing? (http://java.sun.com/j2se/1.5.0/docs/guide/vm/class-data-sharing.html)
It doesn't seem what I intended ...

 

 

No probably not, but you didn't say what you're trying to do. How about java.nio.MappedByteBuffer?

 

 

Whether nio mapped buffers reflect other processes' changes or not is OS dependent.

Pete

 

 

I was studying alternative solutions to make a C process communicate with a Java process, to "exchange data between them".

Other alternatives i know are:
- JNI
- Named FIFOs
- Sockets

I wondered if using shared memory to do this was a possibility.

 

 

Probably shared memory via JNI would be the best bet, since your C process will be OS specific, and you get code re-use between the two sides of the communication.

Pete

 

 

Currently I've partially implemented an hybrid solution with FIFOs. Because the C program didn't worked as expected if I compiled it as a shared library, so that I could access directly its functions.

So I've made 2 C programs:
- the first (A) is the original program compiled normally, plus a communication module.
- the second (B) is a shared library for JNI calls and is the other peer of the communication.

So Java class make JNI calls to (B), then (B) communicates with (A) trought FIFO's

U suggest a similar solution with shared memory instead of FIFOs can be more efficient?

 

 

This is an article I found about shared memory,

http://www.codeguru.com/Cpp/misc/misc/print.php/c415

 

 

This is about pipes ( I guess they could also be called FIFOs)

http://www.codeproject.com/threads/anonpipe1.asp

 

 

If you can use NIO (i.e., if your JDK version is >= 1.4) you can try using the java.nio.MappedByteBuffer classes.

The idea is that you can define a file on disk that must be mapped in memory and shared between several processes.
So you can open the file, get the FileChannel, call the "map" method using the mode MapMode.READ_WRITE, and obtain a MappedByteBuffer.

 

 

To demonstrate sharing memory using a memory-mapped file, try these programs.

Compile both, start TestShared1 in a window, and TestShared2 in a second window.
TestShared1 creates the shared memory and writes a random integer in the first 4 bytes of the shared memory. TestShared2 reads the memory that TestShared1 wrote. A file named "myshared" will be created in the current directory and backs the shared memory.

import java.io.*;
import java.nio.*;
import java.nio.channels.*;
import java.util.*;
 
class TestShared1 {
    public static void main(String[] args) throws Exception {
        Random r = new Random();
        //-- Opening the file
        RandomAccessFile raf = new RandomAccessFile ("myshared", "rw");
        FileChannel fc = raf.getChannel();
        //-- Getting the memory-mapped byte buffer
        MappedByteBuffer mbb = fc.map (FileChannel.MapMode.READ_WRITE, 0, 1024);
        //-- Writing a random integer in the first 4 positions of the memory
        //-- every second
        for (int i = 0; i < 1000; ++i) {
            try { Thread.sleep(1000); } catch (InterruptedException ex) {}
            int x = r.nextInt();
            mbb.putInt(0, x);
            System.out.println ("Written to the shared memory: " + x);
        }
        fc.close();
        raf.close();
    }
}

and

import java.io.*;
import java.nio.*;
import java.nio.channels.*;
import java.util.*;
 
class TestShared2 {
    public static void main(String[] args) throws Exception {
        Random r = new Random();
        //-- Opening the file
        RandomAccessFile raf = new RandomAccessFile ("myshared", "rw");
        FileChannel fc = raf.getChannel();
        //-- Getting the memory-mapped byte buffer
        MappedByteBuffer mbb = fc.map (FileChannel.MapMode.READ_WRITE, 0, 1024);
        //-- Printing the integer that is in the first 4 positions of the memory
        //-- every second
        for (int i = 0; i < 1000; ++i) {
            try { Thread.sleep(1000); } catch (InterruptedException ex) {}
            int x = mbb.getInt(0);
            System.out.println ("Read from the shared memory: " + x);
        }
        fc.close();
        raf.close();
    }
}

 

 

Thanks to all, I'll read and try all suggestions here. BTW I'm programming under linux (emulating flashcard in RAM) and the final application will go on a handheld device with an ARM processor

 

 

Using JNI in SDK 1.4, you have the functions like GetDirectBufferAddress(env, buf);
This function takes an object created by NewDirectByteBuf() or java.nio.Buffer.ByteBuffer.allocateDirect().
The buffer memory accessed by Java and JNI is supposed to be at the same physical address.