PEMROGRAMAN POSIX

THREAD (PTHREAD)
 

1. 1611512005 ALDI SYAHPUTRA

2. 1711511010 HILDA LIARY NIRWANI
3. 1811512002 MAHMUDA AREHA
4. 1811512018 FAISAL KAMZA
5. 1811513008 ARIF ALDIKA PUTRA
 THREAD

• Secara teknis, thread didefinisikan sebagai aliran instruksi

independen yang dapat dijadwalkan untuk dijalankan oleh
sistem operasi. Bagi pengembang perangkat lunak, konsep
"prosedur" yang berjalan secara independen dari program
utamanya mungkin paling tepat menggambarkan sebuah
thread.
• Untuk melangkah lebih jauh, bayangkan program utama
(a.out) yang berisi sejumlah prosedur. Kemudian bayangkan
semua prosedur ini dapat dijadwalkan untuk berjalan secara
bersamaan dan / atau secara independen oleh sistem operasi.
Itu akan menggambarkan program "multi-threaded".
 POSIX
• POSIX (Portable Operating System Interface UNIX)  adalah kumpulan standar yang diatur
oleh IEEE untuk menyeragamkan API dan antarmuka yang dipakai oleh sistem-sistem
operasi mirip Unix. Tujuannya untuk menangani kompatibilitas dan portabilitas
variasi Unix  dan sistem operasi lain

• Standar POSIX didukung oleh kebanyakan sistem operasi modern (utamanya

keluarga sistem operasi UNIX), meski tidak semuanya diimplementasikan.
Keluarga Windows NT juga mendukung standar POSIX, meski hanya beberapa standar,
yakni POSIX.1 dan POSIX.4. Dukungan POSIX dalam sistem operasi itu juga dapat
diperluas dengan menambahkan komponen tambahan, yang disebut dengan Windows
Services for UNIX dari Microsoft atau MKS Toolkit.

• Unix atau UNIX adalah sebuah sistem operasi komputer yang diawali dari project Multics

 (Multiplexed Information and Computing Service) pada tahun 1965 yang dilakukan
American Telephone and Telegraph (AT&T), General Electric (GE), dan Institut Teknologi
Massachusetts (MIT), dengan biaya dari Departemen Pertahanan Amerika (Departement of
Defence Advenced Research Project, DARPA atau ARPA). UNIX didesain sebagai Sistem
operasi yang portabel, multi-tasking dan multi-user. Pengembangannya dimulai dari tahun
1970-an di Bell Labs oleh Ken Thompson, Dennis Ritchien dan lain-lain
 PROSES UNIX

Sebuah proses dibuat oleh sistem operasi, dan membutuhkan "overhead" yang cukup. Proses
berisi informasi tentang sumber daya program dan status pelaksanaan program, termasuk:
• ID proses, ID grup proses, ID pengguna, dan ID grup
• Lingkungan Hidup
• Direktori kerja.
• Instruksi program
• Mendaftar
• Stack
• Heap
• Deskriptor file
• Tindakan sinyal
• Perpustakaan bersama
• Alat komunikasi antar proses (seperti antrian pesan, pipa, semaphore, atau memori
bersama).
• More about this source textSource text required for additional translation information
PROSES UNIX
 PTHREAD
• Secara historis, vendor perangkat keras telah mengimplementasikan versi utas
mereka sendiri. Implementasi ini sangat berbeda satu sama lain sehingga
menyulitkan programmer untuk mengembangkan aplikasi thread portabel. Untuk
memanfaatkan sepenuhnya kemampuan yang disediakan oleh thread, diperlukan
antarmuka pemrograman standar. Untuk sistem UNIX, antarmuka ini telah
ditentukan oleh standar IEEE POSIX 1003.1c (1995). Implementasi yang
mengikuti standar ini disebut sebagai utas POSIX, atau Pthreads.
• Sebagian besar vendor perangkat keras sekarang menawarkan Pthreads selain API
milik mereka. Standar POSIX terus berkembang dan mengalami revisi, termasuk
spesifikasi Pthreads.
• Pthreads didefinisikan sebagai sekumpulan jenis pemograman bahasa C dan
panggilan prosedur, diimplementasikan dengan file header / include pthread.h dan
pustaka utas - meskipun pustaka ini mungkin menjadi bagian dari pustaka lain,
seperti libc, dalam beberapa implementasi.
ALASAN MENGGUNAKAN PTHREAD

1) Ringan
• Jika dibandingkan dengan biaya pembuatan dan pengelolaan
proses, utas dapat dibuat dengan overhead sistem operasi yang
jauh lebih sedikit. Mengelola utas membutuhkan lebih sedikit
sumber daya sistem daripada mengelola proses.
• Misalnya, tabel berikut membandingkan hasil pengaturan
waktu untuk subrutin fork () dan subrutin pthread_create ().
Pengaturan waktu mencerminkan 50.000 proses / pembuatan
utas, dilakukan dengan utilitas waktu, dan unit dalam hitungan
detik, tidak ada tanda pengoptimalan.
 2) Komunikasi / Pertukaran Data yang Efisien:
• Motivasi utama untuk mempertimbangkan penggunaan Pthreads dalam
lingkungan komputasi berkinerja tinggi adalah untuk mencapai kinerja
optimal. Secara khusus, jika aplikasi menggunakan MPI untuk komunikasi
on-node, ada potensi kinerja dapat ditingkatkan dengan menggunakan
Pthreads. Perpustakaan MPI biasanya mengimplementasikan komunikasi
tugas pada node melalui memori bersama, yang melibatkan setidaknya satu
operasi penyalinan memori (proses ke proses). Untuk Pthreads tidak
diperlukan salinan memori perantara karena utas berbagi ruang alamat yang
sama dalam satu proses. Tidak ada transfer data. Ini bisa seefisien hanya
meneruskan pointer. Dalam skenario kasus terburuk, komunikasi Pthread
menjadi lebih dari masalah bandwidth cache-to-CPU atau memori-ke-CPU.
Kecepatan ini jauh lebih tinggi daripada komunikasi memori bersama MPI.
Misalnya: beberapa perbandingan lokal, dulu dan sekarang,
 PEMROGRAMAN PARALEL

• Pada mesin modern multi-core, pthread sangat cocok untuk pemrograman paralel, dan
apa pun yang berlaku untuk pemrograman paralel secara umum, berlaku untuk program
pthreads paralel.
• Ada banyak pertimbangan untuk mendesain program paralel, seperti:
• Jenis model pemrograman paralel apa yang digunakan?
• Masalah partisi
• Penyeimbang beban
• Komunikasi
• Dependensi data
• Sinkronisasi dan kondisi balapan
• Masalah memori
• Masalah I / O
• Kompleksitas program
• Upaya / biaya / waktu programmer
• Secara umum, agar program dapat memanfaatkan Pthreads, program harus dapat
diatur menjadi tugas-tugas terpisah dan independen yang dapat dijalankan secara
bersamaan. Misalnya, jika routine1 dan routine2 dapat dipertukarkan, disisipkan,
dan / atau tumpang tindih secara real time, mereka adalah kandidat untuk threading.
Program yang memiliki karakteristik berikut mungkin cocok untuk
pthreads:
• Pekerjaan yang dapat dijalankan, atau data yang dapat dioperasikan, dengan
banyak tugas secara bersamaan:
• Blokir untuk kemungkinan I / O menunggu lama
• Gunakan banyak siklus CPU di beberapa tempat tetapi tidak di tempat lain
• Harus menanggapi peristiwa asynchronous
• Beberapa pekerjaan lebih penting daripada pekerjaan lain (interupsi prioritas)
Ada beberapa model umum untuk program berulir:
• Manager / worker: satu thread, manajer menugaskan pekerjaan ke thread lain,
pekerja. Biasanya, manajer menangani semua input dan membagi pekerjaan ke
tugas-tugas lain. Setidaknya ada dua bentuk model manajer / pekerja yang
umum: kumpulan pekerja statis dan kumpulan pekerja dinamis.
• Pipeline: tugas dipecah menjadi serangkaian suboperations, yang masing-
masing ditangani secara seri, tetapi secara bersamaan, oleh thread yang
berbeda. Jalur perakitan mobil paling tepat menggambarkan model ini.
• Peer: mirip dengan model manajer / pekerja, tetapi setelah utas utama
membuat utas lain, utas ini berpartisipasi dalam pekerjaan.
 MODEL SHARED MEMORI

• Semua thread memiliki akses ke memori bersama global yang sama. Thread juga
memiliki data pribadinya sendiri. Pemrogram bertanggung jawab untuk
menyinkronkan akses (melindungi) data yang dibagikan secara global.
 PTHREAD API
API Pthreads asli didefinisikan dalam standar ANSI / IEEE POSIX 1003.1 - 1995. Standar
POSIX terus berkembang dan mengalami revisi, termasuk spesifikasi Pthreads. Subrutin
yang terdiri dari Pthreads API dapat dikelompokkan secara informal menjadi empat
kelompok utama:
• Manajemen thread: Rutinitas yang bekerja langsung pada utas - membuat, melepaskan,
menggabungkan, dll. Mereka juga menyertakan fungsi untuk mengatur / menanyakan
atribut utas (dapat digabungkan, penjadwalan, dll.)
• Mutexes: Rutinitas yang berhubungan dengan sinkronisasi, disebut "mutex", yang
merupakan singkatan dari "mutual exclusion". Fungsi Mutex menyediakan untuk
membuat, menghancurkan, mengunci, dan membuka kunci mutex. Ini dilengkapi
dengan fungsi atribut mutex yang mengatur atau memodifikasi atribut yang terkait
dengan mutex.
• Variabel kondisi: Rutinitas yang menangani komunikasi antar utas yang berbagi mutex.
Berdasarkan kondisi yang ditentukan programmer. Grup ini mencakup fungsi untuk
membuat, menghancurkan, menunggu dan memberi sinyal berdasarkan nilai variabel
yang ditentukan. Fungsi untuk menyetel / atribut variabel kondisi kueri juga disertakan.
• Sinkronisasi: Rutinitas yang mengelola kunci dan pembatas baca / tulis.
 API PTHREAD

• API Pthreads berisi sekitar 100 subrutin. Tutorial ini akan

berfokus pada subset dari ini - khususnya, yang kemungkinan
besar akan segera berguna bagi programmer Pthreads pemula.
• Untuk portabilitas, file header pthread.h harus disertakan di
setiap file sumber menggunakan pustaka Pthreads.
• Standar POSIX saat ini hanya ditentukan untuk bahasa C.
Pemrogram Fortran dapat menggunakan pembungkus di
sekitar pemanggilan fungsi C. Beberapa kompiler Fortran
mungkin menyediakan API pthreads Fortran.
TABEL COMPILE PEMROGRAMAN
PTHREAD
 CONTOH PROGRAM
#include <pthread.h>
#include <stdio.h>
#define NUM_THREADS 5
 
void *PrintHello(void *threadid)
{
long tid;
tid = (long)threadid;
printf("Hello World! It's me, thread #%ld!\n", tid);
pthread_exit(NULL);
}
 
int main (int argc, char *argv[])
{
pthread_t threads[NUM_THREADS];
int rc;
long t;
for(t=0; t<NUM_THREADS; t++){
printf("In main: creating thread %ld\n", t);
rc = pthread_create(&threads[t], NULL, PrintHello, (void *)t);
if (rc){
printf("ERROR; return code from pthread_create() is %d\n", rc);
exit(-1);
}
}
 
pthread_exit(NULL);
}
 MULTITHREADING
• Memakai library pthread (POSIX threading interface) untuk membuat dan sinkronisasi
beberapa thread dalam satu proses. POSIX adalah antarmuka standar untuk sistem operasi UNIX.
Tidak ada dukungan komunikasi secara eksplisit karena data di-share antar thread, yaitu variabel
global dan alokasi memori pada heap. Kompilasi program dengan gcc -lpthread.

#include <pthread.h>
#include <stdio.h>
void *say_hello(void *arg) { printf("Hello!\n");
pthread_exit(NULL);
}
int main()
{
pthread_t T[4];
int i;
// membuat 4 thread yg menjalankan fungsi say_hello
for (i = 0; i < 4; i++)
pthread_create(&T[i], NULL, say_hello, NULL);
for (i = 0; i < 4; i++)
pthread_join(T[i], NULL);
return 0;
}