Shared memory adalah merupakan komunikasi antar proses tercepat karena semua proses menggunakan blok memori yang sama. Shared memory memungkinkan dua atau lebih proses mengakses memory yang sama disebut malloc dan mengembalikan pointer ke memori aktual yang sama. Ketika sebuah proses berganti memori maka proses-proses yang lain pun akan memperhatikan perubahan tersebut.

Akses ke shared memory adalah secepat seperti mengakses sebuah proses tanpa shared memory, akses tersebut tidak memerlukan system call atau harus melalui kernel , shared memory juga menghindari pengkopian data yang tidak penting.

Karena kernel tidak melakukan sinkronisasi akses ke shared memory maka kita harus membuat sinkronisasi tersebut sendiri. Sebagai contoh sebuah proses tidak akan membaca dari memori sebelum memori tersebut ditulisi, dan dua proses tidak boleh secara bersamaan menulis ke lokasi memori yang sama.

Untuk menggunakan segmen shared memory, sebuah proses harus mengalokasi segmen dan proses lain yang ingin mengakses segmen harus melampirkan segmen tersebut, setelah selesai menggunakan segmen setiap proses melepaskan segmen tersebut, pada satu titik sebuah proses mengalokasikan ulang segmen.

Parameter shared memory

Sebuah proses mengalokasi segmen shared memory menggunakan shmget(Shared Memory GET) ada tiga parameter untuk mengalokasi segmen:

    1. Key integer, sebuah key integer menspesifikasikan segmen mana yang akan dibuat. Proses lain yang tidak berhubungan bisa mengakses segmen secara bersamaan dengan menggunakan nilai key yang sama.

   2. Size(byte) dari segmen, karena segmen dialokasi menggunakan halaman-halaman, jumlah byte yang dialokasikan adalah dibulatkan ke kelipatan integral dari ukuran halaman.

    3. Flag, flag terdiri dari:

      · IPC_CREAT, flag ini mengindikasi bahwa segmen baru akan dibuat.

      · IPC_EXCL, flag ini selalu digunakan dengan IPC_CREAT karena shmget gagal. Jika sebuah key segmen yang ditetapkan sudah ada. Maka flag ini mengatur untuk memanggil proses untuk memiliki “exclusive” segmen. Jika flag ini tidak diberikan dan key dari segmen yang sudah ada digunakan, shmget mengembalikan segmen yang ada sebagai gantinya membuat segmen baru.

    · Mode Flags, nilai ini dibuat dari 9 bit yang mengindikasikan ijin yang diberikan kepada owner, group dan others untuk mengontrol akses ke segmen. Bit eksekusi diabaikan. Sebagai contoh S_IRUSR dan S_IWUSRN untuk spesifikasi baca dan tulis untuk owner pada segmen shared memory, dan S_IROTH dan S_IWOTH untuk spesifikasi baca dan tulis untuk others.

Sebagai contoh pemanggilan shmget membuat segmen shared memory yang baru, jika shm_key sudah digunakan maka pembacaan dan penulisan hanya diberikan untuk owner bukan untuk user lainnya.

Int segment_id = shmget (shm_key, getpagesize(), IPC_CREAT| S_IRUSR|S_IWUSER);

Jika pemanggilan berhasil, shmget mengembalikan sebuah segmen identifier. Jika segmen shared memory sudah ada ijin, akses diverifikasi dan sebuah pengecekan dibuat untuk memastikan bahwa segmen tidak ditandai untuk dihancurkan.

Untuk membuat segmen shared memory tersedia sebuah proses harus menggunakan shmat (Shared Memory ATtach) dengan mengirim identifier segmen shared memory SHMID yang nilai baliknya berupa shmget. Shmat tersebut berupa pointer yang menunjukan dimana tempat alamat proses yang ingin dipetakan shared memory. Jika kita menunjukan NULL, LINUX akan memilih alamat yang tersedia.

Ketika kita sudah selesai menggunakan segment shared memory, segmen harus dilepas menggunakan Shmdt (Shared Memory DeTach) dengan mengirim alamat yang nilai baliknya adalah shmat.

Shmctl (Shared Memory ConTroL) memanggil kembali informasi tentang segmen shared memory dan dapat memodifikasinya. Parameter pertama dari shmctl adalah identifier segmen shared memory. Cara untuk memperoleh informasi mengenai segmen shared memory yaitu mengirim IPC_STAT sebagai indentifier dari segmen dan sebuah pointer untuk menyusun shmid_ds. Untuk menghapus segmen, yaitu mengirim IPC_RMID dan NULL. Segmen akan dihapus ketika proses terakhir sudah dilepaskan.

Contoh shared memory:

#include <stdio.h>
#include <sys/shm.h>
#include <sys/stat.h>
int main ()
{
    int segment_id;
    char* shared_memory;
    struct shmid_ds shmbuffer;
    int segment_size;
    const int shared_segment_size = 0x6400;
    /* Allocate a shared memory segment. */
    segment_id = shmget (IPC_PRIVATE, shared_segment_size,
    IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR);
    /* Attach the shared memory segment. */
    shared_memory = (char*) shmat (segment_id, 0, 0);
    printf (“shared memory attached at address %p\n”, shared_memory);
    /* Determine the segment’s size. */
    shmctl (segment_id, IPC_STAT, &shmbuffer);
    segment_size = shmbuffer.shm_segsz;
    printf (“segment size: %d\n”, segment_size);
    /* Write a string to the shared memory segment. */
    sprintf (shared_memory, “Hello, world.”);
    /* Detach the shared memory segment. */
    shmdt (shared_memory);
  /*Reattach the shared memory segment, at a different address.*/
   shared_memory = (char*) shmat (segment_id, (void*) 0x5000000, 0);
  printf (“shared memory reattached at address %p\n”, shared_memory);
    /* Print out the string from shared memory. */
    printf (“%s\n”, shared_memory);
    /* Detach the shared memory segment. */
    shmdt (shared_memory);
    /* Deallocate the shared memory segment. */
    shmctl (segment_id, IPC_RMID, 0);
    return 0;
}