Mengenal GPU dan CUDA

Beberapa dekade terakhir nama GPU (Graphic Processing Unit) mencuat. GPU pada awalnya dipakai sebagai accelerator untuk pemrosesan grafis pada komputer yang biasanya paling banyak dimanfaatkan oleh aplikasi game. Namun pada perkembangannya, GPU mulai dilirik sebagai accelerator untuk pemrosesan algoritma yang lebih umum, seperti komputasi numerik, realtime medical imaging, komputasi bioinfiormatika, embedded system, dan lainnya. GPU jenis ini dikenal dengan nama GPGPU (General Purpose GPU). Dalam proses desain chip, terutama yang membutuhkan permodelan realtime seperti wireless system, GPU menjadi solusi menarik untuk mengimplementasikan model dalam realtime dan memverifikasinya.

NVIDIA, sebagai sala satu pengembang GPU, melihat potensi ini kemudian mengembangkan seri-seri GPGPU dengan engine yang bisa diakses secara bebas yaitu CUDA. CUDA (Compute Unified Device Architacture) adalah engine untuk mengakses GPU NVIDIA dan API-nya bisa dipanggil oleh program C secara natural. Klaim dari pihak NVIDIA menyatakan bahwa GPU-card NVIDIA Tesla yang mereka miliki bisa memproses operasi foating-point single precision sampai 1TeraFLOPS.

Apa perbedaan CPU dengan GPU? CPU dan GPU saat ini sama-sama memiliki core processor lebih dari satu (multicore). CPU biasanya maksimal saat ini 4-core processor, atau disebut quad-core, sedangkan GPU bisa mencapai sampai 400-core. Walaupun sama-sama multicore, ada perbedaan mendasar pada paradigma multicore-nya. Kalau CPU adalah MIMD, Multiple-Instruction Multiple-Data, sedangkan GPU adalah SIMD, Single-Instruction Multiple-Data.

Instalasi (Driver, CUDA Toolkit, dan SDK)

Berikut langkah-langkah dalam instalasi GPU NVIDIA. Ada tiga macam yang perlu diinstal: NVIDIA Driver, CUDA toolkit, dan SDK (Software Development Kit). Driver, CUDA tookit, dan SDK bisa didownload di website NVIDIA.

Berikut file-file yang saya download untuk Ubuntu 10.0:

NVIDIA-Linux-x86_64-260.19.44.run

cudatoolkit_3.2.16_linux_64_ubuntu10.04.run

gpucomputingsdk_3.2.16_linux.run

Untuk menginstall NVIDIA Driver, matikan dulu X-servernya, jalankan installernya, lalu aktifkan kembali X-servernya atau bisa juga reboot.

(ALT+F1)

$ sudo su

$ /etc/init.d/gdm stop

$ cd <NVIDIA_Driver_Path>

$ ./NVIDIA-Linux-x86_64-260.19.44.run

$ /etc/init.d/gdm start

Untuk menginstall CUDA toolkit, jalankan instaler sebagai root.

$ sudo su

$ ./cudatoolkit_3.2.16_linux_64_ubuntu10.04.run

Disini akan ditanya dimana CUDA akan diinstal, defaultnya diinstall di /usr/local/cuda, tapi bisa juga diset untuk diinstall ditempat lain misalnya /opt/cuda. Setelah installasi selesai, set variable PAT dan LD_LIBRARY_PATH mengarah ke tempat instalasi CUDA. Edit file ~/.bashrc dan tambahkan line berikut (asumsi CUDA diinstall di /usr/local/cuda), lalu eksekusi ~/.bashrc tersebut.

export PATH=$PATH:/usr/local/cuda/bin

export LD_LIBRARY_PATH=/usr/local/cuda/lib

$ source ~/.bashrc

Jika instalasi berhasil, compiler bawaan CUDA (nvcc) sudah bisa dijalankan. Buat  hello world biasa dalam bahasa C,dan coba compile dan jalankan hello worldnya.

$ nvcc –o hello hello.c

$ ./hello

Hello

Compiler CUDA (nvcc) bekerja sama persis dengan gcc, apabila extension filenya adalah .c. Agar code dianggap sebagai CUDA code, ubah extensionya menjadi .cu. Penjelasan lebih lanjut mengenai ini bisa disimak pada bagian “Hello World” dalam artikel ini.

Untuk instalasi SDK, jalankan installer sebagai root.

$ sudo su

$ ./gpucomputingsdk_3.2.16_linux.run

Ketika installasi, lokasi instalasi CUDA toolkit akan diminta. Pada proses intalasi (terutama Ubuntu), akan ditemui beberapa masalah, terutama masalah library. Biasanya ada dua library yang perlu ditambahkan, yaitu library X Windows dan OpenGL (lXi, dan lglut).

$ sudo apt-get install libXi-dev libglut3 libglut3-dev

OK, SDK sudah terinstall dan siap digunakan. Untuk mencobanya, masuk ke directory /C/src, copy project template, compile dan jalankan binary-nya, kalau berhasil, kalimat “Test PASSED” akan muncul.

$ cd /C/src

$ cp –r template coba

$ cd coba

$ make

$ ../../bin/linux/release/template

Test PASSED

Pada beberapa kasus, muncul error linker. Kasus yang sering muncul adalah:

/usr/bin/ld: cannot find -lshrutil_x86_64

/usr/bin/ld: cannot find -lcutil_x86_64

/usr/bin/ld: cannot find -lglut

/usr/bin/ld: cannot find -lGL

Berikut solusi-solusinya:

ERROR: /usr/bin/ld: cannot find -lshrutil_x86_64

Cek dulu, seharusnya library -lshrutil_x86_64 ada di /shared/lib, kalau belum ada bisa di-create ulang:

$ cd /shared

$ make

ERROR: /usr/bin/ld: cannot find -lcutil_x86_64

Cek dulu, seharusnya library -lcutil_x86_64 ada di /C/lib, kalau belum ada bisa di-create ulang:

$ cd /C

$ make

ERROR: /usr/bin/ld: cannot find -lglut

ERROR: /usr/bin/ld: cannot find -lGL

Berarti library OpenGL belum tersedia, untuk Ubuntu jalankan command berikut:

$ sudo apt-get install libglut3 libglut3-dev

Lalu tapi ada sedikit tweak untuk Ubuntu, yaitu kalau masih ada error /usr/bin/ld: cannot find -lGL, artinya library /usr/lib/libGL.so broken (lihat http://ubuntuforums.org/showthread.php?t=1480282). Solusinya, delete file /usr/lib/libGL.so, lalu buat link dari /usr/lib/libGL.so.1

$ rm /usr/lib/libGL.so

$ ln -s /usr/lib/libGL.so.1 /usr/lib/libGL.so

Sampai disini installasi sudah selesai semua, Driver, CUDA toolkit, dan SDK. Kita bisa coba lagi menjalankan program template.

$ cd /C/src

$ cp –r template coba

$ cd coba

$ make

$ ../../bin/linux/release/template

Test PASSED

CUDA Hello World (First Program)

#include #include int main(int argc, char *argv[]) {     printf("Hello\n");     return 0; }

Program hello world dalam C sudah dicoba pada bagian instalasi, dan bisa berjalan dengan baik, karena ketika program hello world tersebut dijalankan, eksekusi hanya dilakukan pada CPU. Kita akan sedikit memodifikasi code hello world sebelumnya, dengan menambahkan dua hal:

• Fungsi kosong bernama kernel() dengan quaifier __global__
• Call ke fungsi kosong kernel(), dengan imbuhan <<<1, 1>>>

#include #include #include "cuda.h" __global__ void kernel(void) { } int main(int argc, char *argv[]) {     kernel<<<1,1>>>();     printf("Hello\n");     return 0; }

CUDA menambahkan qualifier __global__ pada standard C. Qualifier ini akan memberitahu compiler bahwa eksekusi fungsi didalam __global__ dilakukan di device (GPU), bukan di host (CPU). Call ke fungsi kernel menggunakan imbuhan <<<1, 1>>> untuk memberitahu, bagaimana fungsi kernel dijalankan di device (GPU). Compile code diatas, dan jalankan programnya, maka akan keluar hasil yang sama, yaitu “Hello”, sama persis dengan sebelum dimodifikasi, karena memang fungsi di GPU kosong. Sekarang kita coba tambahkan fungsi sederhana yang dijalankan di GPU, yaitu fungsi penjumlahan.

#include #include #include "cuda.h" __global__ void add( int a, int b, int *c ) {     *c = a + b; } int main(int argc, char *argv[]) {     int c;     int *dev_c;       cudaMalloc( (void**)&dev_c, sizeof(int) );        add<<<1,1>>>( 2, 7, dev_c );      cudaMemcpy( &c,  dev_c,  sizeof(int),  cudaMemcpyDeviceToHost );     printf( "2 + 7 = %d\n", c );     cudaFree( dev_c ); }

Compile code-nya, lalu jalankan programnya.

$ nvcc -o hello hello.cu

$ ./hello

2 + 7 = 9

Voila! selamat mencoba! (Ya2n)

Design hierarki sistem menggunakan TLM-2.0

TLM (Transaction Level Modeling) adalah tools yang disediakan SystemC untuk memodelkan komunikasi antar modul dalam system, baikan dalam hardware, software, ataupun komunikasi yang melibatkan hardware software. TLM memungkinkan kita modelkan sistem dilakukan dengan cepat. Salah satu hal penting yang kita butuhkan dalam memodelkan sistem adalah kemampuan merepresentasikan hierarchy. Berikut sedikit pengenalan bagaimana membuat desain hierarchy dalam SystemC TLM-2.0.  

Initiator dan target

Dalam TLM, kita mengenal istilah initiator dan target. Initiator adalah modul yang menginisiasi/mengawali transaksi, sedangkan target adalah yang menerima transaksi. Gambaran umumnya adalah seperti CPU menulis data ke RAM, dimana CPU adalah initiator, dan RAM adalah target. Initiator bisa dibungkus oleh modul initiator yang lain, begitu pula dengan target. Ini berguna jika ingin membuat desain dengan granularity yang jelas. 

Desain hierarchy pada gambar diatas dapat dibuat menggunakan library tlm_initiator_socket dan tlm_target_socket  dari tlm core interface. Kalau memakain tlm_utils, jangan lupa definisikan SC_INCLUDE_DYNAMIC_PROCESSES.

#define SC_INCLUDE_DYNAMIC_PROCESSES

#include "systemc.h"
#include "tlm/tlm.h"

struct initiator : sc_module {

tlm::tlm_initiator_socket<> init_socket;

SC_CTOR(initiator) : init_socket("init_socket")

{}

};

struct target : sc_module {

tlm::tlm_target_socket<> targ_socket;

SC_CTOR(target) : targ_socket("targ_socket")

{}

};

struct parent_of_initiator : sc_module {

tlm::tlm_initiator_socket<> init_socket;

initiator *INITIATOR;

SC_CTOR(parent_of_initiator) : init_socket("init_socket")

{

INITIATOR = new initiator("INITIATOR");

        INITIATOR->init_socket.bind(init_socket);

}

};

struct parent_of_target : sc_module {

tlm::tlm_target_socket<> targ_socket;

target *TARGET;

 SC_CTOR(parent_of_target) : targ_socket("targ_socket")

{

TARGET = new target("TARGET");

        targ_socket.bind(TARGET->targ_socket);

}

};

struct parent_of_initator_and_target : sc_module

{

tlm::tlm_initiator_socket<> init_socket;

tlm::tlm_target_socket<> targ_socket;

initiator *INITIATOR;

target *TARGET;

SC_CTOR(parent_of_initator_and_target) : init_socket("init_socket"), targ_socket("targ_socket")

{

INITIATOR = new initiator("INITIATOR");

TARGET = new target("TARGET");

  INITIATOR->init_socket.bind(init_socket);

  targ_socket.bind(TARGET->targ_socket);

}

};

Sebuah initiator juga bisa berfungsi sekaligus sebagai target. Ini sangat diperlukan ketika memodelkan interconnect component. Berikut implementasinya menggunakan simple_initiator_socket dan simple_target_socket.

struct initiator_target : sc_module {

tlm::tlm_initiator_socket<> init_socket;

tlm::tlm_target_socket<> targ_socket;

 SC_CTOR(initiator_target) : init_socket("init_socket"), targ_socket("targ_socket")

{}

};

struct parent_of_initiator_target : sc_module

{

tlm::tlm_initiator_socket<> init_socket;

tlm::tlm_target_socket<> targ_socket;

initiator_target *INITIATOR_TARGET;

SC_CTOR(parent_of_initiator_target): init_socket("init_socket"), targ_socket("targ_socket")

{

INITIATOR_TARGET = new initiator_target("INITIATOR_TARGET");

INITIATOR_TARGET->init_socket.bind(init_socket);

  targ_socket.bind(INITIATOR_TARGET->targ_socket);

}

};

TLM library dan source code pada contoh ini bisa didownload pada halaman Download. Sampai jumpa di tutorial TLM selanjutnya... Selamat mencoba.. ^^ (Ya2n)

Fixed-Point Modeling Menggunakan SystemC

Bernostalgia dengan LSI Design Contest in Okinawa 2007, saya kepikiran untuk mencoba membuat model FFT64-point yang ada dalam spec contest tersebut kedalam fixed-point di C/C++. Hal ini juga termotivasi dengan adanyya kebutuhan untuk memulai migrasi model fixed-point dari Octave/Matlab ke C/C++.

Tipe data fixed-point diperlukan dalam memodelkan hardware (chip) karena dalam harware representasi angka dibuat dalam satuan bit, misalnya angka 5 direpresentasikan dalam bit 101. Oleh karena jumlah bit terbatas, maka representasi angka terpaksa dibatasi juga, kalau hanya ada representasi angka dalam 2 bit, maka nilai 5 tidak ada, karena angka 5 membutuhkan representasi paling sedikit dalam 3 bit. Demikian halnya representasi angka rational dalam hardware, juga dibatasi oleh jumlah bit. Representasi angka rational dalam hardware biasanya dibuat dalam representasi fixed-point. Dengan representasi fixed-point ini, kita bisa memodelkan berbagai algoritma yang membutuhkan operasi rational seperti dalam algoritma FFT.

FFT (Fast Fourier Transform) adalah algoritma yang banyak digunakan dalam DSP (Digital Signal Processing), baik dalam image processing, audio/video, dan communication. Algoritma ini membutuhkan representasi nilai rational karena menggunakan operasi trigonometri seperti sinus dan cosinus. Dalam FFT, tidak hanya dibutuhkan fixed-point, tapi juga bilangan kompleks. Dalam C/C++, ada standard library complex tapi belum ada standard library fixed-point. Ada beberapa solusi dalam representasi fixed-point, beberapa diantaranya adalah library GNU MPFR dan SystemC. SystemC dipilih karena bahasa modeling ini sangat dekat dengan bahasa hardware (Verilog/VHDL) dan bahkan bisa di-mix dalam satu tool untuk mensimulasikannya.

Hasil percobaan menunjukkan bahwa model fixed-point FFT-64 di SystemC valid dan menunjukkan perilaku yang sama dengan model FFT64 dari library Matlab, pada konfigurasi fixed-point<10, 3>, tapi menunjukkan hasil yang berbeda ketika menggunakan konfigurasi fixed-point<10, 5> karena terjadi overflow (clipping). Gambar pertama adalah menggunakan Matlab library, gambar kedua adalah menggunakan fixed-point<10, 3>, gambar terkahir adalah menggunakan fixed-point<10, 5>.

Artikel selengkapnya bisa didownload pada halaman Download dengan judul FFT-64 Fixed-Point Modeling Using SystemC and User Defined Complex Datatypes. Selamat mencoba! ^^ (Ya2n)

Membuat User Define Complex Datatype menggunakan Operator Overloading di C/C++

(Updated 2011/03/11 - menambahkan fungsi abs() dan conj())

Dalam pemodelan DSP (Digital Signal Processing), tak jarang kita membutuhkan operasi bilangan kompleks, misal (2 + 3i) * (0.2 + 3.5i). Operasi seperti ini sangat mudah dilakukan di Matlab, seperti berikut ini:

>> (2 + 3i) * (0.2 + 3.5i)


ans=


  -10.1000 + 7.6000i

Tapi berbeda halnya ketika menggunakan C/C++. Tapi jangan kuatir, sekompleks apapun tipe data dan operasinya, bisa kita buat di C/C++. Tipe data complex sebenarnya sudah ada di standard library , namun dengan alasan interoperability, kita bisa buat sendiri tipe datanya. Misal, jika ingin menggabungkan library fix-point nya SystemC dengan tipe data kompleks.

Operator overloading.

Operator overloading memungkinkan kita untuk menggunakan operasi yang sama pada jenis tipe data yang berbeda dan menghasilkan hasil yang berbeda. Contoh ekstrimnya begini:

int a = 1;
int b = 2;
int c = a + b; // c = 3

Kode diatas akan menghasilkan nilai c = 3. Akan tetapi kalau kita memiliki tipe data lain yang ada operator overloading untuk operasi penjumlahan (+) nya, maka hasilnya bisa beda sesuai keinginnan kita. Misal:

tipe_buatan_sendiri a = 1;
tipe_buatan_sendiri b = 2;
tipe_buatan_sendiri c = a + b; // c = -1 (haha)

Kalau saya overload operator penjumlahannya menjadi: + adalah a - b, maka kode diatas akan menghasilkan nilai c = -1, karena c = a + b = a - b (karena operasi + saya overload menjadi -) = 1- 2 = -1. Haha, seems mad =)).. OK, itu contoh ekstrimnya, kita masuk ke implementasi real-nya pada tipe data kompleks.

Tipe data kompleks.

Tipe data kompleks memiliki anggota real dan imaginer, kita buat dulu struct-nya.

struct mycomplex_t {
  int real, imag;


  //constructor
  mycomplex_t(int init_real, int init_imag)
  {
    real = init_real;
    imag = init_imag;
  }
};

Sekarang kita punya tipe data mycomplex_t, dan langsung bisa kita gunakan:

mycomplex_t a(1, 2); //real = 1, imag = 2
cout << a.real; //print nilai real dari a, yaitu = 1
cout << a.imag; //print nilai real dari a, yaitu = 2

Kode mycomplex_t a(1, 2) akan memanggil struct mycomplex_t, dang menginisiasi nilai real dan imag yang ada di struct tersebut menggunakan constructor. Lalu kita tambahkan operator penjumlahan menggunakan operator overloading dan copy contsructor:

struct mycomplex_t {

  int real, imag;

  //constructor

  mycomplex_t(int init_real, int init_imag)

  {

    real = init_real;

    imag = init_imag;

  }

  //operasi penjumlahan

  mycomplex_t operator + (const mycomplex_t& rhs) {
    mycomplex_t t(0, 0);

    t.real = this->real + rhs.real;

    t.imag = this->imag + rhs.imag;

    return t;

  }

};

Dengan begini kita bisa lakukan operasi sebagai berikut:

mycomplex_t a(1, 2); //real = 1, imag = 2

mycomplex_t b(3, 4); //real = 3, imag = 4

mycomplex_t c(0, 0); //real = 0, imag = 0

c = a + b;

cout << c.real; //print nilai real dari c, yaitu = 4

cout << c.imag; //print nlai real dari c, yaitu = 6

OK, sampai disini kita sudah mempunyai tipe data kompleks buatan sendiri. Agar tipe data ini bisa dipakai sepenuhnya, kta lengkapi operasi-operasi yang mungkin dalam bilangan komplek:

1. + (penjumlahan)

2. - (pengurangan)

3. * (perkalian)

4. / (pembagian)
5. abs (absolut)
6. conj (konjugasi)
7. = (sama dengan)

Berikut operator overloadingnya:

  //operasi penjumlahan

  mycomplex_t operator + (const mycomplex_t& rhs) {
    mycomplex_t t;

    t.real = this->real + rhs.real;

    t.imag = this->imag + rhs.imag;
    return t;

  }

  //operasi pengurangan
  mycomplex_t operator + (const mycomplex_t& rhs) {

    mycomplex_t t;

    t.real = this->real - rhs.real;

    t.imag = this->imag - rhs.imag;

    return t;

  }

  //operasi perkalian

  mycomplex_t operator * (const mycomplex_t& rhs) {
    mycomplex_t t;

    t.real = (this->real * rhs.real) - (this->imag * rhs.imag);

    t.imag = (this->imag * rhs.real) + (this->real * rhs.imag);

    return t;

  }

  //operasi pembagian

  mycomplex_t operator / (const mycomplex_t& rhs) {
    mycomplex_t t;

    int div = ((rhs.real * rhs.real) + (rhs.imag * rhs.imag));

    t.real = ((this->real * rhs.real) + (this->imag * rhs.imag)) / div;

    t.imag = (this->imag * rhs.real) - (this->real * rhs.imag) / div;

    return t;

  }

  //operasi absolut
  mycomplex_t& abs()
  {
    int t;
    t = (this->real * this->real) + (this->imag * this->imag);

    float x1, x2;

    int i;

    while( (i*i) <= t )

          i+=0.1;

    x1=i;

    for(int j=0;j<10;j++)

    {

      x2=m;

      x2/=x1;

      x2+=x1;

      x2/=2;

      x1=x2;

    }

    return x2;    

  }

  //operasi konjugasi

  mycomplex_t& conj() {

    this->real = rhs.real;

    this->imag = - (rhs.imag);

    return *this;

  }

  //operasi sama dengan

  mycomplex_t& operator = (const mycomplex_t& rhs) {

    this->real = rhs.real;

    this->imag = rhs.imag;

    return *this;

  }

Sekarang, mari kita coba operasi-operasi tersebut:

mycomplex_t a(1, 2);

mycomplex_t b(3, 4);

mycomplex_t c(0, 0);

c = a + b;

c = a - b;

c = a * b;

c = a / b;

c = a.abs();
c = a.conj();

Bagaimana hasilnya? OK, bukan? Tapi tunggu dulu, sampai disini masih ada keanehan, kita harus inisiasi nilai tiap kali mau membuat variabel baru, padahal sebenarnya kita belum mengisi nilai variabel tersebut. Seperti dalam contoh: mycomplex_t c(0, 0). Hal ini karena constructor dalam struct-nya memakai parameter:

  //constructor

  mycomplex_t(int init_real, int init_imag)

  {

    real = init_real;

    imag = init_imag;

  }

Agar kita bisa membuat variabel dengan mycomplex_t c; saja, solusinya buat satu constructor lagi yang tanpa parameter tapi initial value-nya 0.

  //constructor

  mycomplex_t()

    : real(0), imag(0)

  {  }

Enjoy! (Ya2n)

Memanggil Code C di Python

Ketika seorang simulation coder sudah mulai meninggalkan tool matlab, maka penggunaan platform C/C++ menjadi alternatif yang cukup menjanjikan dengan tawaran kecepatan dan juga masalah opensource. Tapi masih ada kendala jika semua code dari matlab harus semua diterjemahkan ke dalam C/ C++ yaitu masalah library matlab yang sudah begitu sangat memanjakan engineer simulasi. Maka dari itu untuk melakukan proses migrasi ini akan lebih baik jika kita memanfaatkan kelebihan python sebagai jembatan antara C/C++/IT++ dengan matlab/octave.

Karena saya baru belajar mengenai hal ini (hari ini belajar bersama dengan yayan), maka saya akan mencoba sedikit share pengalaman bagaimana memanggil code C dari python. Mungkin bagi yang sudah terbiasa menggunakan python hal ini menjadi barang yang kecil, tapi meski begitu saya yakin masih banyak beberapa temen yang mungkin bisa mengambil manfaatnya.

1. Membuat code C sederhana.
misal code C-nya seperti ini :

#include
void hello(){
printf("hello, calling C from python is really easy (nek we ngerti rek..he he) \n");
}

kemudian code diatas bisa disimpan ke dalam file-name misalkan aja 'contoh.c'

2. Creating a shared library with the gnu compiler [gcc]
Shared libraries adalah libraries yang dipanggil oleh programs ketika mulai pertama kali. Shared library ini memungkinkan suatu object bisa di-share pada platform yang berbeda (misal python dan C). Untuk membuat 'object files' yang akan menjadi 'shared library' bisa menggunakan gcc -fPIC atau -fpic flag.

Berikut adalah contohnya (ketik di terminal linux):

>>> gcc -shared -fPIC contoh.c -o contoh.o

3. Loading dynamic link libraries
Untuk memanggil shared library yang sudah dibuat diatas kita bisa menggunaka 'ctypes'.
Ctypes akan meng-export 'cdll' untuk nge-load 'dynamic link libraries'.

sebagai contoh di script di python-nya bisa ditulis sebagai berikut :

>>> from ctypes import *
>>> libc = CDLL("./contoh.o")
>>> libc.hello() # hello disini pastikan sama dengan nama fungsi yang ada di code C/C++

kemudian save script python dalam top.py

4. Kemudian panggil python-nya dengan cara berikut (pastikan anda sudah menginstall python):

>>> python top.py

enjoy...

referensi
1. http://www.adp-gmbh.ch/cpp/gcc/create_lib.html
2. http://dalkescientific.com/writings/NBN/ctypes.html
3. http://docs.python.org/library/ctypes.html
4. http://tldp.org/HOWTO/Program-Library-HOWTO/shared-libraries.html
5. http://mail.python.org/pipermail/baypiggies/2009-December/005918.html