Cuman numpang posting source code. Know what, mata kuliah High Performance System menurut saya adalah salah satu mata kuliah yang unik. Tugasnya dari awal sampai akhir hanya melakukan perkalian matriks. Tapi yang menarik perkalian matriks ini dilakukan dalam berbagai cara dengan menggunakan fitur, pustaka, ataupun mesin berkinerja tinggi. Semua cara ini nantinya akan dibandingkan dengan cara perkalian matriks yang naif dan serial.
Berikut adalah kodenya

void sgemm(int n, float alpha, const float *A, const float *B, float beta, float *C){
    int i, j, k;
    for (i = 0; i < n; ++i) {
        for (j = 0; j < n; ++j) {
            float prod = 0;
            for (k = 0; k < n; ++k) {
                prod += A[k * n + i] * B[j * n + k];
            }
            C[j * n + i] = alpha * prod + beta * C[j * n + i];
        }
    }
}

Di salah satu kuliah yakni High Performance System sering dibutuhkan fungsi untuk menghitung durasi waktu. Salah satu fungsi yang dapat dipakai adalah clock_gettime yang menyediakan ketelitian hingga nanosecond. Fungsi ini menggunakan struktur data yakni timespec yang juga didefinisikan di header time.h.

Cara untuk menghitung durasinya adalah sebagai berikut

#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#include <unistd.h>

timespec diff(timespec start, timespec end)
{
    timespec temp;
    if ((end.tv_nsec - start.tv_nsec) < 0) {
        temp.tv_sec = end.tv_sec - start.tv_sec - 1;
        temp.tv_nsec = 1000000000 + end.tv_nsec - start.tv_nsec;
    } else {
        temp.tv_sec = end.tv_sec - start.tv_sec;
        temp.tv_nsec = end.tv_nsec - start.tv_nsec;
    }
    return temp;
}

int main(){

    timespec start, stop;
    clock_gettime(CLOCK_REALTIME, &start);
    sleep(1);
    clock_gettime(CLOCK_REALTIME, &stop);

    timespec duration = diff(start, stop);
    printf("%d.%09d s\n", duration.tv_sec, duration.tv_nsec);
    return 0;
}

• Moore’s Law
  Number of transistors on a single piece of silicon doubles every 19-24 months
• Gilder’s Law
  Network bandwith capacity triples every 12 months
• Meltcalfe’s Law
  Value of network increases exponentially as number of participants increases
• Fitt’s Law
  The time required to rapidly move to a target area is a function of the distance and the size of the target

Got from here.

(update: Fitt’s Law thanks to Peb)

I am a big fan of Plurk (literally). And since they officially open up their API last Saturday, I’ve been working to build a Java ME version of the client these 3 days.

Here’s the screenshot. It’s not quite ready yet. But it’s nice to know that the app is getting its form.

(click to enlarge)

Masih melanjutkan tentang The Readers and Writers Problem. Java sudah menyediakan fitur Lock khusus untuk model permasalahan ini yakni ReadWriteLock yang disediakan oleh Concurrent APInya Java. Locking ini mempunyai 2 buah Lock yakni ReadLock yang dapat dimiliki beberapa Reader selama tidak ada Writer yang berjalan dan WriteLock yang ekslusif untuk sebuah Writer. Penggunaannya sangat mirip pada postingan sebelumnya. Kita perlu membuat sebuah instance dari ReadWriteLock tersebut. Karena ReadWriteLock hanya berupa Interface maka kita pakai Class yang sudah ada yakni ReentrantReadWriteLock (meski dengan mudahnya kita dapat membuat sebuah Class ReadWriteLock baru dengan menggunakan kode pada postingan sebelum ini)

    private static ReentrantReadWriteLock rwlock = new ReentrantReadWriteLock();
    private static Lock rlock = rwlock.readLock();
    private static Lock wlock = rwlock.writeLock();

public void read() {
        System.out.println(strid + ": start!");
        while (true) {
            try {
                rlock.lock();
                System.out.println(strid + ": start reading!");
                FileInputStream fis = new FileInputStream(fileName);
                byte[] b = new byte[4];
                fis.read(b);
                System.out.println(strid + ": read \"" + new String(b) + "\"");
                fis.close();
                System.out.println(strid + ": done reading!");
                rlock.unlock();
            } catch (Exception ex) {
                synchronized (System.out) {
                    ex.printStackTrace(System.out);
                }
            }
        }
    }

public void write() {
        System.out.println(strid + ": start!");
        while (true) {
            try {
                wlock.lock();
                System.out.println(strid + ": start writing!");
                FileOutputStream fos = new FileOutputStream(fileName);
                String srandom = Long.toString((long) ((new Random()).nextDouble() * 9000) + 1000);
                //Writing random
                System.out.println(strid + ": write \"" + srandom + "\"");
                fos.write(srandom.getBytes());
                fos.close();
                System.out.println(strid + ": done writing!");
                wlock.unlock();
            } catch (Exception ex) {
                synchronized (System.out) {
                    ex.printStackTrace(System.out);
                }
            }
        }
    }

Kodenya dapat dilihat di sini. (Caranya sama seperti sebelumnya)

Cuman mau ngetes fitur wordpress yang bisa publikasi langsung di twitter. Follow twitter.com/maleskoding untuk postingan blog ini atau twitter.com/petrabarus untuk mengenal saya lebih jauh

Untuk lebih jelasnya dapat dicoba di berita resminya.

Melanjutkan postingan sebelumnya tentang masalah The Readers and Writers Problem. Untuk memberikan hak ekslusif bagi Writers untuk menulis file maka diperlukan sebuah mekanisme locking. Mekanisme ini akan coba diimplementasikan pada sebuah class bernama Lock.

class Lock {

        public static int countRequestingWriter = 0;
        public static int countRunningWriter = 0;
        public static int countRunningReader = 0;

        public synchronized void lockRead() throws InterruptedException {
            while (countRunningWriter > 0 || countRequestingWriter > 0) {
                wait();
            }
            countRunningReader++;
        }

        public synchronized void unlockRead() {
            countRunningReader--;
            notifyAll();
        }

        public synchronized void lockWrite() throws InterruptedException {
            countRequestingWriter++;
            while (countRunningReader > 0 || countRunningWriter > 0) {
                wait();
            }
            countRequestingWriter--;
            countRunningWriter++;
        }

        public synchronized void unlockWrite() {
            countRunningWriter--;
            notifyAll();
        }
    }

Ketika lock akan dipakai oleh sebuah thread untuk melakukan write locking, maka lock akan memeriksa apakah sedang dilakukan reading atau writing. Jika ada maka lock akan menunggu. Ketika thread lain selesai melakukan tugasnya maka lock akan memberitahu thread yang menungu itu untuk memeriksa lagi. Jika berhasil maka thread akan menambahkan nilai variabel tersebut. Variabel ini bertugas sebagai semacam semaphore. Untuk menggunakan lock ini, method untuk write dan read harus dimodifikasi.

public void read() {
        System.out.println(strid + ": start!");
        while (true) {
            try {
                lock.lockRead();
                System.out.println(strid + ": start reading!");
                FileInputStream fis = new FileInputStream(fileName);
                byte[] b = new byte[4];
                fis.read(b);
                System.out.println(strid + ": read \"" + new String(b) + "\"");
                fis.close();
                System.out.println(strid + ": done reading!");
                lock.unlockRead();
            } catch (Exception ex) {
                synchronized (System.out) {
                    ex.printStackTrace(System.out);
                }
            }
        }
    }

public void write() {
        System.out.println(strid + ": start!");
        while (true) {
            try {
                lock.lockWrite();
                System.out.println(strid + ": start writing!");
                FileOutputStream fos = new FileOutputStream(fileName);
                String srandom = Long.toString((long) ((new Random()).nextDouble() * 9000) + 1000);
                //Writing random
                System.out.println(strid + ": write \"" + srandom + "\"");
                fos.write(srandom.getBytes());
                fos.close();
                System.out.println(strid + ": done writing!");
                lock.unlockWrite();
            } catch (Exception ex) {
                synchronized (System.out) {
                    ex.printStackTrace(System.out);
                }
            }
        }
    }

Hasilnya, Writers akan serialized dengan seluruh Readers. Contoh keluarannya dapat dilihat di bawah.

..
Writer 1: start writing!
Writer 1: write "8742"
Writer 1: done writing!
Reader 4: start reading!
Reader 2: start reading!
Reader 5: start reading!
Reader 3: start reading!
Reader 5: read "8742"
Reader 5: done reading!
Reader 5: start reading!
Reader 1: start reading!
Reader 1: read "8742"
Reader 3: read "8742"
Reader 3: done reading!
Reader 4: read "8742"
Reader 5: read "8742"
Reader 4: done reading!
...

Kode dapat dilihat di sini. (ganti ekstensi jadi zip)

Setelah mengimplementasikan Multithread di postingan sebelumnya, jadi pengen iseng-iseng nyoba salah satu problem di IPC yakni Readers and Writers. Sebelumnya di kuliah High Performance System, pernah dikasih tugas yang menyangkut IPC problem juga yakni Producer dan Consumer, tapi pakai bahasa C dan pakai  POSIX thread. Sekarang ingin coba implementasi di Java.

Permasalahan Readers and Writers ini tidak jauh berbeda dengan Dining Philosopher, hanya saja di Readers and Writers ini terdapat beberapa Readers dan Writers. Kedua jenis ini memiliki perlakuan yang berbeda. Sebuah filefile boleh diakses beberapa Reader bersamaan, tetapi ketika Writer sedang menulis tidak ada yang boleh menulis file tersebut.

Masalah ini bisa dilihat setelah kita memodifikasi method untuk write dan read pada kode di postingan sebelumnya.

public void read() {
        System.out.println(strid + ": start!");
        while (true) {
            System.out.println(strid + ": start reading!");
            try {
                FileInputStream fis = new FileInputStream(fileName);
                byte[] b = new byte[5];
                fis.read(b);
                System.out.println(strid + ": read \"" + new String(b) + "\"");
                fis.close();
            } catch (FileNotFoundException ex) {
                ex.printStackTrace();
            } catch (IOException ex) {
                ex.printStackTrace();
            } catch (Exception ex) {
                ex.printStackTrace();
            }
            System.out.println(strid + ": done reading!");
        }
    }

public void write() {
        System.out.println(strid + ": start!");
        while (true) {
            System.out.println(strid + ": start writing!");
            try {
                FileOutputStream fos = new FileOutputStream(fileName);
                String srandom = Long.toString((long) ((new Random()).nextDouble() * 9000) + 1000);
                //Writing random
                System.out.println(strid + ": write \"" + srandom + "\"");
                fos.write(srandom.getBytes());
                fos.close();
            } catch (FileNotFoundException ex) {
                ex.printStackTrace();
            } catch (IOException ex) {
                ex.printStackTrace();
            } catch (Exception ex) {
                ex.printStackTrace();
            }
            System.out.println(strid + ": done writing!");
        }
    }

Jika kode ini dijalankan maka keluarannya dapat berupa

Reader 1: start!
Writer 1: start!
Reader 2: start!
Writer 1: start writing!
Reader 1: start reading!
Reader 2: start reading!
Reader 2: read "     "
Reader 2: done reading!
Reader 1: read "     "
Reader 2: start reading!
Reader 1: done reading!
Reader 1: start reading!
Reader 2: read "     "
Writer 1: write "8727"
Reader 2: done reading!
Reader 1: read "     "
Reader 2: start reading!
Reader 1: done reading!
Reader 1: start reading!
Writer 1: done writing!
Writer 1: start writing!
Reader 2: read "8727 "
Reader 1: read "8727 "
Reader 2: done reading!
Reader 2: start reading!
Reader 2: read "     "
Reader 1: done reading!
Reader 2: done reading!
Reader 1: start reading!
Reader 2: start reading!
Writer 1: write "9972"
Reader 1: read "9972 "
Writer 1: done writing!
Reader 2: read "9972 "
Reader 1: done reading!
Reader 2: done reading!
Writer 1: start writing!
Reader 2: start reading!
Reader 1: start reading!
Reader 2: read "     "
Writer 1: write "7951"
Reader 2: done reading!
Reader 1: read "     "
Reader 2: start reading!
Writer 1: done writing!
Writer 1: start writing!
Reader 1: done reading!
Reader 1: start reading!
Reader 2: read "7951 "
...

Dapat dilihat hasilnya agak kacau karena tidak ada sinkronisasi sama sekali. Kadang-kadang si Readernya tidak mendapat hasil apa-apa karena berkas sedang di tulis.
Kodenya dapat diunduh di sini. (rename extension ke zip dulu)

Cuman snippets aja, kadang-kadang suka lupa gimana cara pakai multithread di Java. ^_^

import java.util.logging.Level;
import java.util.logging.Logger;

/**
 *
 * @author Petra Barus
 */
public class ReadWrite1 implements Runnable {

    //
    public static int countwriter = 0;
    public static int countreader = 0;
    //
    public static final int READER = 0;
    public static final int WRITER = 1;
    //
    private int type;
    private int id;
    private String strid;

    public ReadWrite1(int type) {
        this.type = type;
        this.strid = (type == READER) ? ("Reader " + (this.id = ++countreader)) : ("Writer " + (this.id = ++countwriter));
    }

    public static void main(String[] argv) {
        (new Thread(new ReadWrite1(READER))).start();
        (new Thread(new ReadWrite1(READER))).start();
        (new Thread(new ReadWrite1(WRITER))).start();
    }

    public void run() {
        if (type == READER) {
            read();
        } else if (type == WRITER) {
            write();
        }
    }

    //*********************************************************
    // Reader
    //*********************************************************
    /**
     *
     */
    public void read() {
        System.out.println(strid + ": start!");
        while (true) {
            System.out.println(strid + ": reading!");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException ex) {
                Logger.getLogger(ReadWrite1.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }
    //*********************************************************
    //*********************************************************
    // Writer
    //*********************************************************

    public void write() {
        System.out.println(strid + ": start!");
        while (true) {
            System.out.println(strid + ": writing!");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException ex) {
                Logger.getLogger(ReadWrite1.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }
    //*********************************************************
}

Contoh keluarannya

Reader 1: start!
Reader 2: start!
Reader 2: reading!
Reader 1: reading!
Writer 1: start!
Writer 1: writing!
Reader 1: reading!
Reader 2: reading!
Writer 1: writing!
Reader 1: reading!
Reader 2: reading!
Writer 1: writing!
Reader 2: reading!
Reader 1: reading!
Writer 1: writing!