Interprocess Communication (IPC)

Interprocess Communication(atau biasa disingkat IPC) adalah alat komunikasi antar process yang berbeda. Berbeda dengan multithread dalam 1 process yang bisa berkomunikasi langsung, multithread dalam beda process harus menggunakan IPC karena sebuah process tidak dapat mengakses memory process lainnya.

IPC dapat dilakukan dengan berbagai metode diantaranya:

• Files, adalah sebuah record yang disimpan dalam disk yang dapat diakses oelh setiap proses. Metode ini dapat dijalankan di kebanyakan OS.
• Signal, adalah komunikasi yang menggunakan perintah untuk mengirim dari satu proses ke proses lainnya. Metode ini dapat dijalankan di kebanyakan OS.
• Socket, Sebuah aliran data yang dikirim melalui interface jaringan, baik untuk proses yang berbeda pada komputer yang sama atau komputer lain. Metode ini dapat dijalankan di kebanyakan OS.
• Message Queue, adalah sebuah data stream anonim yang mirip dengan metode Pipe, tetapi Message Queue menyimpan dan mengambil informasi dalam bentuk packets. Metode ini dapat dijalankan di kebanyakan OS.

• Pipe, adalah sebuah aliran data dua arah yang dihubungkan melalui standar input (stdin) dan output (stdout) dan membaca karakter demi karakter. Metode ini dapat dijalankan di semua sistem yang mendukung POSIX (Portable Operating System Interface), Windows.
• Named Pipe, adalah implementasi Pipe melalui sebuah file pada sistem file, bukan melalui standar input dan output. Metode ini dapat dijalankan di semua sistem yang mendukung POSIX (Portable Operating System Interface), Windows.
• Semaphore, adalah sebuah struktur sederhana yang mensinkronisasikan thread atau proses yang bekerja pada sumber daya yang sama. Metode ini dapat dijalankan di semua sistem yang mendukung POSIX (Portable Operating System Interface), Windows.

• Shared Memory, adalah proses yang memiliki akses ke memori yang sama, sehingga memungkinkan semua proses untuk mengubah dan membaca perubahan yang dilakukan oleh suatu proses. Metode ini dapat dijalankan di semua sistem yang mendukung POSIX (Portable Operating System Interface), Windows.

• Message Passing, adalah proses komunikasi antar bagian sistem untuk membagi variabel yang dibutuhkan. Proses ini menyediakan dua operasi yaitu mengirim pesan dan menerima pesan. Bila dua buah sistem ingin berkomunikasi satu sama lain, maka harus dibuat sebuah link komunikasi antara kedua sistem tersebut. Setelah itu, kedua bagian itu dapat saling bertukar pesan melalui link komunikasi tersebut. Metode ini digunakan di paradigma MPI, Java RMI, CORBA, DDS, MSMQ, Mailslots, QNX.
• Memory-mapped File, adalah sebuah file yang dipetakan ke RAM dan dapat dimodifikasi dengan mengubah alamat memori secara langsung. Metode ini dapat dijalankan di semua sistem yang mendukung POSIX (Portable Operating System Interface), Windows.
   

SOCKET
adalah interface pada jaringan yang menjadi titik komunikasi antarmesin pada Internet Protocol, dan tentunya tanpa komunikasi ini, tidak akan ada pertukaran data dan informasi jaringan. Socket terdiri dari elemen-elemen utama sebagai berikut:

(1)    Protokol.

(2)    Local IP.

(3)    Local Port.

(4)    Remote IP.

(5)    Remote Port.

Komunikasi socket jaringan memang tidak mengenal lelah, pertukaran data terjadi terus-menerus dan memegang peranan vital.Bayangkan sebuah server game online yang berkomunikasi tanpa henti, dimainkan oleh entah berapa banyak client yang tersebar. Ini merupakan salah satu contoh aplikasi dari sekian banyak aplikasi yang menggunakan socket jaringan untuk saling berkomunikasi dan bertukar data.

Potongan kode untuk membuat, membaca, menulis dan menghapus pipe:

Untuk membuat pipe, anda bisa menggunakan fungsi mkfifo(<namafifo>,< permission>);
Permission yang saya sarankan adalah 0666, yang berarti semua orang bisa membaca dan menulis didalamnya.

Menulis:
char  phrase[] = “when does the narwhal bacon”;
int main () {
char[]=”/tmp/fifo/”;
int fd1;                       
fd1 = open ( “mypipe”, O_WRONLY );

write (fd1, phrase, strlen ( phrase));  
close (fd1);                                                      
}

Membaca:
int main () {
int fd1;                                            
char buf [100];                  
fd1 = open ( “mypipe”, O_RDONLY );

read ( fd1, buf, 100 );                
printf ( “%s\n”, buf );             
close (fd1);                             
}

Untuk menghapus pipe, anda tinggal menggunakan fungsi unlink(<nama pipe>);

Fuse

Fuse XMP

Source code untuk fuse xmp

#define FUSE_USE_VERSION 30

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#ifdef linux

/* For pread()/pwrite()/utimensat() */

#define _XOPEN_SOURCE 700

#endif

#include <fuse.h>

#include <stdio.h>

#include <string.h>

#include <unistd.h>

#include <fcntl.h>

#include <sys/stat.h>

#include <dirent.h>

#include <errno.h>

#include <sys/time.h>

#ifdef HAVE_SETXATTR

#include <sys/xattr.h>

#endif

static int xmp_getattr(const char *path, struct stat *stbuf)

{

int res;

res = lstat(path, stbuf);

if (res == -1)

return -errno;

return 0;

}

static int xmp_access(const char *path, int mask)

{

int res;

res = access(path, mask);

if (res == -1)

return -errno;

return 0;

}

static int xmp_readlink(const char *path, char *buf, size_t size)

{

int res;

res = readlink(path, buf, size - 1);

if (res == -1)

return -errno;

buf[res] = '\0';

return 0;

}

static int xmp_readdir(const char *path, void *buf, fuse_fill_dir_t filler,

off_t offset, struct fuse_file_info *fi)

{

DIR *dp;

struct dirent *de;

(void) offset;

(void) fi;

dp = opendir(path);

if (dp == NULL)

return -errno;

while ((de = readdir(dp)) != NULL) {

struct stat st;

memset(&st, 0, sizeof(st));

st.st_ino = de->d_ino;

st.st_mode = de->d_type << 12;

if (filler(buf, de->d_name, &st, 0))

break;

}

closedir(dp);

return 0;

}

static int xmp_mknod(const char *path, mode_t mode, dev_t rdev)

{

int res;

/* On Linux this could just be 'mknod(path, mode, rdev)' but this

is more portable */

if (S_ISREG(mode)) {

res = open(path, O_CREAT | O_EXCL | O_WRONLY, mode);

if (res >= 0)

res = close(res);

} else if (S_ISFIFO(mode))

res = mkfifo(path, mode);

else

res = mknod(path, mode, rdev);

if (res == -1)

return -errno;

return 0;

}

static int xmp_mkdir(const char *path, mode_t mode)

{

int res;

res = mkdir(path, mode);

if (res == -1)

return -errno;

return 0;

}

static int xmp_unlink(const char *path)

{

int res;

res = unlink(path);

if (res == -1)

return -errno;

return 0;

}

static int xmp_rmdir(const char *path)

{

int res;

res = rmdir(path);

if (res == -1)

return -errno;

return 0;

}

static int xmp_symlink(const char *from, const char *to)

{

int res;

res = symlink(from, to);

if (res == -1)

return -errno;

return 0;

}

static int xmp_rename(const char *from, const char *to)

{

int res;

res = rename(from, to);

if (res == -1)

return -errno;

return 0;

}

static int xmp_link(const char *from, const char *to)

{

int res;

res = link(from, to);

if (res == -1)

return -errno;

return 0;

}

static int xmp_chmod(const char *path, mode_t mode)

{

int res;

res = chmod(path, mode);

if (res == -1)

return -errno;

return 0;

}

static int xmp_chown(const char *path, uid_t uid, gid_t gid)

{

int res;

res = lchown(path, uid, gid);

if (res == -1)

return -errno;

return 0;

}

static int xmp_truncate(const char *path, off_t size)

{

int res;

res = truncate(path, size);

if (res == -1)

return -errno;

return 0;

}

#ifdef HAVE_UTIMENSAT

static int xmp_utimens(const char *path, const struct timespec ts[2])

{

int res;

/* don't use utime/utimes since they follow symlinks */

res = utimensat(0, path, ts, AT_SYMLINK_NOFOLLOW);

if (res == -1)

return -errno;

return 0;

}

#endif

static int xmp_open(const char *path, struct fuse_file_info *fi)

{

int res;

res = open(path, fi->flags);

if (res == -1)

return -errno;

close(res);

return 0;

}

static int xmp_read(const char *path, char *buf, size_t size, off_t offset,

struct fuse_file_info *fi)

{

int fd;

int res;

(void) fi;

fd = open(path, O_RDONLY);

if (fd == -1)

return -errno;

res = pread(fd, buf, size, offset);

if (res == -1)

res = -errno;

close(fd);

return res;

}

static int xmp_write(const char *path, const char *buf, size_t size,

off_t offset, struct fuse_file_info *fi)

{

int fd;

int res;

(void) fi;

fd = open(path, O_WRONLY);

if (fd == -1)

return -errno;

res = pwrite(fd, buf, size, offset);

if (res == -1)

res = -errno;

close(fd);

return res;

}

static int xmp_statfs(const char *path, struct statvfs *stbuf)

{

int res;

res = statvfs(path, stbuf);

if (res == -1)

return -errno;

return 0;

}

static int xmp_release(const char *path, struct fuse_file_info *fi)

{

/* Just a stub. This method is optional and can safely be left

unimplemented */

(void) path;

(void) fi;

return 0;

}

static int xmp_fsync(const char *path, int isdatasync,

struct fuse_file_info *fi)

{

/* Just a stub. This method is optional and can safely be left

unimplemented */

(void) path;

(void) isdatasync;

(void) fi;

return 0;

}

#ifdef HAVE_POSIX_FALLOCATE

static int xmp_fallocate(const char *path, int mode,

off_t offset, off_t length, struct fuse_file_info *fi)

{

int fd;

int res;

(void) fi;

if (mode)

return -EOPNOTSUPP;

fd = open(path, O_WRONLY);

if (fd == -1)

return -errno;

res = -posix_fallocate(fd, offset, length);

close(fd);

return res;

}

#endif

#ifdef HAVE_SETXATTR

/* xattr operations are optional and can safely be left unimplemented */

static int xmp_setxattr(const char *path, const char *name, const char *value,

size_t size, int flags)

{

int res = lsetxattr(path, name, value, size, flags);

if (res == -1)

return -errno;

return 0;

}

static int xmp_getxattr(const char *path, const char *name, char *value,

size_t size)

{

int res = lgetxattr(path, name, value, size);

if (res == -1)

return -errno;

return res;

}

static int xmp_listxattr(const char *path, char *list, size_t size)

{

int res = llistxattr(path, list, size);

if (res == -1)

return -errno;

return res;

}

static int xmp_removexattr(const char *path, const char *name)

{

int res = lremovexattr(path, name);

if (res == -1)

return -errno;

return 0;

}

#endif /* HAVE_SETXATTR */

static struct fuse_operations xmp_oper = {

.getattr = xmp_getattr,

.access = xmp_access,

.readlink = xmp_readlink,

.readdir = xmp_readdir,

.mknod = xmp_mknod,

.mkdir = xmp_mkdir,

.symlink = xmp_symlink,

.unlink = xmp_unlink,

.rmdir = xmp_rmdir,

.rename = xmp_rename,

.link = xmp_link,

.chmod = xmp_chmod,

.chown = xmp_chown,

.truncate = xmp_truncate,

#ifdef HAVE_UTIMENSAT

.utimens = xmp_utimens,

#endif

.open = xmp_open,

.read = xmp_read,

.write = xmp_write,

.statfs = xmp_statfs,

.release = xmp_release,

.fsync = xmp_fsync,

#ifdef HAVE_POSIX_FALLOCATE

.fallocate = xmp_fallocate,

#endif

#ifdef HAVE_SETXATTR

.setxattr = xmp_setxattr,

.getxattr = xmp_getxattr,

.listxattr = xmp_listxattr,

.removexattr = xmp_removexattr,

#endif

};

int main(int argc, char *argv[])

{

umask(0);

return fuse_main(argc, argv, &xmp_oper, NULL);

}

File System

Pengertian Sistem File (File System)
Sistem file (file system) atau sistem berkas merupakan struktur logika yang digunakan untuk mengendalikan akses terhadap data yang ada pada disk. Dengan kata lain, sistem file merupakan database khusus untuk penyimpanan, pengelolaan, manipulasi dan pengambilan data, agar mudah ditemukan dan diakses.

Sumber: Gufron Rajo Kaciak, S.T., M.Kom: Mengenal Sistem File (File System) Linux: http://dosen.gufron.com/artikel/mengenal-sistem-file-file-system-linux/18/

Hubungan antara sistem operasi dengan sistem file adalah sistem file (file system) merupakan interface yang menghubungkan sistem operasi dengan disk. Ketika program menginginkan pembacaan dari hard disk atau media penyimpanan lainnya, sistem operasi akan meminta sistem file untuk mencari lokasi dari file yang diinginkan. Setelah file ditemukan, sistem file (file system) akan membuka dan membaca file tersebut, kemudian mengirimkan informasinya kepada sistem operasi dan akhirnya bisa dibaca oleh pengguna.

File System pada Linux

1. Ext 2 (2^nd Extended)

Ext 2 merupakan tipe file system yang paling tua yang masih ada. File system ini pertama kali dikenalkan pada tahun 1993. Ext 2 adalah file system yang paling ampuh di linux dan menjadi dasar dari segala distribusi linux. Pada Ext 2 file system, file data disimpan sebagai data blok. Data blok ini mempunyai panjang yang sama dan meskipun panjangnya bervariasi di antara Ext 2 file system, besar blok tersebut ditentukan pada saat file system dibuat dengan mk2fs. Jika besar blok adalah 1024 bytes, maka file dengan besar 1025 bytes akan memakai 2 blok. Ext 2 File System menyimpan data secara hirarki standar yang banyak digunakan oleh sistem operasi. Data tersimpan di dalam file, file tersimpan di dalam direktori. Sebuah direktori bisa mencakup file dan direktori lagi di dalamnya yang disebut sub direktori.

Kehandalan Ext2FS:

• Administrator sistem dapat memilih ukuran blok yang optimal (dari 1024 sampai 4096 bytes), tergantung dari panjang file rata-rata, saat membuat file sistem.
  
• Administrator dapat memilih banyak inode dalam setiap partisi saat membuat file sistem.
  
• Strategi update yang aman dapat meminimalisasi dari system crash.
  
• Mendukung pengecekan kekonsistensian otomatis saat booting.
  
• Mendukung file immutable (file yang tidak dapat dimodifikasi) dan append-only (file yang isinya hanya dapat ditambahkan pada akhir file tersebut).
  

Kelemahan Ext2FS:

• Ketika shut down secara mendadak membutuhkan waktu yang tidak sebentar untuk recover.
  
• Untuk melakukan clean up file system, biasanya Ext 2 secara otomatis akan menjalankan utility
  e2fsck pada saat booting selanjutnya.
  

2. Ext 3 (3^rd Extended)

Ext 3 merupakan peningkatan dari Ext 2 File System. Beberapa peningkatan yang ada antara lain:

1. Journaling
   
   Dengan menggunakan journaling, maka waktu recovery pada shut down yang mendadak tidak akan selama pada Ext 2.
   
2. Integritas Data
   
   Ext 3 menjamin adanya integritas data setelah terjadi kerusakan atau unclean shut down. Ext 3 memungkinkan kita memilih jenis dan tipe proteksi dari data.
   
3. Kecepatan
   
   Daripada menulis data lebih dari sekali, Ext 3 mempunyai throughput yang lebih besar daripada Ext 2 karena Ext 3 memaksimalkan pergerakan head harddisk. Kita bisa memilih tiga jurnal mode untuk memaksimalkan kecepatan, tetapi integritas data tidak terjamin.
   
4. Mudah Dilakukan Migrasi
   
   Kita dapat melakukan migrasi atau konversi dari Ext 2 ke Ext 3 tanpa harus melakukan format ulang pada harddisk.
   

Di samping keunggulan di atas, Ext 3 juga memiliki kekurangan. Dengan adanya fitur journaling, maka membutuhkan memori yang lebih dan memperlambat operasi I/O.

3. Ext 4 (4^th Extended)

Ext 4 dirilis secara komplit dan stabil berawal dari kernel 2.6.28. Jadi, apabila distro yang secara default memiliki kernel tersebut atau di atasnya secara otomatis system sudah support Ext 4. Apabila masih menggunakan Ext 3, dapat dilakukan konversi ke ext 4 dengan beberapa langkah yang tidak terlalu rumit.

Keuntungan menggunakan Ext 4 ini adalah mempunyai pengalamatan 48-bit blok yang artinya dia akan mempunyai 1 EiB = 1.048.576 TB ukuran maksimum file system dengan ukuran 16 TB untuk maksimum file sizenya, fast fsck, journal checksumming, defragmentation support.

Multithreading

Thread: sekumpulan instruksi (proses) yang dieksekusi secara independen.

Multithreading: suatu kemampuan yang memungkinkan beberapa kumpulan instruksi (proses) dijalankan secara bersamaan dalam sebuah program.

Sebuah thread memungkinkan untuk memiliki beberapa state:
1. Running
Sebuah thread yang pada saat ini sedang dieksekusi dan didalam control dari CPU.
2. Ready to run
Thread yang sudah siap untuk dieksekusi, tetapi masih belum ada kesempatan untuk
melakukannya.
3. Resumed
Setelah sebelumnya di block atau diberhentikan sementara, state ini kemudian siap
untuk dijalankan.
4. Suspended
Sebuah thread yang berhenti sementara, dan kemudian memperbolehkan CPU untuk
menjalankan thread lain bekerja.
5. Blocked
Sebuah thread yang di-block merupakan sebuah thread yang tidak mampu berjalan,
karena ia akan menunggu sebuah resource tersedia atau sebuah event terjadi.

Model-Model MultiThreading:
1. Model Many-to-One
Model ini memetakan beberapa thread tingkatan pengguna ke sebuah thread. tingkatan kernel. Pengaturan thread dilakukan dalam ruang pengguna sehingga efisien. Hanya satu thread pengguna yang dapat mengakses thread kernel pada satu saat. Jadi Multiple thread tidak dapat berjalan secara paralel pada multiprosesor. Contoh: Solaris Green Threads dan GNU Portable Threads.

2. Model One-to-One
Model ini memetakan setiap thread tingkatan pengguna ke setiap thread. Ia menyediakan lebih banyak concurrency dibandingkan model Many-to-One. Keuntungannya sama dengan keuntungan thread kernel. Kelemahan model ini ialah setiap pembuatan thread pengguna memerlukan tambahan thread kernel. Karena itu, jika mengimplementasikan sistem ini maka akan menurunkan kinerja dari sebuah aplikasi sehingga biasanya jumlah thread dibatasi dalam sistem. Contoh: Windows NT/XP/2000 , Linux, Solaris 9.

3. Model Many-to-Many
Model ini memultipleks banyak thread tingkatan pengguna ke thread kernel yang jumlahnya sedikit atau sama dengan tingkatan pengguna. Model ini mengizinkan developer membuat thread sebanyak yang ia mau tetapi concurrency tidak dapat diperoleh karena hanya satu thread yang dapat dijadwalkan oleh kernel pada suatu waktu. Keuntungan dari sistem ini ialah kernel thread yang bersangkutan dapat berjalan secara paralel pada multiprosessor.

Keuntungan menggunakan Multithreading:
1. Meningkatkan respon dari pengguna.
2. Pembagian sumber daya.
3. Ekonomis.
4. Mengambil keuntungan dari arsitektur multiprosessor.

Multithreading bermanfaat untuk membuat proses yang interaktif, misalnya pada program permainan (game). Contohnya pada game Counter Strike. Pengguna dapat bergarak sambil melakukan penembakkan. Bayangkan saja apabila game tersebut tidak ada proses multithreading.