Criar threads e usa-las não é uma tarefa complicada, porém o uso deste recurso introduz algumas dificuldades que não são enfrentadas pelo programador quando o mesmo utiliza a programação seqüencial.

Dizer que um programa é multithread é o mesmo que dizer que este programa possui vários pontos de execução, sendo um ponto para cada thread. Pra facilitar a compreensão é como se existisse um processador para cada thread, assim, ao criar uma thread você pode imaginar-se instanciando um novo processador para fazer o trabalho que você está dando para aquela thread fazer.

Eu acredito muito que o leitor não possui um super computador com dezenas de processadores, sendo assim, melhor manter o exemplo acima apenas para fins de compreensão do que realmente é uma thread ok?(Isso foi apenas um momento auto-ajuda, afinal de contas auto-ajuda vende muito mais que livros de informática. )

Na verdade o Sistema Operacional com seu algoritmo de escalonamento de processos, pede ao processador para fazer uma pequena parte do trabalho de cada vez e trocando de uma thread para outra e de um processo para outro tão rapidamente que temos a impressão de possuir vários processadores. Na verdade todo o processamento é feito em cima das threads, todo processo tem pelo menos uma thread, sendo assim,quando digo que o processador troca de um processo para outro é simplesmente para lembrar-lhe que temos threads de outros processos sendo executados o tempo todo.

Podemos dizer que os processos com suas respectivas threads concorrem ao processador e por essa e por outras o termo concorrência é tão usado ao se falar de threads.

Mas por que usar multithreads? Para que concorrência?

Caso você tenha um micro ou um servidor multiprocessado em mente já deve ter surgido imediatamente em sua cabeça a idéia de usar os recursos dos vários processadores que possui, afinal de contas para que tanto processador se não para aproveitar os mesmos.

Outra coisa seria utilizar as threads para trabalhar com dispositivos lentos (comparados ao nosso nobre processador) como impressoras, rede, discos e outros. Assim nossa thread vai fazer esse serviço de esperar o retorno dos nossos dispositivos “lesmas” enquanto nosso programa principal faz coisas mais importantes.

Agora, uma coisa é certa, a razão é sempre dos usuários. Mediante isso por que não pensar neles? Então por que deixar aquela tela travada para que o coitado fique abrindo o gerenciador de tarefas e matando o malvado processo que teima em travar todas as vezes que ele pede a geração de um determinado relatório ou uma consulta um pouco mais rebuscada, ou coisa do tipo? Neste caso a thread seria uma aliada. Ela iria trabalhar na consulta e a interface gráfica não seria substituída por uma tela branca travada e sem vida.

Um caso um pouco mais raro para a grande maioria dos desenvolvedores seria o uso na construção de uma aplicação distribuída. Imagine-se criando o seu próprio IIS, receber as requisições do usuário e então criar uma thread para cada requisição e deixa-la atende-lo. Obs.: Dei um exemplo extremamente simplista do trabalho do IIS, meramente ilustrativo.

Então é mais ou menos isso, sei que fui simplista, mas… pra que complicar? O objetivo foi entender o conceito. Logo virei com a segunda parte dessa conversa sobre threads. Como cria-las e controla-las.

Comentários e críticas são muito bem vindas.

Abraços!

Multithreading mengacu kepada dua atau lebih task (tugas, thread) yang berjalan (sedang dieksekusi) di dalam satu program. Thread merupakan suatu path eksekusi independen di dalam program. Banyak thread dapat nerjalan secara konkuren (berbarengan) di dalam program. Setiap thread di dalam Java dibuat dan dikendalikan oleh kelas java.lang.Thread. Suatu program Java dapat mempunyai banyak thread, dan thread-thread ini dapat berjalan secara bersamaan, secara asinkron atau sinkron.

Multithreading mempunyai beberapa keuntungan, dibandingkan multiprocessing, di antaranya:

• Thread bersifat lightweight, sedangkan proses lebih berat. Perlu diketahui bahwa proses adalah program yang sedang berada di memory atau processor, sedang dieksekusi. Thread dapat diartikan sebagai anak dari proses.
• Thread-thread berbagi pakai ruang alamat yang sama dan karena itu dapat berbagi pakai data dan kode (instruksi)
• Context switching antar thread biasanya lebih murah daripada antar proses.
• Biaya komunikasi antar thread relatif lebih rendah daripada komunikasi antar proses.
• Thread memungkinkan task-task berbeda dikerjakan secara konkuren.

Note: Penjelasan lebih detail mengenai konsep thread dan proses dapat dibaca pada buku teks mengenai Sistem Operasi, di antaranya karya Stallings dan Tanenbaum yang banyak digunakan di Universitas di Dunia.

Kelas Thread merupakan turunan dari kelas Object. Kelas Object sendiri mempunyai metode notify(), notifyAll() dan wait(), sedangkan kelas Thread menyediakan metode sleep() dan yield(). Metode-metode ini akan sering digunakan dalam pengelolaan aplikasi banyak thread.

Pembuatan Thread

Terdapat 2 (dua) cara membuat thread di dalam Java:

• Mengimplementasikan interface Runnable (java.lang.Runnable)
• Menurunkan (extend) kelas Thread (java.lang.Thread)

Mengimplementasikan Interface Runnable

Bentuk dasar (signature) dari interface Runnable adalah

public interface Runnable {
    void run();
}

Pada pendekatan ini, kita harus membuat sebuah kelas yang implementasi interface Runnable menggunakan kata kunci implements Runnable. Kemudian dibuat instansiasi berupa suatu obyek dari kelas itu. Kita perlu meng-override metode run() di dalam kelas itu, satu-satunya metode yang perlu diimplementasikan. Metode run() mengandung logika dari thread yang dibangun.

Prosedur pembuatan thread berdasarkan pendekatan interface Runnable adalah sebagai berikut:

1. Sebuah kelas meng-implements interface Runnable, menyediakan metode run() di dalamnya yang akan dieksekusi oleh thread nantinya. Obyek dari kelas ini merupakan obyek Runnable.
2. Obyek dari kelas Thread dibuat dengan melewatkan obyek Runnable sebagai argumen ke konstruktur Thread. Obyek Thread sekarang mempunyai suatu obyek Runnable yang mengimplementasikan metode run().
3. Metode start() pada obyek Thread yang dibuat sebelumnya dipanggil. Metode start() tersebut kembali segera setelah suatu thread dilahirkan (berhasil dibuat).
4. Thread berakhir ketika metode run() berakhir, baik dengan penyelesaian normal atau dengan melempar suatu eksepsi tidak tertangkap (uncaught exception).

Di bawah ini adalah sebuah program yang mengilustrasikan pembuatan thread menggunakan interfaca Runnable, bukan meng-extend kelas Thread. Suatu thread dimulai ketika kita memanggil metode start() pada obyek yang dibuat.

class RunnableThread implements Runnable {

	Thread runner;

	public RunnableThread() {	}

	public RunnableThread(String threadName) {
		runner = new Thread(this, threadName); // (1) Buat thread baru.
		System.out.println(runner.getName());
		runner.start(); // (2) Memulai eksekusi thread tersebut.
	}

	public void run() {
		//Tampilkan info tentang thread ini
		System.out.println(Thread.currentThread());
	}
}

public class RunnableExample {

	public static void main(String[] args) {
		Thread thread1 = new Thread(new RunnableThread(), "thread1");
		Thread thread2 = new Thread(new RunnableThread(), "thread2");
		RunnableThread thread3 = new RunnableThread("thread3");

		//Memulai eksekusi thread.
		thread1.start();
		thread2.start();
		try {
			//delay selama satu detik (1000 ms).
			Thread.currentThread().sleep(1000);
		} catch (InterruptedException e) {   }

		//Tampilkan info tentang thread main (utama).
		System.out.println(Thread.currentThread());
	}
}

Keluaran dari Program di atas dapat berupa:

thread3
Thread[thread1,5,main]
Thread[thread2,5,main]
Thread[thread3,5,main]
Thread[main,5,main]private

Pendekatan ini harus digunakan jika kelas yang menginstansiasi obyek thread diperlukan (sebagai parent) untuk membuat kelas-kelas lain yang merupakan keturunannya. Pada kasus demikian, kita tidak boleh menurunkan kelas Thread, harus mengimplementasikan Runnable.

Meng-Extend Kelas Thread

Prosedur pembuatan thread melalui pendekatan penurunan kelas Thread adalah sebagai berikut:

1. Membuat sebuah sub-kelas turunan dari kelas Thread, kemudian meng-override metode run() dari kelas Thread dan di dalamnya didefinisikan beberapa kode yang dieksekusi oleh thread.
2. Sub-kelas ini dapat memanggil suatu konstruktur Thread secara eksplisit untuk menginisialisasi thread, menggunakan metode super().
3. Metode start() yang telah diturunkan (secara otomatis) dari kelas Thread dipanggil agar thread segera berjalan.

Berikut ini adalah sebuah program yang mengilustrasikan pembuatan thread dengan meng-extend kelas Thread sebagai ganti mengimplementasikan interface Runnable. Metode start() digunakanuntuk mengeksekusi obyek thread yang dibuat.

class XThread extends Thread {

	XThread() {  }

	XThread(String threadName) {
		super(threadName); // Memulai thread.
		System.out.println(this);
		start();
	}

	public void run() {
		//Tampilkan info tentang thread ini
		System.out.println(Thread.currentThread().getName());
	}
}

public class ThreadExample {

	public static void main(String[] args) {
		Thread thread1 = new Thread(new XThread(), "thread1");
		Thread thread2 = new Thread(new XThread(), "thread2");

		// 2 thread diberikan nama default
		Thread thread3 = new XThread();
		Thread thread4 = new XThread();
		Thread thread5 = new XThread("thread5");

		//Memulai eksekusi thread
		thread1.start();
		thread2.start();
		thread3.start();
		thread4.start();
		try {
	//Metode sleep() dipanggil pada thred main (utama), delay 1 detik.
			Thread.currentThread().sleep(1000);
		} catch (InterruptedException e) {	}

		//Tampilkan info tentang thread main
		System.out.println(Thread.currentThread());
	}
}

Keluaran yang diperoleh dapat berupa:

Thread[thread5,5,main]
thread1
thread5
thread2
Thread-3
Thread-2
Thread[main,5,main]

Pada saat membuat thread, ada dua alasan mengapa kita mengimplementasikan interface Runnable, bukan meng-extend kelas Thread:

• Menurunkan kelas Thread berarti bahwa subclass tidak dapat diturunkan menjadi kelas lain lagi, sedangkan suatu kelas yang mengimplementasikan interface Runnable mempunyai opsi ini.
• Suatu kelas mungkin hanya diinginkan runnable, karena itu menurunkan Thread secara penuh merupakan pemborosan.

Contoh dari kelas anonim berikut memperlihatkan bagaimana membuat sebuah thread dan langsung menjalankannya:

( new Thread() {
   public void run() {
      for(;;) System.out.println(”Stop the world!”);
   }
}
).start();

Masih banyak fitur lain di Java yang dapat digunakan untuk mengelola thread. Insya Allah coba dibahas pada tulisan berikutnya.

Thats right, current glibc’s implementation of localtime function is not thread-safe, instead we have localtime_r available which offers the same functionality but it is reentrant.
Here is why

struct tm _tmbuf;
/* Return the `struct tm' representation of *T in local time,
   using *TP to store the result.  */
struct tm *
__localtime_r (t, tp)
     const time_t *t;
     struct tm *tp;
{
  return __tz_convert (t, 1, tp);
}
weak_alias (__localtime_r, localtime_r)

/* Return the `struct tm' representation of *T in local time.  */
struct tm *
localtime (t)
     const time_t *t;
{
  return __tz_convert (t, 1, &_tmbuf);
}
libc_hidden_def (localtime)

The localtime representation is returned in a chunk of memory than in the case of localtime_r is given by the user but in the case of the standard localtime every call returns the result in the same memory chunk, currently it uses the file scoped variable _tmbuf in localtime compilation unit.
So simultaneous calls to the localtime will produce non-desired results in every real concurrency scenario.

thank god for DOM…. what a breeze.  you know..

Nice Seo Recipe:

3 Cups of Database

1 Cup of DOM

1 dash of magic

1 heaping bin of skyboard software

but really I just added some nice search engine submission routines (auto web form with database backend to populate fields)….

Also added a nice keyword field to the SB board master table…. also had to add the proper interfaces to the skyboard board cache index…..

Still I need to get some supersampling happening…. if you know you know…

whoo hoo

Lenn Dolling
Skyboard Software

the dining philosophers

road-traffic deadlock

 Di dalam ilmu komputer, apabila dijumpai beberapa proses yang berjalan secara mandiri tetapi menggunakan sumber daya (resources) yang sama, akan terjadi kemungkinan keadaan saling menunggu secara timbal-balik (jika hanya melibatkan 2 pemakai/proses), atau secara “melingkar” (jika melibatkan lebih dari 2 pemakai/proses), yang disebut sebagai kebuntuan (deadlock), misalnya di dalam suatu proses multi-threading.

Contoh lainnya dari keadaan kebuntuan (deadlock) dalam peristiwa sehari-hari: adalah kebuntuan arus lalu-lintas di suatu persimpangan jalan, di mana setiap kendaraan berada dalam posisi saling-menghalangi kendaraan lainnya, dan pada saat yang sama saling menunggu kendaraan lainnya untuk bergerak maju dulu seperti juga ditunjukkan pada gambar di atas. Sebuah Applets kartun sederhana yang memperagakan sebuah deadlock dapat dilihat di sini .

Keadaan ’saling-tunggu-secara melingkar’ di atas digambarkan seperti keadaan di mana 5 orang filsuf duduk melingkar dalam suatu jamuan makan (dinner) di sebuah meja bundar di restoran China. Untuk bisa memakan makanan China, setiap orang memerlukan sepasang (2 buah) supit (chopstick), jadi akan diperlukan 10 batang supit utk. kelima filsuf tersebut.  Masalahnya, saat itu restoran sedang penuh pelanggan hingga persediaan supit yg ada sampai tidak mencukupi.

Maka, sang pelayan restoran punya gagasan: “ah, bukankah para filsuf ini punya kebiasaan makan sambil sesekali berhenti dan melamun (berfikir), jadi toh mereka bisa menggunakan supit secara bergantian.” Maka di meja para filsuf tersebut hanya disediakan 5 batang supit yang ditaruh berselang-seling di antara kelima piring/mangkuk makanan mereka seperti terlihat pada gambar di atas.

Apa yang diharapkan si pelayan memang bisa saja terwujud, kalau saja para filsuf ini bisa “berkoordinasi”, kalau salah seorang sedang makan, filsuf yang duduk persis di sebelahnya harus berhenti makan dan berfikir, dan sebaliknya. Dengan demikian, setiap filsuf yang sedang mendapat “giliran” makan akan bisa menggunakan kedua batang supit yang ditaruh di sebelah kanan dan kirinya. Tetapi karena koordinasi seperti ini tidak ada, ada saat-saat di mana kelima filsuf secara serentak ingin makan, dan masing-masing (maksimum) hanya kebagian 1 supit, misalnya yang di sebelah kanan-nya, maka mereka hanya mengangkat sebatang supit itu dengan tangan kanannya, sambil menunggu supit di sebelah kiri mereka *selesai dipakai* oleh tetangganya, ini akan menyebabkan ke 5 filsuf tersebut saling menunggu selama-lamanya …

the dining psilosophers versi plesetan

Di Tutorial ini saya akan akan mengajak temen-temen untuk berkenalan dengan thread, sebelum memulai pengkodeannya terlebih dahulu kita harus mengetahui sebenarnya apa itu thread, pengertian ini dikutip dari http://wikipedia.org :

Ulir atau thread (singkatan dari “thread of execution“) dalam ilmu komputer, diartikan sebagai sekumpulan perintah (instruksi) yang dapat dilaksanakan (dieksekusi) secara sejajar dengan ulir lainnya, dengan menggunakan cara time slice (ketika satu CPU melakukan perpindahan antara satu ulir ke ulir lainnya) atau multiprocess (ketika ulir-ulir tersebut dilaksanakan oleh CPU yang berbeda dalam satu sistem). Ulir sebenarnya mirip dengan proses, tapi cara berbagi sumber daya antara proses dengan ulir sangat berbeda. Multiplethread dapat dilaksanakan secara sejajar pada sistem komputer. Secara umum multithreading melakukan time-slicing (sama dengan time-division multipleks), di mana sebuah CPU bekerja pada ulir yang berbeda, di mana suatu kasus ditangani tidak sepenuhnya secara serempak, untuk CPU tunggal pada dasarnya benar-benar melakukan sebuah pekerjaan pada satu waktu. Teknik penggantian (switching) ini memungkinkan CPU seolah-olah bekerja secara serempak.

nah, apabila telah paham akan pengertian sebuah thread rasanya tidak komplit apabila saya tidak mencontohkan / mengimplementasikannya. sebelumnya bagi temen-temen yang belum mengerti tentang pembuatan suatu class karena ini akan mengeksploitasi kemampuan pembuatan class silahkan belajar dulu cara membuat class di sini. baik pertama kita buat rancangan form sebagai berikut :

isi dari form tersebut hanya 5 panel,5 button dan 5 progressbar dan khusus untuk button dan progressbar namanya adalah untuk button : btn1,btn2,btn3,dst dan progressbar : pb1,pb2,pb3,dst.

Pertama-tama kita buat terlebih dahulu suatu class TThreadButton yang akan kita gunakan untuk mendefinisikan antara button dengan thread, class TThreadButton merupakan class turunan dari TButton, kita letakkan di atas class TForm itu sendiri, pendeklarasiannya adalah sebagai berikut :

TThreadButton = class(TButton)
aThread: TThread;
end;

kemudian selanjutnya kita buat suatu thread yang kali ini saya beri nama TthCounter yang pendeklarasiannya adalah sebagai berikut :

TthCounter = class(TThread)
 private
  FMax,FCounter: integer;
  FCurr: Extended;
  FOwnerButton: TThreadButton;
  FProgressBar: TProgressBar;
  procedure SetOwnerButton(const aButton: TThreadButton);
  procedure SetProgressBar(const aProgressbar: TProgressBar);
  procedure StepProgress;
  { Private declarations }
 protected
  procedure Execute; override;
 public
  constructor Create(CreateSuspended: boolean);
  property ProgressBar: TProgressBar read FProgressBar write SetProgressBar;
  property OwnerButton: TThreadButton read FOwnerButton write SetOwnerButton;
end;

dan sintak terusan untuk class TthCounter adalah sebagai berikut :

constructor TthCounter.Create(CreateSuspended: boolean);
begin
 inherited;
 FCounter                    := 0; //step awal kita beri nilai 0
 FMax                        := MAXINT; //maksimal step adalah nilai dari maksimal tipe integer
 FreeOnTerminate             := True; //lepaskan thread apabila terdeteksi ada pengakhiran aplikasi
end;

procedure TthCounter.Execute;
begin
 ProgressBar.Position          := 0;
 while ProgressBar.Position < 100 do
  begin
   StepProgress; //gunakan synchronize untuk pemanggilan suatu method
                //yang berhubungan dengan objek

   inc(FCounter,50000); //tambahkan nilai variabel FCounter sebanyak 50000
  end;

 OwnerButton.Caption := '&Start';
 OwnerButton.aThread := nil;
end;

procedure TthCounter.SetOwnerButton(const aButton: TThreadButton);
begin
 FOwnerButton := aButton;
end;

procedure TthCounter.SetProgressBar(const aProgressbar: TProgressBar);
begin
 FProgressBar := aProgressbar;
end;

procedure TthCounter.StepProgress;
begin
 FCurr                 := (FCounter / FMax); //posisi sekarang
 ProgressBar.Position  := Round(FCurr * 100); //masukkan posisi progressbar
end;

Selanjutnya pada Form kita buat prosedur yang nantinya berfungsi untuk memanggil thread tersebut, deklarasinya adalah sebagai berikut :

procedure ClickButton(aProgressBar: TProgressBar ; Sender: TObject);

dan sintak penerusnya adalah

procedure TfrmMain.ClickButton(aProgressBar: TProgressBar ; Sender: TObject);
var
 aButton: TThreadButton;
 aThread: TthCounter;
begin
 aButton := TThreadButton(Sender); //definiskan aButton sesuai dengan pengirim perintah
 if not Assigned(aButton.aThread) then  //jika thread milik aButton belum terisi maka
  begin
   aThread                     := TthCounter.Create(True); //buat thread baru
   aProgressBar.DoubleBuffered := True; //supaya progressbar tidak flicker
   aThread.ProgressBar         := aProgressBar; //definisikan progressbar
   aButton.aThread             := aThread; //beri nilai thread milik aButton dgn thread deklarasi
   aThread.OwnerButton         := aButton; //isi properti thread
   aThread.Resume; //jalankan thread
   aButton.Caption             := '&Pause'; //ubah caption tombol
  end
else  //kondisi bahwa thread milik aButton telah terisi
 begin
  if aButton.aThread.Suspended then //apabila posisi suspend maka
   begin
    aButton.aThread.Resume; //jalankan ulang thread
    aButton.Caption := '&Pause'; //ubah caption
   end
  else  //apabila thread sedang berjalan maka
   begin
    aButton.aThread.Suspend; //suspend thread
    aButton.Caption := '&Resume';//ubah caption
   end;
end;
end;

Nah untuk event tiap-tiap button adalah sebagai berikut :

• OnClick Btn1

ClickButton(pb1,btn1);

• OnClick Btn2

ClickButton(pb2,btn2);

• OnClick Btn3

ClickButton(pb3,btn3);

• OnClick Btn4

ClickButton(pb4,btn4);

• OnClick Btn5
  

ClickButton(pb5,btn5);

Nah apabila telah mengikuti langkah – langkah seperti di atas kita jalankan aplikasi yang telah kita buat dan apabila benar maka hasilnya adalah sebagai berikut :

Bagi temen-temen yang belum jelas atau malah belum jalan, dapat mendownload project lengkapnya disini

Demikian tutorial ini, semoga dapat memberikan wawasan baru bagi temen-temen semua.

Orbit Downloader is the leader of download manager revolution, devoted to new generation web (web2.0) downloading, such as video/music/streaming media from Myspace, YouTube, Imeem, Pandora, Rapidshare, support RTMP. And to make general downloading easier and faster. In general, Orbit Downloader is based on P2P technology. It has a smart download logic accelerator that features intelligent dynamic file segmentation. And Orbit Downloader has advanced robust multithread download algorithm implemented with high quality. It can speed up to 500% faster with great acceleration. Orbit Downloader is written with efficiency in mind, it typically uses less than 3MB of memory and 3% of cpu when downloading. Additionally, the installation package is just about 2MB. Orbit downloader Support HTTPS and HTTP POST method. Orbit downloader can make your downloads from file-sharing service websites including RapidShare much faster, safer and more stable. Orbit Downloader supports IE, FireFox, Maxthon and Opera internet browsers. You can easily download files with a browser click from any remote server via HTTP, HTTPS, FTP, RTSP and MMS. You can set Orbit Downloader to use a proxy server. Orbit Downloader can work well with HTTP, HTTPS and SOCKS5 protocols. Orbit Downloader can resume broken downloads. So you needn’t start the downloading process from the very beginning after casual interruption. You can resume unfinished download from the moment when it was interrupted. The latest Orbit Downloader version 2.8.10 has improved functionality with the new Internet Explorer 8 (IE8) web browser from Microsoft and some resolved problems with the GetIt button.

- Download Orbit Downloader 2.8.10

http://developers.sun.com/solaris/articles/scale_cmt.html?cid=e7978

This is a Beautiful piece of code which helps in moving the Multiple mailboxes in Multithread.

Sourcefilepath contact the text file with the list of alias names or email address of the users to move.
TargetDatabase should have the path of the destination store where mailstore to be moved.
Maxthreads 8 will move 8 users at a time, you can increase this count based on the performace of your machine.
-BadItemsLimit is if mailbox which is moved has some corrupted item then move-mailbox wil skip the corruption upto 30 items. If this corsses then specific mailbox will not be moved, but it will continue to move rest of the mailbox.

$TargetDatabase = “Path to the destination Store”
$k = Get-Content “SourceFilepath”
$k| Get-Mailbox | Move-Mailbox -BadItemLimit ‘30′ -TargetDatabase $TargetDatabase -maxthreads 8 -Confirm: $false

Multi-core programming is the new trend in software programming, the new big thing that will earn the big consulting companies the big bucks.

Don’t get me wrong: I am not saying it’s a fad or something like that, I am just saying that it’s not something new at all, SMP machines exists for many
years now.
I started working with this kind of machine in 1997, a SGI machine with 16 processors. Old stuff that becomes new stuff, again …
Since then, when working for banking or financial companies, this has always been the motto: let’s do it faster. Add more ram, more cpus, more disks.
And, yes please, use them as efficiently as possible: I paid the big bucks for the hardware, the software must use it  (Nowadays the companies willing to spend the most time and money on multi-core programming will probably be the gaming companies).

So … We have more computing power now and we want to use it efficiently, we want to keep these cpus busy.
Of course this is not easy, in order to get a faster program, having more than one cpu does not make automatically any of your applications faster. One must choose the right technology in order to achieve the most efficiency out of these new multi-core cpus.

Multi-threading is the most common chosen technology to try to use the multiple cores available on your $600 desktop or +10,000$ on your brand new server.
But multi-threading is not the only technology that does exist to maximize your computing efficiency nor it is the right technology to solve every problem: multi-processing is also a good choice under certain circumstances.

So you want to optimize or develop a new program that would scale when in presence of multiple cores/cpus, here are the steps I follow when trying it:

First things first: check the operating system the program is supposed to run on.

• why: not all operating systems are created equal when dealing with multiple cpus. Even if your preferred OS claims to support multiple cores it may not be able to use them efficiently i.e. where are the  GL contention point in your OS ?

• example: if your new application is a networking app and you think that multiple cpus will make it faster you should check if your OS implements a BGL around networking APIs.

• conclusion: check your OS internals regarding areas where you expect multiple core to speed-up your application. usually I use SOLARIS and Linux, I tend to avoid MAC OSX and other UNIX like HP-UX and IBM AIX. I do not use windows boxes, hence I cannot make any comment on them.

I will not speak of correct time-sharing and scheduling in presence of multiple cores since all these OS have good support for those.

choose between multi-threading and multi-processing.
As I previously said, multi-threading is not always the right choice for your multi-core applications. This always a shock to people I talk with, since for them multi-threading is the only answer to multi-core programming.
So here are a description of situations where multiple processes may be a better choice than multiple threads in a single process:

• robustness, multiple threads share the same address space, hence if one generates a fault, the whole application may crash. Multi-thread applications do not run in complete isolation, so if certain threads of your program MUST stay alive no matter what can happen to the other threads, multi-threading may be a bad choice. If restarting the program upon failure is not an issue, you can safely ignore the robustness requirement.
• integrity, when designing multiple processes application, each process has its own address space so if one process goes crazy, it cannot corrupt the other processes data, it can only corrupt the shared data between processes. On the other hand, if a thread goes crazy it can corrupt the other threads data since there is no memory protection between threads. This is particularly true when a parent spawns a child process, the child process does whatever computation it needs, and then terminate. If any corruption occurs when doing the computation, it just goes away when the child dies: a new process is spawn to handle a new computation without being affected the previous child fault. There is no such safety net with threads. Corruption made by one thread is program wide, regardless of its lifetime.

Now a description of when a multi-threading application is more desirable than a multi-process one:

• CPU bound applications, video/sound/images processing, numerical simulations (finite elements, molecules interactions)
• high bandwidth message passing, this is when multiple threads exchanges messages for processing at very high rate i.e. the processing done on the various messages is very lightweight.
• cache friendly code, this is related to CPU bound applications
• model driven, multiple threads just make your coding easier: 1 request to be processed by 1 thread, like network connections etc. (yep this is naive e.g. see C10K problem, high performance server design)

Still not decided between multi-threaded and multi-process application ?

Measure the time necessary for the computations, if this amount of time is really small i.e. lightweight computation, compare it to the time taken to increment/decrement a semaphore between 2 processes. If they are in the same order of magnitude, you probably be more satisfied with multi-threading
Otherwise, multi-processing is a very viable choice. Multi-processing is a good choice when the computation takes an order of magnitude more time than the time spent exchanging data.

reduce contention
See ddj article – that’s what will kill your application (regardless of multi-threading or multi-processing).

• reduce code size that is protected by mutexes/semaphores i.e. a whole numerical simulation between two threads is a bad idea

• reduce the necessity for locking, fastest way of sharing data between two threads ? No sharing at all !!! if you are in a master/slave processing model, try to have the master make a copy of the data to be protected by the mutex/semaphore and feed the copy to the various slaves. Copying the shared data can be way much cheaper than competing for a lock (especially when the number of threads increase).

• try to use dirty-reads, do you really need to know the exact value of a shared data i.e. the value of a counter.
  Example: you have to remove items from a cache when the item is expired. The item expires at 11:00, the current timestamp value is protected by a mutex. Locking can be avoided, since reading 11:00 or 11:01 (it has been updated by another thread while reading it) does not really mater: as soon as the timestamp is greater than 11:00 deletion can be performed. Your counter/timestamp is quite big ? See if Lamport concurrent reading and writing of clocks algorithm applies to you (it’s simple and effective).
• do not forget that memory is not cheap to access, check some machine architecture docs to educate yourself on these low levels issues

If dealing with a CPU bound application, beware of trashing: that beast will decrease your performance while maintaining your various cores busy

If dealing with a CPU bound application, maximize the use of your cpu architecture. This is quite a last resort action, but it can be very effective.
For example, I had to a given computation on a powerpc processor. The computation involved multiple floating point operations. The powerpc is a beautiful beast, you have multiple floating point engines when doing the calculations (in my case 4 if I remember correctly).

The trick was to make the compiler produce code that use all of them.

The  following code and discussion are not about loop unrolling (yes it is closely related), here we try to avoid stalling the cpu pipeline by using the multiples floating point units.

original code (and simplified code):

float* a = new float[1000];
float* b = new float[1000];
float* c = new float[1000];
// most cpu time was spent in there...
for ( int i = 0; i < 1000; ++i )
{
    c[i] = 0;
    for ( int j = 0; j < 1000; ++j )
    {
        c[i] += a[j] * b[j];
    }
}

updated loop:

for ( int i = 0; i < 1000; ++i )
{
    float partial_sum = 0;
    for (int j = 0; j < 1000; j += 4)
    {
        // load data into the various processor registers
        float a1 = a[j];
        float a2 = a[j+1];
        float a3 = a[j+2];
        float a4 = a[j+3];
        float b1 = b[j];
        float b2 = b[j+1];
        float b3 = b[j+2];
        float b4 = b[j+3];

        // compute all sums in isolation, so they can be mapped
        // independantly to the various floating point engines
        float s1 = a1 * b1; // FPU engine 1
        float s2 = a2 * b2; // FPU engine 2
        float s3 = a3 * b3; // FPU engine 3
        float s4 = a4 * b4; // FPU engine 4

        s1 += s2; // FPU engine 1
        s3 += s4; // FPU engine 2

        partial_sum += s1 + s3; // FPU engine 1
    }
    c[i] = partial_sum;
}

This is longer but much more efficient and related to multi-threading: you are using the concurrency offered by your processor at the operation level: s1, s2, s3, s4 are computed in parallel, then s1 and s3 are computed in parallel again. This is very good, and most of the time, neglected source of concurrency for your programs.

The previous code, the updated loop, will probably be faster even on classic x86 chips with only 1 FPU, reason being that placing data in registers (explicitly) will be faster than retrieving the data from the cache.

Forget about the fact that this is a powerpc processor and there are multiple FPU engines etc.
What we really did here, was to provide the compiler with lot of context, on how the operation should be done and handled. After that the compiler can work on the optimizations, register allocations etc. Always provide your compiler a maximum of context on the computation to be performed.

You are not alone, seek advices and help
The conclusion to this post is: think twice before writing a multi-core application, check the os, your design and implementation with these previous notes before writing any line of code. Get some help from old schools SMP programmers, get them to review the design and get them to give you some tips. Multi-core programming is hard, really hard.

That’s all folks, for now. I’ll probably make a few other posts about multi-core programming, I have yet to decide the material to write on

Enjoy and share.

Ho fatto una modifica allo script del post precedente facendo in modo che lo script controlli tutte le wireless contemporaneamente.

Ho inoltre aggiunto un paramentro fortuna che in maniera assolutamente empirica calcola quanto sia possibile connettersi a quella wireless.

I valori vanno da 0 a 100, per valori superiori a 50 la connessione dovrebbe essere stabile

#!/usr/bin/ruby
@versione="1.1.1"
@monitors=Hash.new("None")

def spazia(valore,n=20)
    return valore.to_s if n<valore.to_s.size
    return valore.to_s+" "*(n-valore.to_s.size)
end

def tokenize(stream)
	token=Hash.new("None")
	stream.each("Cell"){&#124;cella&#124;
		nome=cella.scan(/ESSID.*/).to_s[7...-1]
		token[nome]=cella
	}
	return token
end

def battery()
	begin
	responso=[]
	`cat /proc/acpi/battery/BAT1/state`.each{&#124;riga&#124; responso<<riga}
	attuale=responso[4].scan(/:.*/).to_s[7..-1].to_f
	massima=responso[3].scan(/:.*/).to_s[7..-1].to_f
	percento=(100*attuale/massima).to_i
	return "Batteria in carica: #{attuale}mAh" if not responso[2].scan("discharging").size>0
	return "Nella batteria rimangono "+responso[4].scan(/:.*/).to_s[7..-1]+" pari al #{percento}%"
	rescue => azz
		return "Informazioni ACPI non disponibili"
	end
end

def fortuna(p,l)
	f= (p+13) / (1.0+(l-50)/6000)
	return 100 if f>100
	return f
end

class Monitor
    def initialize(essid)
        @alpha=1.0/8
        @n=0
        @beacon=0
        @power=0
        @delay=2
        @same=0#Scarto assoluto medio esponenziale
        @oldpower=0
        @essid=essid
    end
    def estrai(celle)
            @cella=celle[@essid]
            beacon=celle[@essid].scan(/beacon.*/).to_s[8..-7].to_i
            power=celle[@essid].scan(/uality.*/).to_s[7..-6].to_i
            enc=(celle[@essid].split("Encryption key")[1])[1..5].tr("\n",' ')
            same=(power-@oldpower).abs
            if(@n==0 &#124;&#124; @power+@beacon==0)
                    @beacon=beacon
                    @power=power
            else
                @beacon=(1-3*@alpha)*@beacon+3*@alpha*beacon if power>0
                @power=(1-@alpha)*@power+@alpha*power
                @power=4*@alpha*@power if power==0
                @beacon=@beacon+ 1000*@delay if (beacon==0 && power==0 && @beacon<10**6 && @beacon>0)
            end
            @oldpower=power
            @fortuna=fortuna(@power,@beacon)
            @n=@n+1
            @map={
                "essid" => @essid ,
                "fortuna" => @fortuna,
                "mpower" => @power,
                "mlatence" => @beacon,
                "beacon"=> beacon,
                "power" => power,
                "same" => same.to_i,
                "enc" => enc
                }
    end

    def compatta()
        puts spazia(@map["essid"])+spazia(@map["fortuna"])+spazia(@map["mpower"])+spazia(@map["mlatence"])+spazia(@map["enc"])
    end

    def estesa()
        ora=Time.now.strftime("%I:%M:%S ")
        puts "\ec \n#{ora} #{battery()}\n"+@cella
	puts "Power    = #{@map["power"]}"
	puts "Latence  = #{@map["beacon"]}\n"
	puts "Scarto   = #{@map["same"]}%\n"
	verso="up";verso="down" if @power>@map["power"]
	puts "MPower   = #{@power} (#{verso})";
	verso="up";verso="down" if @beacon>@map["beacon"]
	puts "MLatence = #{@beacon} (#{verso})"
	puts "Fortuna  = #{@fortuna}"
	puts "Codifica = #{@map["enc"]}"

    end
end

def thread_main()
    #lista solo le celle attualmente visibili.
    #le statistiche delle celle non visibili non vengono aggiornate.
    responso= `iwlist eth1 s`
    celle=tokenize(responso)
    celle.delete(nil)
        ora=Time.now.strftime("%I:%M:%S ")
        puts "\ec#{ora} #{battery()}\n\n"
    puts spazia("ESSID")+spazia("Fortuna")+spazia("MPower")+spazia("MLatence")+spazia("Crittografia")
    celle.each_key{&#124;k&#124;
            @monitors[k]=Monitor.new(k) if @monitors[k]=="None"
            @monitors[k].estrai(celle)
            @monitors[k].compatta()
        }
    puts "\n#{celle.size} celle rilevate"
#    puts @monitors.size
end

thread_main()

esecutore=Thread.new {
    while(true)
#        puts "\ec"
        thread_main()
        sleep 2
    end
}

while(cosa=readline.chomp.upcase)
	if cosa=="Q" then
		Thread.kill(esecutore)
		exit
	end
end

ho aggiunto una pagina dedicata a questo script wscanner ]]> http://parasatria.wordpress.com/2008/10/24/multithreading-in-linux/ Fri, 24 Oct 2008 17:00:19 +0000 m teguh satria http://parasatria.wordpress.com/2008/10/24/multithreading-in-linux/ http://pebbie.wordpress.com/2008/09/23/openmp-a-la-delphi/ Tue, 23 Sep 2008 15:54:21 +0000 pebbie http://pebbie.wordpress.com/2008/09/23/openmp-a-la-delphi/

Setelah beberapa tulisan^[1][2] mengenai OpenMP sebagai bahan kuliah saya jadi penasaran untuk membuat tiruannya dengan Delphi berhubung Delphi (saya pakai versi 7) memiliki kelas wrapper untuk menggunakan fasilitas threading di Win32. Sebetulnya Delphi versi 7 sudah lumayan tertinggal (mengingat sekarang sudah ada Delphi 200X) dalam hal pengembangan (tapi belum tahu juga untuk versi Turbo Delphi) dan untuk varian lainnya adalah FreePascal tetapi alternatif yang diajukan di FreePascal sepertinya tidak kompatibel secara bahasa dengan versi Object Pascal yang digunakan di Delphi 7 jadinya saya masih ragu-ragu. Akhirnya saya teruskan niat untuk mencoba membuat implementasi dari secuil fitur paralelisme OpenMP yaitu parallel for (untuk modifikasi sekumpulan data yang independen).

Pendahuluan

Langkah pertama adalah membuat algoritma sekuensial yang ingin diparalelkan (dibuat menjadi algoritma yang berjalan secara paralel). Algoritma yang saya pilih adalah seperti tulisan ini yaitu operasi terhadap seluruh elemen array 2 dimensi (misalnya citra) yang hanya melibatkan masing-masing elemen tersebut. Kodenya kira-kira seperti ini (yang dicetak miring adalah operasi elementernya)

for j := 0 to high(arr) do
    for i := 0 to high(arr[j]) do begin
      arr[j][i] := arr[j][i] + 10; { operasi elementer }
    end;

Algoritma ini dipilih karena dianggap cukup sederhana karena jika diimplementasi secara paralel menggunakan thread maka antar thread tidak perlu melakukan komunikasi. Algoritma di atas cukup (bahkan mungkin terlalu) sederhana sehingga tidak bisa dibandingkan dengan algoritma paralel karena untuk membuat algoritma versi paralel ada overhead untuk penciptaan thread, penjadwalan, delegasi tugas, dan pembersihan. Oleh sebab itu yang dijadikan acuan untuk melakukan perbandingan performa adalah algoritma versi paralel yang hanya dikerjakan oleh satu buah thread saja. Waktu eksekusi untuk satu thread ini selanjutnya disebut sebagai t₁ sedangkan waktu eksekusi algoritma versi paralel dengan n buah thread akan disebut sebagai t_n sehingga pemercepatan (peningkatan kecepatan) akan dihitung sebagai perbandingan antara t₁ dengan t_n (t₁/t_n).

Pembuatan kelas Worker Thread

Penggunaan fasilitas threading di Delphi ada dua macam cara. Cara pertama adalah memanfaatkan fungsi-fungsi yang berkaitan dengan thread pada Win32 API dan cara kedua adalah membuat kelas turunan dari kelas TThread. Cara kedua dipilih secara subjektif dengan alasan kenyamanan pengelolaan. Pembuatan kelas turunan TThread dapat memanfaatkan wizard dari delphi dengan menggunakan menu File>New>Other>Thread Object. Fungsi yang ingin dijalankan pada thread ditempatkan sebagai fungsi execute yang menutup(override) implementasi dari kelas TThread. Sifat dari penggunaan kelas turunan TThread adalah objek tersebut akan dibebaskan dari memori setelah fungsi execute selesai dijalankan. Penciptaan dan Pembebasan ini tentunya akan menyebabkan redundansi proses yang tidak terlalu relevan dengan tujuan awal (mempercepat eksekusi). Oleh sebab itu perlu dibuat cara lain sedemikian rupa sehingga objek thread hanya perlu diciptakan sekali sebelum proses utama dilakukan dan hanya perlu sekali dibebaskan dari memori setelah seluruh pekerjaan selesai. Caranya adalah dengan membuat atribut status pada kelas thread dan membuat isi fungsi execute ini melakukan perulangan hingga tercapai status akhir (final state). Untuk itu kita perlu tiga buah keadaan yaitu Running, Idle, dan Done. Pada awalnya keadaan akan diinisialisasi sebagai Idle. Keadaan ini adalah keadaan yang menyatakan objek thread tidak sedang sibuk melakukan pekerjaan sehingga dapat didelegasikan. Jika objek thread sedang sibuk maka keadaannya adalah Running. Kode untuk kelas thread ditunjukkan dalam kode berikut :

unit Unit2;

interface

uses
  Classes, Windows, SysUtils;

type
  TThreadState = (tsRunning, tsIdle, tsDone);
  TArrElmtModifier = class(TThread)
  private
    { Private declarations }
    FX, FY, FID: integer;
    FState : TThreadState;
  protected
    procedure Execute; override;

    procedure NotifyStart;
    procedure NotifyDone;
  public
    constructor Create(AID:integer);
    procedure Run;
    procedure Done;
    property X : integer read FX write FX;
    property Y : integer read FY write FY;
    property ID : integer read FID write FID;
    property State : TThreadState read FState write FState;
  end;

implementation

uses Unit1;

{ TArrElmtModifier }

constructor TArrElmtModifier.Create(AID:integer);
begin
  inherited Create(false);
  FID := AID;
  X := 0;
  Y := 0;
  State := tsIdle;
  self.FreeOnTerminate := false;
end;

procedure TArrElmtModifier.Done;
begin
  FState := tsDone;
end;

procedure TArrElmtModifier.Execute;
begin
  { Place thread code here }
  while (FState<>tsDone) do begin
    if (FState=tsRunning) then begin
      { Do Thread Task here }
      Form1.arr[Y][X] := Form1.arr[Y][X] + 10;
      NotifyDone;
      { Notify when task done }
    end;
    sleep(1);
  end;
end;

procedure TArrElmtModifier.NotifyDone;
begin
  Form1.AcceptDone(FID);
  State := tsIdle;
end;

procedure TArrElmtModifier.NotifyStart;
begin
  Form1.Memo1.Lines.Add('Thread #'+inttostr(FID)+' started');
end;

procedure TArrElmtModifier.Run;
begin
  State := tsRunning;
end;

end.

Implementasi Parallel for

Langkah selanjutnya adalah melakukan penjadwalan untuk alokasi pekerjaan dalam iterasi for agar dikerjakan oleh worker thread. Penyederhanaan (tanpa menggunakan antrian pekerjaan) dilakukan dengan penurunan tiap pekerjaan langsung diturunkan dari pola perulangan yang sama seperti pada algoritma sekuensial sehingga urutan pekerjaan menjadi terurut sesuai dengan eksekusi for. Selanjutnya dilakukan penjadwalan delegasi thread agar tiap thread mendapatkan proporsi beban pekerjaan yang cukup seimbang satu sama lain. Hal ini dilakukan dengan menggunakan antrian berbentuk cincin (ring queue) yang secara sederhana diimplementasi dengan memanfaatkan operator modulo pada struktur data kumpulan objek thread yang menggunakan array. Setelah semua pekerjaan didelegasikan perlu dibuat mekanisme barrier yang akan menunggu konfirmasi penyelesaian dari seluruh thread sebelum thread dibebaskan dari memori. Langkah terakhir adalah menampilkan perubahan. Hasil implementasi pada kode utama ditampilkan sebagai berikut :

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, Unit2, StdCtrls, Spin;

type
  TForm1 = class(TForm)
    Memo1: TMemo;
    SpinEdit1: TSpinEdit;
    Button2: TButton;
    Label1: TLabel;
    Label2: TLabel;
    SpinEdit2: TSpinEdit;
    Button1: TButton;
    procedure Button2Click(Sender: TObject);
    procedure Button1Click(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
    nthreads : integer;
    threadflags : array of boolean;
    threads : array of TArrElmtModifier;
    arr : array of array of integer;
    tq : integer;
    procedure Prepare;
    procedure DispatchThreads;
    procedure AcceptDone(idx:integer);
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.AcceptDone(idx: integer);
begin
  threadflags[idx] := false;
  //memo1.lines.Add('done #'+inttostr(idx));
end;

procedure TForm1.DispatchThreads;
var
  i, j, k : integer;
  busy : boolean;
  tmp : tstrings;
  start, finish : longint;
begin
  Memo1.Lines.Clear;
  start := GetTickCount;

  { ordered scheduling }
  for j := 0 to high(arr) do
    for i := 0 to high(arr[j]) do begin
      { schedule iteration(i,j) }
      busy := true;
      repeat
        k := tq; //GetNextAvailableThread
        //if not threadflags[k] then begin
        if threads[k].State = tsIdle then begin
          threadflags[k] := true;
          //memo1.lines.add(format('dispatch (%d,%d) to thread #%d', [i,j,k]));
          threads[k].X := i;
          threads[k].Y := j;
          threads[k].Run;
          busy := false;
          break;
        end;
        tq := (tq + 1) mod length(threads);
        Application.ProcessMessages;
      until not busy;
    end;

  { barrier, wait until all task finished }
  repeat
    busy := false;
    for k := 0 to high(threads) do begin
      if threadflags[k] then begin
        busy := true;
        break;
      end;
    end;
    Application.ProcessMessages;
  until not busy;
  finish := GetTickCount;
  { clean up threads }
  for i := 0 to high(threads) do
    threads[i].State := tsDone;

  { display changes }
  tmp := TStringlist.Create;
  for j := 0 to high(arr) do begin
    tmp.Clear;
    for i := 0 to high(arr[j]) do begin
      tmp.add(inttostr(arr[j][i]));
    end;
    memo1.Lines.add(tmp.CommaText);
  end;
  Memo1.Lines.Add('Done in '+inttostr(finish-start)+' ms');
  tmp.Free;
end;

procedure TForm1.Button2Click(Sender: TObject);
var
  i : integer;
begin
  Prepare;

  nthreads := SpinEdit1.Value;
  setlength(threadflags, nthreads);
  setlength(threads, nthreads);
  for i := 0 to high(threads) do begin
    threadflags[i] := false;
    threads[i] := TArrElmtModifier.Create(i);
  end;

  DispatchThreads;
end;

procedure TForm1.Button1Click(Sender: TObject);
var
  i, j, k : integer;
  start, finish : cardinal;
  tmp : TStrings;
begin
  Prepare;
  Memo1.Lines.Clear;
  start := GetTickCount;

  { ordered scheduling }
  for j := 0 to high(arr) do
    for i := 0 to high(arr[j]) do begin
      arr[j][i] := arr[j][i] + 10;
    end;

  finish := GetTickCount;

  { display changes }
  tmp := TStringlist.Create;
  for j := 0 to high(arr) do begin
    tmp.Clear;
    for i := 0 to high(arr[j]) do begin
      tmp.add(inttostr(arr[j][i]));
    end;
    memo1.Lines.add(tmp.CommaText);
  end;
  Memo1.Lines.Add('Done in '+inttostr(finish-start)+' ms');
  tmp.Free;
end;

procedure TForm1.Prepare;
var
  i,n : integer;
begin
  n := SpinEdit2.Value;

  if length(arr)>0 then
    for i := 0 to high(arr) do
      setlength(arr[i], 0);

  setlength(arr, n);
  for i := 0 to high(arr) do
    setlength(arr[i], n);
  tq := 0;
end;

end.

Tampilan Form (4K PNG)

Pengujian

Untuk menguji perubahan kecepatan pada penggunaan thread digunakan dimensi array 10×10 dan jumlah thread yang diuji antara lain 1 (kontrol), 2, 4, 8, 16 (diabaikan karena asimtotik). Hasil pengukuran ditunjukkan pada gambar berikut.

Grafik Speedup (4K PNG)

Penutup

Sepertinya bisa dinyatakan berhasil, walaupun sebelumnya saya coba justru bisa dibilang gagal karena penggunaan multithread justru memperlambat (mungkin karena saya menjalankan langsung dari IDE). Selanjutnya mungkin saya akan mencoba bagaimana mengimplementasi pola eksekusi berbentuk pohon, analisis statik independensi antar operasi, dan komunikasi (sinkronisasi) antar thread yang pada tujuan akhirnya adalah mewujudkan salah satu mimpi saya terdahulu yaitu membuat bahasa pemrograman (next generation programming language) paralel (akhirnya tujuan perancangannya bisa lebih spesifik) yang memanfaatkan threading secara implisit (tidak perlu menyatakan pembuatan dan pembersihan objek thread secara eksplisit dalam kode program) dan sebisa mungkin makin meng-eksplisitkan independensi antar data/task pada kode program dan penulisan yang bersih dan nyaman untuk dibaca (yang terakhir agak subjektif dan kurang terdefinisi, hehehe). Perwujudan ini (mungkin) dilakukan dalam beberapa tahap yaitu pengembangan abstract machine (sebagai testbed komputer paralel), interpreter, dan pada akhirnya implementasi compiler dan IDE untuk bahasa baru ini yang untuk sementara saya namakan sebagai ‘project pi’ (akhirnya ada juga namanya).

Случай из пратктики.

Проблема: Банк решил закрыть день в многопоточном режиме, был сделан SYSTEM.BACKUP. Закрытие дня прошло без ошибок. Бизнес начал смотреть резлультаты и выявил пару мелочей, для исправления нужно было откатиться на предыдущий день. Восстановились из бэкапа, внесли нужные изменения и начали закрывать день в многопоточном режиме – посыпалась масса ошибок, система не могла прочитать какие-то файлы.

Решение: пока день закрывали в один поток, BATCH.JOB.CONTROL обходился одним файлом F.JOB.LIST.1, когда первый раз закрыли на 7 потоков, он автоматически создал нужное число F.JOB.LIST.2, F.JOB.LIST.3 и т.д. При этом появились соответствующие записи в VOC. Дальше, мы откатились из бэкапа, т.к. это был SYSTEM.BACKUP, то перетерся только каталог bnk.data и все эти файлы (F.JOB.LIST.2, F.JOB.LIST.3, …) удалились, а записи в VOC остались. Когда мы заново начали закрывать день в многопоточном режиме, BATCH.JOB.CONTROL обнаружил в VOC, что файлы которые ему нужны, вроде как уже есть, и попытался читать/писать в/из них, что и привело к ошибкам. В конце концов мы почистили в VOC все F.JOB.LIST.n кроме “1″ и нормально закрыли день.

A peine s’est-on habitués à l’idée d’avoir des processeurs à double coeur dans nos PC que les quadruple coeurs (Intel Core 2 Quad ou  AMD Opteron Quad Core) débarquent dans les PC haut de gamme, et bientôt sur nos bureaux.

Si le double coeur apporte sans conteste un gain de confort (un coeur pour Windows, un autre pour l’application …), il faut reconnaitre que très peu d’applications sont capables de tirer parti du gain de performance qu’apportent théoriquement deux unités de calcul. Que dire pour quatre ?

L’article “Choosing Dual or Quad Core” de Jeff Atwood donne une réponse simple après de nombreux tests : “ça dépend”.

Certaines applications vont presque 2x plus vite avec 4 coeurs qu’avec 2 : elles sont parfaitement parallélisées, avec des processus très indépendants ne nécessitant que très peu de communication entre eux. Pov-Ray, certains benchmarks et des modules de jeux comme le système de particules du moteur Valve Source sont du nombre.

D’autres logiciels sont moins “scalables”, essentiellement parce que les processus doivent s’échanger des données entre eux, et chaque synchronisation bloque l’utilisation simultanée des coeurs. Avec 4 coeurs, l’accélération n’est “que” d’environ 150%. Dans cette catégorie on trouve par exemple  Windows Media Encoder, Cinebench et d’autres programmes de traitement d’images notamment.

Enfin, il y a tous les programmes qui ne sont pas parallélisés, ou qui n’ont été codés que pour 2 coeurs. Et il faut bien le reconnaitre, c’est le cas de la plupart des logiciels actuels.

Reste que la tendance est lancée : les processeurs auront bientôt 4, 8, 16 coeurs (le processeur Cell qui équipe déjà la Playstation III a déjà 1+8 coeurs, on les voit bien sur la photo), et les programmeurs sont en train d’apprendre à en tirer parti.

Pour l’instant, un Quad vous apportera donc peu de gain de performance sur des applications interactives. Mais si vous encodez des videos, faites du rendu réaliste ou autres applications fonctionnant pendant des heures en tâche de fond, les 4 coeurs vous apporteront un gain de vitesse tout en laissant la machine disponible pour du travail interactif, ça peut valoir le coup.

(article publié aussi sur le blog du Microclub)

Chúng ta đã hiểu vấn đề nảy sinh ở chương trình trước. Để giải quyết bài toán xung đột đó chũng ta hãy xem đoạn mã đúng sử dụng mutex:

thread3.c

#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
int myglobal;
pthread_mutex_t mymutex=PTHREAD_MUTEX_INITIALIZER;
void *thread_function(void *arg)
{
    int i,j;
    for ( i=0; i<20; i++ ) {
        pthread_mutex_lock(&mymutex);
        j=myglobal;
        j=j+1;
        printf(".");
        fflush(stdout);
        sleep(1);
        myglobal=j;
        pthread_mutex_unlock(&mymutex);
    }
    return NULL;
}
int main(void)
{
    pthread_t mythread;
    int i;
    if ( pthread_create( &mythread, NULL, thread_function, NULL) ) {
        printf("error creating thread.");
        abort();
    }
    for ( i=0; i<20; i++) {
        pthread_mutex_lock(&mymutex);
        myglobal=myglobal+1;
        pthread_mutex_unlock(&mymutex);
        printf("o");
        fflush(stdout);
        sleep(1);
    }
    if ( pthread_join ( mythread, NULL ) ) {
        printf("error joining thread.");
        abort();
    }
    printf("\nmyglobal equals %d\n",myglobal);
    exit(0);
}

Nếu chúng ta so sánh đoạn mã này với đoạn mã trong chương trình thread2.c, chúng ta sẽ thấy có thêm những lời gọi hàm pthread_mutex_lock() và pthread_mutex_unlock(). Những lời gọi hàm này rất cần thiết trong lập trình với thread. Chúng cung cấp cách thức loại trừ lẫn nhau (mutual exclusion) – có nghĩa là khi một thread sử dụng tài nguyên thì thread khác không được sử dụng và phải chờ cho đến khi thread kia giải phóng tài nguyên. Không có hai thread nào có thể cùng có một mutex bị khóa ở một thời điểm.

Đó chính là cách thức mutex làm việc. Nếu thread “a” cố gắng khóa một mutex trong khi thread “b” đã khóa cùng mutex đó rồi thì thread “a” sẽ rơi vào trạng thái ngủ (sleep). Ngay khi thread “b” giải phóng mutex (thông qua pthread_mutex_unlock()), thread “a” sẽ có thể khóa mutex (nói một cách khác thì khi đó giá trị của hàm pthread_mutex_lock() sẽ được trả về với mutex bị lock). Ngược lại, nếu thread “c” cố gắng khóa mutex trong khi thread “a” đang nắm giữ nó thì thread “c” cũng sẽ bị rơi vào trạng thái ngủ tạm thời. Tất cả thread mà cùng rơi vào trạng thái ngủ từ lệnh gọi pthread_mutex_lock() vì một khóa mutex đã bị lock sẵn rồi sẽ được đưa vào hàng đợi để truy nhập vào mutex.

pthread_mutex_lock() và pthread_mutex_unlock() thường được sử dụng để bảo vệ cấu trúc dữ liệu. Nó đảm bảo rằng chỉ có một thread tại một thời điểm có thể truy nhập vào cấu trúc dữ liệu bằng việc khóa và mở khóa. Bạn cũng có thể đoán ra rằng POSIX threads sẽ cấp một khóa mà không đưa thread đó vào trạng thái ngủ khi nó cố gắng khóa một mutex không bị khóa.

Thế nhưng tại sao chúng ta lại phải đưa các thread vào trạng thái sleep? Rõ ràng nó không phải là ưu điểm chính của thread khi mà ta muốn tận dụng khả năng làm việc độc lập và đồng thời của các thread? Đúng vậy. Tuy nhiên thì các chương trình sử dụng thread vẫn thường cần phải sử dụng mutex.

Nếu bạn nhìn vào hàm thread_function(), bạn sẽ nhận ra rằng mutex bị khóa vào lúc đầu vòng lặp và giải phóng khi kết thúc. Trong ví dụ này thì mymutex được dùng để bảo vệ giá trị của myglobal. Nếu nhìn cẩn thận hơn, sẽ thấy rằng đoạn mã tăng giá trị của myglobal trong thread_function sẽ copy giá trị myglobal và một biến local và ghi trở lại từ local vào myglobal sau khi tăng (đoạn mã sleep một giây có thể bỏ đi. Chẳng có lý do gì để thread_function phải sleep khi đã sử dụng mutex. Nó được thêm vào để có thể nhìn rõ hơn sự khác biệt).

Этой статьёй я планирую завершить тему многопоточности в Perl, ибо она меня уже порядком устала . Кстати, предыдущие статьи ни в коем случае не претендуют на полный и подробный мануал, вовсе нет. Это скорее HOWTO, дающее, однако возможность подумать и понять сущность процесса (как мне кажется).

Итак, на повестке дня —
Частенько смысл множества потоков состоит в работе над одной большой (или необязательно большой) базой. Возникает резонный вопрос: а как обмениваться информацией между нитями?

Оказывается, очень просто. Достаточно всего лишь подключить специальный модуль threads::shared, и для массивов и скалярных переменных, не являющихся ссылками и объектами, можно указывать модификатор shared, показывающи интерпретатору, что переменная доступна всем тредам.

Как всегда пример:

#!/usr/bin/perl -w

use threads;
use threads::shared;

# Объявляем переменную общей для всех нитей с
# помощью модификатора shared
my $i : shared = 1;

# Альтернативный способ - использование функции share
my $j = 0;
share $j;

threads->new(\&my_sub)->join();
threads->new(\&my_sub)->join();
threads->new(\&my_sub)->join();

sub my_sub()
{
    print "Это вызов #$i. Переменная \$j = $j\n";
    $j++;
    $i++;
}

Результат такого скрипта в консоли выглядит примерно так:

% perl threads.pl
Это вызов #1. Переменная $j = 0
Это вызов #2. Переменная $j = 1
Это вызов #3. Переменная $j = 2

Вроде бы всё понятно и просто и пора уже с многопоточностью заканчивать. В качестве прощания мы с вами напишем скрипт, который будет выдирать прокси с первых пяти страниц небезызвестного ресурса MPR Proxylist (разумеется, каждая страница отдельным потоком ). В качестве HTTP-клиента используется библиотека LWP, которая обычно установлена (если не установлена, то пользователи FreeBSD могут устанавливать порт www/p5-libwww, а линуксоидам ничем помочь не могу ):

#!/usr/bin/perl -w

use LWP::UserAgent;
use threads;
use threads::shared;

# В этом массиве будут храниться найденные прокси
my @proxies : shared;

# Массив для хранения ссылок на объекты нитей
my @threads;

# Количество страниц (и, разумеется,  нитей  )
my $threads = 5;

# Создаём $threads нитей, каждая из которых будет
for (my $i = 0; $i < $threads; $i++) {
    threads->new(\&find_proxy, $i);
}

# Скрипт будет жить до завершения работы всех нитей
foreach my $thread (@threads) {
    $thread->join();
}

# Записываем найденные прокси в файл
open PROXIES, '>', 'proxylist.txt';

foreach my $proxy (@proxies) {
    print PROXIES $proxy, "\n";
}

close PROXIES;

# Создание HTTP-клиента на основе LWP (при кажом создании
# у клиента будет разные User-Agent
sub http_factory()
{
    my @agents = ('Mozilla 5.0/Firefox',
                  'Opera 9.02',
                  'Interner Explorer 7',
                  'Safari 3.0/Gecko 31337',
                  'Lynx/FreeBSD 6.0');
    my $client = LWP::UserAgent->new('agent' => $agents[rand($#agents)]);
    return $client;
}

# Процедура соединения с донором и парсинг прокси
sub find_proxy
{
    my $page = shift;
    my $url = sprintf('http://proxylist.sakura.ne.jp/index.htm?pages=%s', $page);
    my $client = &http_factory();
    my $response = $client->get($url) or warn "Can't connect $url: $@\n";

    if ($response->is_success() && $response->content_type() eq 'text/html') {
        my $content = $response->content();

        while ($content =~ m!
(.*?)

\s*?
([a-z]{2})

!sgi) {
            my $proxy = $1;
            my $country = $2;
            push @proxies, $proxy;
            print "Found $proxy [$country], saving it\n";
        }
    }

    else {
        print "fuck! $@\n";
    }
}

В общем, вроде всё, балуйтесь, детишки. И не забывайте, что это только пример, демонстрирующий мощность многопоточных приложений на Perl

Удачного дня