Ubuntu Software Center Tertutup Sendiri (Closed Unexpectedly), Ini Solusinya

Meskipun menginstall software baru dapat dilakukan secara manual melalui terminal, dengan apt. Rasanya tetap nyaman menggunakan software center. Selain karena tampilannya berbasis GUI dan praktis digunakan, melalui ini kita bisa melihat menu software secara lebih detail. Apa jadinya kalau software center tiba--tiba mengalami masalah?

Inilah yang baru saja saya alami. Ubuntu software center dapat dibuka normal, sih. Selang beberapa waktu, saya sepertinya harus menunggu data software yang masih keadaan diload. Tiba-tiba, cling. Seperti sihir, ia menghilang begitu saja. Berkali-kali saya coba buka kembali menghasilkan kondisi serupa. Sayapun mencoba eksekusi apt-get update, sambil berharap agar software center kembali seperti sedia kala. Ya, akhirnya berhasil.

Hanya sehari ia bekerja normal. Keesokannya, saya menemui masalah kemarin hari, seperti kisah lama yang terulang kembali. Sayapun tak berkutik, karena tak tahu sebab dan asal muasalnya. Muncul sebuah ide untuk menjalankan software center dari terminal. Sebelum menghilang tiba-tiba, di terminal saya menemukan pesan log aneh.

(ubuntu-software:2114): GLib-ERROR **: Creating pipes for GWakeup: Too many open files

Yang benar saja? Too many open files?

Jika memang terlalu banyak open files, mana mungkin saya bisa menjalankan program lain dengan normal. Ah sudahlah. Penyebabnya sudah diketahui, jadi saya bisa bertanya ke Google soal ini.

Dan, strike. Inilah jawabannya (https://ubuntuforums.org/showthread.php?t=2343602)

sudo apt-get install ubuntu-software -f

Alhamdulillah, masalah tersebut fixed. Entah apa gunanya argumen "-f" pada perintah tersebut. Yang jelas, saya berterima kasih pada Google dan Ubuntu Foums. :)

Read more

GTK Programming : Membuat Idle dan Timeout

Sampai sekarang, banyak kontributor yang mengupayakan GTK menjadi thread-safe, namun hal itu rupanya sangat sulit. Untuk mengakses widget dengan fungsi GTK secara bersamaan dari thread, banyak yang merekomendasikan untuk menggunakan idle atau time out. Setelah memahami 2 konsep ini, Anda dapat mengombinasikannya dengan thread tanpa harus kawatir masalah keamanan dalam multithreading.  Jadi, apa itu idle dan timeout?
 
Idle
Idle adalah suatu fungsi yang disisipkan pada main thread. Biasanya idle digunakan untuk mengakses widget secara terus menerus saat program berjalan.
Seperti yang telah kita ketahui sebelumnya, gtk_main() sebenarnya bekerja menerima event dan melanjutkannya kepada callback yang sesuai. Dengan menambahkan sebuah idle, fungsi yang kita inginkan akan dieksekusi setelah gtk_main() menangani handle.

Untuk menambahkan idle, kita dapat memilih satu dari 2 macam metode, yaitu dengan metode dari GDK atau dengan metode dari GLib. Menurut beberapa sumber, metode dari GDK lebih aman, namun ada pula sumber yang mengatakan keduanya sama saja. Jika dilihat dari dokumentasi GTK, penggunaan metode dari GLib ataupun GDK sama sekali tidak dipermasalahkan, namun programmer dianjukan untuk memakai fungsi dari GDK.

GDK:

guint gdk_threads_add_idle (GSourceFunc function, gpointer data);

GLib:

guint g_idle_add (GSourceFunc function, gpointer data);

function : Argumen ini berupa alamat ke fungsi callback GSourceFunc yang ingin didaftarkan. GSourceFunc merupakan fungsi khusus untuk membuat idle dan timeout. Bentuk fungsinya seperti berikut:

gboolean nama_callback (gpointer user_data);
{
   //do something
}

Fungsi callback ini akan terus dipanggil selama kita masih mengembalikan TRUE. Saat fungsi selesai dengan return FALSE, maka secara otomatis idle dihapus.  

data : Argumen kedua ini berupa pointer ke data yang dikirimkan pada fungsi callback. Sifatnya opsional, jadi bisa dikosongi.
 
Timeout
Timeout kurang lebih sama dengan idle. Perbedaanya, sebelum menjalankan fungsi callback, interval akan diperiksa terlebih dahulu.

Metode untuk membuat timeout juga disediakan oleh GDK dan GLib, sama halnya dengan idle. Parameter function dan data memiliki ketentuan pemakaian yang sama dengan fungsi yang dijelaskan sebelumnya. Fungsi berikut memiliki parameter interval, yaitu jangka waktu yang dipakai sebagai patokan sebelum pemanggilan fungsi callback. Satuan interval ditulis dalam milidetik, jadi, jika ingin callback dipanggil setiap 1 detik, gunakan argumen 1000 pada parameter interval.

GDK:

guint gdk_threads_add_timeout (guint interval, GSourceFunc function, gpointer data);

GLib:

guint g_timeout_add (guint interval, GSourceFunc function, gpointer data);

Contoh Kode

#include<stdio.h>
#include<gtk/gtk.h>

GtkWidget *window;
int num = 0;
char str[20];

gboolean timeout (gpointer user_data)
{
   sprintf((char*)&str,"Timeout: %d x", num);
   gtk_window_set_title(GTK_WINDOW(window),(char*)&str);
   num++;
   return TRUE;
}

void window_destroy (GtkWidget *object, gpointer user_data)
{
    g_print("Event destroy diterima :) \n");
    gtk_main_quit();
}

int main(int argc, char *argv[])
{
    gtk_init(&argc, &argv);
    //window baru
    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(window),"GtkWindow");
    //hubungkan signal destroy
    g_signal_connect (window, "destroy", G_CALLBACK (window_destroy),NULL);
    //daftar timeout. Fungsi akan dipanggil setiap 1000 ms (1 detik)
    gdk_threads_add_timeout(1000,timeout,0);
    //tampilkan widget
    gtk_widget_show_all(window);
    gtk_main();
    return 0;
}

Kode di atas akan membuat timeout dengan interval 1000 ms. Fungsi timeout() didaftarkan sebagai callback. Sehingga setiap satu detik, fungsi tersebut dipanggil. Dalam fungsi tersebut kita mengubah titlebar window dengan jumlah total pemanggilan fungsi callback.

Hasil

Read more

GTK Programming : Tipe Variabel Dasar GLib

GTK dibangun dengan mengimplementasikan GLib. Sehingga banyak tipe data yang mengikuti standar dari GLib. Pada dasarnya semua tipe data tersebut merupakan tipe data standar bahasa C yang didefinisikan sesuai konvensi GLib. Sederhananya, hampir semua tipe dasar GLib sama seperti fungsi standar C dengan tambahan karakter “g” di awal dan menyingkat keyword “unsigned” dengan karakter “u”.

Berikut ini adalah daftar lengkap tipe dasar GLib dan persamaannya dengan tipe standar yang biasa diimplementasikan pada bahasa C.

Tipe GLib	Tipe C	Tipe GLib	Tipe C
gboolean	int	gint16	signed short
gpointer	void*	guint16	unsigned short
gconstpointer	const void*	gint32	signed int
gchar	char	guint32	unsigned int
guchar	unsigned char	gint64	signed long
gint	int	guint64	unsigned long
guint	unsigned int	gfloat	float
gshort	short	gdouble	double
gushort	unsigned short	gsize	unsigned long
glong	long	gssize	signed long
gulong	unsigned long	goffset	unsigned long
gint8	signed char	gintptr	signed int
guint8	unsigned char	guintptr	unsigned int

Banyak tipe GLib yang memiliki kesamaan tipe dasar C, misalnya gsize dan gulong. Walaupun begitu, GLib tidak menggunakan tipe-tipe tersebut secara sembarangan. Misalnya tipe gulong digunakan untuk menampung data umum, sementara itu gsize lebih direkomendasikan untuk menyimpan ukuran suatu data dalam byte. Tipe gboolean merupakan definisi lain dari tipe int. Kita tahum tipe int dapat menampung data beragam, tapi penggunaan gboolean lebih direkomendasikan untuk menampung angka 0 atau 1 saja. Tipe gint8, guint8, dan lainnya juga demikian. Pada dasarnya kelompok tipe ini sama seperti tipe gint, guint dan lainnya. Bedanya fungsi gint dan lainnya dapat dipakai untuk menampung data umum, sementara guint8 dan lainnya direkomendasikan untuk menampung data yang erat kaitannya dengan pehitungan matematis.

Perbedaan penggunaan setiap tipe data tadi hanyalah rekomendasi. Jika anda tahu bahwa antara kedua tipe memiiliki kesamaan, anda bebas untuk menggunakan salah satu diantaranya. Bahkan anda juga boleh menggunakan tipe standar C saja.

Read more

GTK Programming : Membuat Thread dengan GLib

Thread adalah bagian dari proses, namun thread bukanlah proses. Dalam sebuah proses minimal terdapat satu buah thread utama, disebut juga sebagai main thread. Dalam program C, main thread adalah kode yang berada pada fungsi main() sekaligus fungsi-fungsi yang dipanggil dari main().

Thread biasanya dibuat untuk menjalankan tugas lebih cepat, atau digunakan saat ada 2 tugas yang harus dikerjakan secara bersamaan. Misalnya dalam sebuah video player, kita tidak bisa hanya bekerja dengan main thread, setidaknya ada 1 atau 2 lagi thread lainnya. Thread utama untuk menerima input/perintah dari user, thread kedua untuk mengolah suara dan thread ketiga untuk mengolah video. Tentu saja hal ini tidak bisa dilakukan dengan 3 fungsi yang berjalan secara berurutan, ketiganya harus berjalan bersamaan.
 
Dengan membuat thread baru, itu artinya kita membuat fungsi lain berjalan bersamaan dengan fungsi main() dalam waktu yang sama. Dengan berjalan bersamaan, program dapat berjalan lebih cepat. Tapi hal itu bukan berarti akan membuat semuanya lebih mudah.

Program yang menjalankan lebih dari satu thread, harus menjaga agar data global tidak diakses secara bersamaan. Jika tidak, hal yang tak diinginkan dapat terjadi sewaktu-waktu. Sehingga program yang mengimplementasikan multithreading harus mempertimbangkan syncronization primitives.

Kita tidak akan membahas bagaimana mengimplementasikan syncronization primitives. Tapi sekarang kita akan membahas permasalahan thread di GTK yang sangat erat kaitannya dengan multithreading.

Sebuah library dikatakan thread-safe apabila dapat diakses oleh banyak thread secara bersamaan. GTK mungkin aman dipakai untuk banyak program, tetapi rupanya GTK sampai sekarang belum tergolong thread-safe. Jadi, GTK hanya diperbolehkan untuk diakses dari main thread saja.
Semua fungsi callback sebenarnya dieksekusi sebagai bagian dari main thread, jadi jangan kawatir. Lagipula, tidak banyak keperluan berkaitan GTK yang harus diakses melalui thread. Jika ada, maka kita sebaiknya menggunakan idle dan timer untuk melakukannya. Selengkapnya tentang idle dan timer akan dibahas pada kesempatan lain yaa..

Baik, sekarang kita bahas bagaimana membuat thread. Walaupun kita tidak bisa mengakses GTK dari sini, nantinya kita akan menemui banyak sekali hal yang harus dilakukan secara multithreading.
Untuk membuat sebuah thread, gunakan fungsi berikut.

GThread *g_thread_new (const gchar *name, GThreadFunc func, gpointer data);

Fungsi di atas mengembalikan struktur GThread. Struktur ini bersifat opaque, atau tidak bisa diakses secara langsung. Kita hanya perlu tahu bahwa struktur ini berisi tentang informasi thread. Fungsi ini menggunakan 3 argumen, yaitu:

• name : identitas thread. Digunakan untuk keperluan debug, jadi cukup isikan sesuai dengan keinginan anda. Maksial 16 karakter
• func : Pointer ke fungsi GThreadFunc, yaitu fungsi yang digunakan sebagai thread.
• data : Data yang digunakan sebagai argumen pada fungsi GThreadFunc.

GThreadFunc
Berbeda dengan fungsi main thread seperti biasa (int main()). Bentuk fungsi thread yang dibuat harus memiliki bentuk sebagai berikut.

gpointer nama_fungsi (gpointer data);
{
   //lakukan sesuatu
}

Return value bukan berupa int, tapi berupa data dalam bentuk pointer. Untuk mengetahui data yang dikembalikan oleh thread, gunakan fungsi berikut.

gpointer g_thread_join (GThread *thread);

Contoh

#include<gtk/gtk.h>

/* thread ini mengeprint pesan
 * lalu pause/sleep selama 1 detik
 * selama 10 kali
 * setelah itu mengembalikan nilai pointer ke string "abcde"
 */
char *r = "abcde \n";
gpointer thread(gpointer data)
{
    int i;
    for(i=10;i!=0;i--){
        g_print("Pesan dari thread() \n");
        g_usleep(1000000);
    }
    return r;
}

int main(int argc, char *argv[])
{
    GThread *t;
    //buat thread
    t = g_thread_new("mythread", thread,0);
    
    //cetak pesan dan sleep 10x
    int i;
    for(i=10;i!=0;i--)
    {
        g_print("Pesan dari main() \n");
        g_usleep(1000000);
    }
    //dapatkan return value
    g_print("Nilai return dari thread: %s \n",(char *)g_thread_join(t) );
}

Kode di atas juga menunjukkan bagaimana menggunakan fungsi g_usleep(). Fungsi ini digunakan untuk melakukan penundaan/pause dalam kurun waktu sekian microsecond.

void g_usleep (gulong microseconds);

Sekali lagi, ingat, jangan memanggil fungsi GTK dari thread :)

Hasil

Read more