Linux & Ocarina

有感

2010-11-29T12:16:00.000+08:00

每當靜下心來好好的寫程式…就能感受到在邏輯的殿堂中自己意志力以及知識的力量，意志力經由手指的敲打化為真實的程式，就像是魔法師一般。看它順利的完成任務，心裏總是開心的滿足的。這單純的喜悅正是為什麼如此著迷於設計並實作軟體，即便是其它人不容易感受到內心的喜悅。
然而…如果想要改善台灣軟體環境的現況，我需要學會的…真的遠遠超過把軟體寫好的能力。夜深人靜時，總是不停的思索這個問題…好像看得到未來的方向，又好虛無飄渺。嗯，我必需學會另一種高度…

Eclair Libgralloc Deadlock Problem

2010-06-09T16:23:00.006+08:00

As we are developing 0xdroid beagle-eclair branch, we occasionally encounter screen flipping issue. This issue rarely happens however it bothers the user experience very much when running some resource eating applications. Last week in the Computex Taipei 2010 show, we demoed 0xdroid beagle-eclair connecting wireless modules and played games. I noticed that this issue happens very often while playing a game called "Frozen Bubble". (It's a good game, we all love this game a lot, and spent a lot of time on it. ;-) ) It's kind of embarrassing when the screen keeps flipping on the show. Therefore I decided to dig out this issue.

Beside of 0xdroid on beagleboard and Devkit8000, I tested some other platforms and find out actually almost all of them having this problem. Therefore I suspected it's not a hardware related problem. Maybe a framework or HAL issue. We noticed that when the screen is flipping, the logcat message will complain as following

E/SurfaceFlinger(  768): eglSwapBuffers: EGL error 0x3002 (EGL_BAD_ACCESS)
E/gralloc (  768): handle 0x13f8c0 not locked
~E/gralloc (  768): handle 0x13f8c0 already locked for write
E/libagl  (  768): eglSwapBuffers() failed to lock buffer 0x1368e0 (640x480)
E/SurfaceFlinger(  768): eglSwapBuffers: EGL error 0x3002 (EGL_BAD_ACCESS)
E/gralloc (  768): handle 0x13f8c0 not locked
E/gralloc (  768): handle 0x13f8c0 already locked for write
E/libagl  (  768): eglSwapBuffers() failed to lock buffer 0x1368e0 (640x480)
E/SurfaceFlinger(  768): eglSwapBuffers: EGL error 0x3002 (EGL_BAD_ACCESS)
E/gralloc (  768): handle 0x13f8c0 not locked
E/gralloc (  768): handle 0x13f8c0 already locked for write
E/libagl  (  768): eglSwapBuffers() failed to lock buffer 0x1368e0 (640x480)
E/SurfaceFlinger(  768): eglSwapBuffers: EGL error 0x3002 (EGL_BAD_ACCESS)
E/gralloc (  768): handle 0x13f8c0 not locked

Therefore I checked the libgralloc and adding some debug message. The libgralloc plugin 0xdroid used is branched from original eclair source tree. I took few hours created the omap3/libgralloc at the first day when I got eclair source code months ago. Since it works well for the most of time, I didn't pay too much attention to it, until I found the deadlock issue goes crazy on frozen bubble.
After noticing the lock log and swap error, I took a close look of the gralloc_lock and gralloc_unlock in hardware/omap3/libgralloc/mapper.c

int gralloc_lock(gralloc_module_t const* module,
        buffer_handle_t handle, int usage,
        int l, int t, int w, int h,
        void** vaddr)
{
    if (private_handle_t::validate(handle) < 0)
        return -EINVAL;

    int err = 0;
    private_handle_t* hnd = (private_handle_t*)handle;
    int32_t current_value, new_value;
    int retry;

    do {
        current_value = hnd->lockState;
        new_value = current_value;

        if (current_value & private_handle_t::LOCK_STATE_WRITE) {
            // already locked for write 
            LOGE("handle %p already locked for write", handle);
            return -EBUSY;
        } else if (current_value & private_handle_t::LOCK_STATE_READ_MASK) {
            // already locked for read
            if (usage & (GRALLOC_USAGE_SW_WRITE_MASK | GRALLOC_USAGE_HW_RENDER)) {
                LOGE("handle %p already locked for read", handle);
                return -EBUSY;
            } else {
                // this is not an error
                //LOGD("%p already locked for read... count = %d", 
                //        handle, (current_value & ~(1<<31)));
            }
        }

        // not currently locked
        if (usage & (GRALLOC_USAGE_SW_WRITE_MASK | GRALLOC_USAGE_HW_RENDER)) {
            // locking for write
            new_value |= private_handle_t::LOCK_STATE_WRITE;
        }
        new_value++;

        retry = android_atomic_cmpxchg(current_value, new_value, 
    } while (retry);

    if (new_value & private_handle_t::LOCK_STATE_WRITE) {
        // locking for write, store the tid
        hnd->writeOwner = gettid();
    }

    if (usage & (GRALLOC_USAGE_SW_READ_MASK | GRALLOC_USAGE_SW_WRITE_MASK)) {
        if (!(current_value & private_handle_t::LOCK_STATE_MAPPED)) {
            // we need to map for real
            pthread_mutex_t* const lock = &sMapLock;
            pthread_mutex_lock(lock);
            if (!(hnd->lockState & private_handle_t::LOCK_STATE_MAPPED)) {
                err = gralloc_map(module, handle, vaddr);
                if (err == 0) {
                    android_atomic_or(private_handle_t::LOCK_STATE_MAPPED,
                            (volatile int32_t*)&(hnd->lockState));
                }
            }
            pthread_mutex_unlock(lock);
        }
        *vaddr = (void*)hnd->base;
    }

    return err;
}

int gralloc_unlock(gralloc_module_t const* module, 
        buffer_handle_t handle)
{
    if (private_handle_t::validate(handle) < 0)
        return -EINVAL;

    private_handle_t* hnd = (private_handle_t*)handle;
    int32_t current_value, new_value;

    do {
        current_value = hnd->lockState;
        new_value = current_value;

        if (current_value & private_handle_t::LOCK_STATE_WRITE) {
            // locked for write
            if (hnd->writeOwner == gettid()) {
                hnd->writeOwner = 0;
                new_value &= ~private_handle_t::LOCK_STATE_WRITE;
            }
        }

        if ((new_value & private_handle_t::LOCK_STATE_READ_MASK) == 0) {
            LOGE("handle %p not locked", handle);
            return -EINVAL;
        }

        new_value--;

    } while (android_atomic_cmpxchg(current_value, new_value, 
            (volatile int32_t*)&hnd->lockState));

    return 0;
}

The code looks reasonably for the first look. Lock and unlock pair looks good. However there is a very tricky part "android_atomic_cmpxchg may fail". Understanding this, it is not hard to see there is a potential bug in gralloc_unlock. If android_atomic_cmpxchg fails, it will run the do while loop for more than once. However for the first run, the hnd->writeOwner will be changed to 0. And then the new_value will not be changed anymore. This lock will goes crazy here after.

The patch solves this problem.

diff --git a/mapper.cpp b/mapper.cpp
index 16ebcc2..1f3e722 100644
--- a/mapper.cpp
+++ b/mapper.cpp
@@ -267,13 +267,13 @@ int gralloc_unlock(gralloc_module_t const* module,
         if (current_value & private_handle_t::LOCK_STATE_WRITE) {
             // locked for write
             if (hnd->writeOwner == gettid()) {
-                hnd->writeOwner = 0;
                 new_value &= ~private_handle_t::LOCK_STATE_WRITE;
             }
         }
 
         if ((new_value & private_handle_t::LOCK_STATE_READ_MASK) == 0) {
             LOGE("handle %p not locked", handle);
+            hnd->writeOwner = 0;
             return -EINVAL;
         }
 
@@ -282,5 +282,6 @@ int gralloc_unlock(gralloc_module_t const* module,
     } while (android_atomic_cmpxchg(current_value, new_value, 
             (volatile int32_t*)&hnd->lockState));
 
+    hnd->writeOwner = 0;
     return 0;
 }

It make sure the value hnd->writeOwner is the same as the first loop, if android_atomic_cmpxchg fails.

This issue comes from the original eclair source tree, and it is still there, and had been inherited to many different platforms. If you encounter two frames crazily flipping and having the lock message, you may try to take a look of your libgralloc.

[備忘] RGB565 To PNG/JPEG

2009-12-14T15:03:00.000+08:00

竟然忘掉了… 寫在這備忘

ffmpeg -vcodec rawvideo -f rawvideo -pix_fmt rgb565 -s 1024x720 -i input.raw -f image2 -vcodec png output.png

Oprofile 0xdroid Android on Beagleboard

2009-10-13T14:05:00.013+08:00

Android supports oprofile actually. And you can play happily with that with some oprofile knowledge on G1. However the external/oprofile in Android does not support ARM_V7 for now. To play with it patch the following type and trigger support of ARM_V7


diff --git a/libop/op_cpu_type.c b/libop/op_cpu_type.c
index b9d13de..737f63e 100644
--- a/libop/op_cpu_type.c
+++ b/libop/op_cpu_type.c
@@ -74,6 +74,7 @@ static struct cpu_descr const cpu_descrs[MAX_CPU_TYPE] = {
  { "ppc64 POWER5++", "ppc64/power5++", CPU_PPC64_POWER5pp, 6 },
  { "e300", "ppc/e300", CPU_PPC_E300, 4 },
  { "AVR32", "avr32", CPU_AVR32, 3 },
+ { "ARM V7 PMNC", "arm/armv7", CPU_ARM_V7, 5}, 
 };
  
 static size_t const nr_cpu_descrs = sizeof(cpu_descrs) / sizeof(struct cpu_descr);
diff --git a/libop/op_cpu_type.h b/libop/op_cpu_type.h
index be95ae2..f4db260 100644
--- a/libop/op_cpu_type.h
+++ b/libop/op_cpu_type.h
@@ -72,6 +72,7 @@ typedef enum {
  CPU_PPC64_POWER5pp,  /**< ppc64 Power5++ family */
  CPU_PPC_E300, /**< e300 */
  CPU_AVR32, /**< AVR32 */
+ CPU_ARM_V7, /**< ARM V7 */
  MAX_CPU_TYPE
 } op_cpu;
 
diff --git a/libop/op_events.c b/libop/op_events.c
index b4a10e7..7f0ed25 100644
--- a/libop/op_events.c
+++ b/libop/op_events.c
@@ -793,6 +793,7 @@ void op_default_event(op_cpu cpu_type, struct op_default_event_descr * descr)
   case CPU_ARM_XSCALE2:
   case CPU_ARM_MPCORE:
   case CPU_ARM_V6:
+  case CPU_ARM_V7:
   case CPU_AVR32:
    descr->name = "CPU_CYCLES";
    break;
diff --git a/opimport_pull b/opimport_pull
index 7dbac4a..bf1f19a 100755
--- a/opimport_pull
+++ b/opimport_pull
@@ -1,4 +1,4 @@
-#!/usr/bin/python2.4 -E
+#!/usr/bin/python -E
 
 import os
 import re

And adding event tables for ARMv7


commit f129bca975b1704c06e07df7710d29de13a1e922
Author: Tick Chen <tick@0xlab.org>
Date:   Sat Sep 26 22:56:44 2009 +0800

[oprofile] adding metadata of armv7

diff --git a/linux-x86/oprofile/arm/armv7/events b/linux-x86/oprofile/arm/armv7/events
new file mode 100644
index 0000000..2550e41
--- /dev/null
+++ b/linux-x86/oprofile/arm/armv7/events
@@ -0,0 +1,53 @@
+# ARM V7 events
+# From Cortex A8 DDI (ARM DDI 0344B, revision r1p1)
+#
+event:0x00 counters:1,2,3,4 um:zero minimum:500 name:PMNC_SW_INCR : Software increment of PMNC registers
+event:0x01 counters:1,2,3,4 um:zero minimum:500 name:IFETCH_MISS : Instruction fetch misses from cache or normal cacheable memory
+event:0x02 counters:1,2,3,4 um:zero minimum:500 name:ITLB_MISS : Instruction fetch misses from TLB
+event:0x03 counters:1,2,3,4 um:zero minimum:500 name:DCACHE_REFILL : Data R/W operation that causes a refill from cache or normal cacheable memory
+event:0x04 counters:1,2,3,4 um:zero minimum:500 name:DCACHE_ACCESS : Data R/W from cache
+event:0x05 counters:1,2,3,4 um:zero minimum:500 name:DTLB_REFILL : Data R/W that causes a TLB refill
+event:0x06 counters:1,2,3,4 um:zero minimum:500 name:DREAD : Data read architecturally executed (note: architecturally executed = for instructions that are unconditional or that pass the condition code)
+event:0x07 counters:1,2,3,4 um:zero minimum:500 name:DWRITE : Data write architecturally executed
+event:0x08 counters:1,2,3,4 um:zero minimum:500 name:INSTR_EXECUTED : All executed instructions
+event:0x09 counters:1,2,3,4 um:zero minimum:500 name:EXC_TAKEN : Exception taken
+event:0x0A counters:1,2,3,4 um:zero minimum:500 name:EXC_EXECUTED : Exception return architecturally executed
+event:0x0B counters:1,2,3,4 um:zero minimum:500 name:CID_WRITE : Instruction that writes to the Context ID Register architecturally executed
+event:0x0C counters:1,2,3,4 um:zero minimum:500 name:PC_WRITE : SW change of PC, architecturally executed (not by exceptions)
+event:0x0D counters:1,2,3,4 um:zero minimum:500 name:PC_IMM_BRANCH : Immediate branch instruction executed (taken or not)
+event:0x0E counters:1,2,3,4 um:zero minimum:500 name:PC_PROC_RETURN : Procedure return architecturally executed (not by exceptions)
+event:0x0F counters:1,2,3,4 um:zero minimum:500 name:UNALIGNED_ACCESS : Unaligned access architecturally executed
+event:0x10 counters:1,2,3,4 um:zero minimum:500 name:PC_BRANCH_MIS_PRED : Branch mispredicted or not predicted. Counts pipeline flushes because of misprediction
+event:0x12 counters:1,2,3,4 um:zero minimum:500 name:PC_BRANCH_MIS_USED : Branch or change in program flow that could have been predicted
+event:0x40 counters:1,2,3,4 um:zero minimum:500 name:WRITE_BUFFER_FULL : Any write buffer full cycle
+event:0x41 counters:1,2,3,4 um:zero minimum:500 name:L2_STORE_MERGED : Any store that is merged in L2 cache
+event:0x42 counters:1,2,3,4 um:zero minimum:500 name:L2_STORE_BUFF : Any bufferable store from load/store to L2 cache
+event:0x43 counters:1,2,3,4 um:zero minimum:500 name:L2_ACCESS : Any access to L2 cache
+event:0x44 counters:1,2,3,4 um:zero minimum:500 name:L2_CACH_MISS : Any cacheable miss in L2 cache
+event:0x45 counters:1,2,3,4 um:zero minimum:500 name:AXI_READ_CYCLES : Number of cycles for an active AXI read
+event:0x46 counters:1,2,3,4 um:zero minimum:500 name:AXI_WRITE_CYCLES : Number of cycles for an active AXI write
+event:0x47 counters:1,2,3,4 um:zero minimum:500 name:MEMORY_REPLAY : Any replay event in the memory subsystem
+event:0x48 counters:1,2,3,4 um:zero minimum:500 name:UNALIGNED_ACCESS_REPLAY : Unaligned access that causes a replay
+event:0x49 counters:1,2,3,4 um:zero minimum:500 name:L1_DATA_MISS : L1 data cache miss as a result of the hashing algorithm
+event:0x4A counters:1,2,3,4 um:zero minimum:500 name:L1_INST_MISS : L1 instruction cache miss as a result of the hashing algorithm
+event:0x4B counters:1,2,3,4 um:zero minimum:500 name:L1_DATA_COLORING : L1 data access in which a page coloring alias occurs
+event:0x4C counters:1,2,3,4 um:zero minimum:500 name:L1_NEON_DATA : NEON data access that hits L1 cache
+event:0x4D counters:1,2,3,4 um:zero minimum:500 name:L1_NEON_CACH_DATA : NEON cacheable data access that hits L1 cache
+event:0x4E counters:1,2,3,4 um:zero minimum:500 name:L2_NEON : L2 access as a result of NEON memory access
+event:0x4F counters:1,2,3,4 um:zero minimum:500 name:L2_NEON_HIT : Any NEON hit in L2 cache
+event:0x50 counters:1,2,3,4 um:zero minimum:500 name:L1_INST : Any L1 instruction cache access, excluding CP15 cache accesses
+event:0x51 counters:1,2,3,4 um:zero minimum:500 name:PC_RETURN_MIS_PRED : Return stack misprediction at return stack pop (incorrect target address)
+event:0x52 counters:1,2,3,4 um:zero minimum:500 name:PC_BRANCH_FAILED : Branch prediction misprediction
+event:0x53 counters:1,2,3,4 um:zero minimum:500 name:PC_BRANCH_TAKEN : Any predicted branch that is taken
+event:0x54 counters:1,2,3,4 um:zero minimum:500 name:PC_BRANCH_EXECUTED : Any taken branch that is executed
+event:0x55 counters:1,2,3,4 um:zero minimum:500 name:OP_EXECUTED : Number of operations executed (in instruction or mutli-cycle instruction)
+event:0x56 counters:1,2,3,4 um:zero minimum:500 name:CYCLES_INST_STALL : Cycles where no instruction available
+event:0x57 counters:1,2,3,4 um:zero minimum:500 name:CYCLES_INST : Number of instructions issued in a cycle
+event:0x58 counters:1,2,3,4 um:zero minimum:500 name:CYCLES_NEON_DATA_STALL : Number of cycles the processor waits on MRC data from NEON
+event:0x59 counters:1,2,3,4 um:zero minimum:500 name:CYCLES_NEON_INST_STALL : Number of cycles the processor waits on NEON instruction queue or NEON load queue
+event:0x5A counters:1,2,3,4 um:zero minimum:500 name:NEON_CYCLES : Number of cycles NEON and integer processors are not idle
+event:0x70 counters:1,2,3,4 um:zero minimum:500 name:PMU0_EVENTS : Number of events from external input source PMUEXTIN[0]
+event:0x71 counters:1,2,3,4 um:zero minimum:500 name:PMU1_EVENTS : Number of events from external input source PMUEXTIN[1]
+event:0x72 counters:1,2,3,4 um:zero minimum:500 name:PMU_EVENTS : Number of events from both external input sources PMUEXTIN[0] and PMUEXTIN[1]
+event:0xFF counters:0 um:zero minimum:500 name:CPU_CYCLES : Number of CPU cycles
+
diff --git a/linux-x86/oprofile/arm/armv7/unit_masks b/linux-x86/oprofile/arm/armv7/unit_masks
new file mode 100644
index 0000000..02464a3
--- /dev/null
+++ b/linux-x86/oprofile/arm/armv7/unit_masks
@@ -0,0 +1,4 @@
+# ARM V7 PMNC possible unit masks
+#
+name:zero type:mandatory default:0x00
+    0x00 No unit mask

This way we can play oprofile on beagleboard already. But you cannot analysis it yet.
Because of that prebuild opreport does not supports ARM_v7. Therefore I downloaded and compile the oprofile 0.9.5. Replace those in prebuild, then we can analysis the data happily.

All of these stuff had been done in 0xdroid, therefore you can play directly with 0xdroid.
The default kernel released in http://downloads.0xlab.org/ currently does not set oprofile flags up therefore you will need to set them up and recompile it.


+ CONFIG_OPROFILE_ARMV7=y
+ CONFIG_OPROFILE=y
+ CONFIG_PROFILING=y
+ CONFIG_HAVE_OPROFILE=y
+ CONFIG_TRACEPOINTS=y

You can throw the vmlinux into a usb storage or SD card with VFAT partition as the first partition.

After booting up 0xdroid beagle-cupcake or beagle-donut, you can run


opcontrol —setup —event=CPU_CYCLES:15000:::1:1 \
—vmlinux=/sdcard/vmlinux \
—kernel-range=0xc0008000,0xcfffffff
echo 16 > /dev/oprofile/backtrace_depth

That will setup the oprofiled to trigger sampling for every 15000 clock cycles. The smaller CPU_CYCLES the more heavy loading of profiling and getting more details. The larger CPU_CYCLES the less detail we get and lower profiling loading.
When I am profiling the overhead of camera preview I found one interesting phenomenon. When I use 150000 as sampling CPU_CYCLES, it's about sampling 30 times per second. I cannot get anything meaningful with the sampling rate. This confused me for a while before I realize it's just about the same frame rate with camera. I always sampled at the same point. Therefore even if we samples a lot, the grid of sampling period should be much smaller than what you want to profile. We always may be blind to some samples. We should be aware of that, and we may need to change various CPU_CYCLES profiling the same topic to get more confidence of the result.

When you are ready to profile just enter


opcontrol --start

And then do whatever you want to profile.
Stop oprofile with


opcontrol --stop

After stopping oprofile, you can use a mini usb cable to download all the samples to the host machine, and analysis them.


On device:
1. plug in usb line between laptop and beagleboard (OTG port)
2. netcfg usb0 up
3. ifconfig usb0 192.168.0.202
On you host:
1. sudo ifconfig usb0 192.168.0.200 # beware nm-applet may breaks it, you can set it up.
2. export ADBHOST=192.168.0.202
3. export PATH={Where you put 0xdroid}/out/host/linux-x86/bin:$PATH
4. pkill adb
5. adb devices  # If you can see the device then you can do next step, or you may need to checkout what’s wrong.

Then:


cd {Where you put 0xdroid}
. build/envsetup.sh
setpaths
export OPROFILE_EVENTS_DIR=${PWD}/linux-x86/oprofile/
cd external/oprofile
./opimport_pull /tmp/0xdroid-oprofile

Copy your vmlinux to ${OUT}/symbols

Then you can analysis the whole symbols with


${OPROFILE_EVENTS_DIR}/bin/opreport --session-dir=/tmp/0xdroid-oprofile -p ${OUT}/symbols

After analyzing, we can use ooffice, graphvis, gnuplot, or whatever you like to rework the data. For example:

Happy profiling. :-)

murmur

2009-08-31T10:23:00.002+08:00

沒什麼，太久沒寫文章，發個聲，証明自已還活著。

今年是一個充滿挑戰的一年，從籌備到成立 0xlab，接受各式各樣的挑戰，同時面對各方面的問題。和一群優秀的人一起工作，做一堆沒人做過的事，真是刺激極了。

這幾個月的目標是建立一個大家可以一同工作的平台，從設備到開發流程的建立。在大家的努力之下，慢慢的把一些東西建立了起來。對內做了相當多的實驗，對外則是提出了一個可以和大家一同工作的軟體平台。第一次的 code drop 之中，把 beagle-cupcake 調到可以玩，可以快速共同開發，容易整合。準備把心中的 item 慢慢一個一個完成。

把基礎打好了，真正的挑戰才要開始。給自已加油，也為大家加油。

這幾個月中之，發現到自已體力上的極限。刻意的放慢自已的腳步，我們是要做長做久的，不可以一下子就把自已燒掉。小心小心切記切記。對於自已一些 FOSS 的案子，真是對使用者感到抱歉，只要有時間和體力，我就會回來看的。 XD

在 lab 進入軌道後，接下來最重要的目標反而是調整好自已：管理好自已的情緒，讓自已更快樂、給自已更多時間，早點下班，多運動，讓自已更健康、訓練自已的表達能力，讓自已更能夠清楚的表達出想法。

希望能給大家和自已一個更好的 Tick. XD

0xlab is opening

2009-04-27T00:28:00.004+08:00

0xlab looks very like 0x'1'ab and 0x1ab is 427. Therefore we choose this day to announce our lab. :)
http://0xlab.org

We are a group of software engineers who have strong passion in Free Open Source Software. We believe the power of knowledge and creativity, and we think we can do something very interesting and valuable.

Beagleboard demo

2009-03-29T23:51:00.003+08:00

Demo for the last four days developement.

[beagleboard hacking note] HDMI monitor

2009-03-29T03:14:00.005+08:00

I tried to use my LG TV as the monitor of beagleboard for three days, after some turning it works fine with Angstrom distribution. However, not in Android.
I tried to hacked around the driver/video/omap/lcd_omap3beagle.c but without successful. Just cannot see the Android screenshot. :(
After a long try, I almost sure every setting in my kernel is correct.And by checking the log, Android run very well. I thought it may be a problem from my TV, therefore I bring my beagle board to a 3C market and ask for testing a new HDMI monitor. It worked like a charm!! Oh my god, the LG TV waste a lot of my time. :( I bought that monitor without second though immediately.

Finally, I can play Android with my beagleboard. ：－）

From beagleboard

But it seem need some other hack to simulate the touch panel events. I am considering write a fake device and sending touch panel event to kernel. (Is that a good idea? I doubt. Any Idea?)

A tiny program read signal from rs232, and translate message to positions and write to a device, and that device triggers input event report of touch panel. XD Hmm.... It's a pure dirty hack. Any suggestion? I don't want to buy another touch panel. I already bought too many stuff. Orz...

murmuring

[beagleboard hacking note] OE references

2009-03-28T05:09:00.006+08:00

OE: openembedded a very powerful and complex build system.
beagleboard google code beagleboard info and download center.
Angstrom Distribution a good embedded distribution maintained by Koen, and that is what I am mainly used, and hacking on.

DSS reference a very good document to control the omap fbs

my local.conf of building beagleboard demo image

Filename: local.conf


MACHINE = "beagleboard"
DISTRO = "angstrom-2008.1"
BUILD_ARCH = "x86_64"
#INHERIT += "rm_work"
PARALLEL_MAKE = "-j 3"
BB_NUMBER_THREADS = "1"
TMPDIR = "/home/tick/OE/build/tmp"
BBFILES := "/home/tick/OE/openembedded/recipes/*/*.bb"

> bitbake beagleboard-demo-image
and have fun

[beagleboard hacking note] Bluetooth network

2009-03-28T04:42:00.004+08:00

Because of using USB OTG mode, connecting beagleboard with keyboard and mouse. I cannot use usb0 as ethernet card. Therefore, I can use bluetooth dongle to simulate ethernet card.

1. modify the kernel configure, to allow usb bluetooth dongle works.
@@ -455,7 +455,7 @@ CONFIG_BT_HIDP=y
#
# Bluetooth device drivers
#
-# CONFIG_BT_HCIBTUSB is not set
+CONFIG_BT_HCIBTUSB=y
CONFIG_BT_HCIBTSDIO=y
# CONFIG_BT_HCIUART is not set
CONFIG_BT_HCIBCM203X=y

2. After boot, plug the dongle.
determin if bluetooth device detected or not.
> hcitool dev
scan surrounding bluetooth devices
> hcitool scan
If everything goes fine, we can try to connect bluetooth devices (e.g. mouse)

3. make your laptop a network access point (NAP) a very good document you should check
On your laptop with bluetooth RF on
a. turn off /etc/init.d/bluetooth
> /etc/init.d/bluetooth stop
b. modprobe bnep
c. pand -s -r NAP
On beagleboard:
a. finding the baddr of your laptop
> hcitool scan
b.connect to your laptop
>pand -c XX:XX:XX:XX:XX:XX:XX
c. Setup your beagleboard network
> ifconfig bnep0 192.168.0.202
> route add default gw 192.168.0.200
d. On your laptop set, let your laptop becomes an NAT gateway:
> ifconfig bnep0 192.168.0.200
> echo 1 > /proc/sys/net/ipv4/ip_forward
> iptables -t nat -A POSTROUTING -s 192.168.0.0/24 -j MASQUERADE
Enjoy the wireless network :-)

[beagleboard hacking note] USB OTG line

2009-03-28T04:31:00.003+08:00

Beagleboard supports USB OTG mode, however beagleboard cannot run OTG mode with normal 5 pin mini USB lines.

It needs to short pin 4 and 5. and so that you can play with OTG mode. Therefore I bought a B type mini usb line and remove the cover and short pin 4 and 5, and I can play with OTG mode happily.

From beagleboard

BTW, beagleboard can play as client with normal mini usb to USB A line as ethernet card. (USB0)

[beagleboard hacking note] Null modem

2009-03-28T03:49:00.005+08:00

The first step of hacking beagleboard. You need to connect to beagleboard first.
．You will need a null modem line to connect beagleboard RS232 port and your PC.

My way is very straight forward: just buy a USB to RS232 line, three thin wires, one 2.5mm 5x2 pin slot, and a RS232 female head.

From beagleboard

Actually you only need to connect three wires, pin2 pin3 and pin5, and remember switch pin 2 and 3. Check here!

After made the line for beagleboard, you can use cu , minicom, or even screen to connect beagleboard. Baud rate is 115200n8.

From beagleboard

Therefore you can access the beagleboard u-boot and console.

Taipei App Engine Sprint 2009

2009-03-15T13:04:00.010+08:00

感謝 Ping 的邀請，我們團隊的其中三人昨天去 Google 玩了一整天。
也做了一個小玩具（我就知道大家會把它拿來找正妹）和大家分享。
享受了腦力激盪、高速開發及實踐想像力的快感。
當然，也吃了過量的 Hogan Doz，和鼎泰豐。
感謝 Google Taipei 舉辦這個好玩的活動。
對我們來說是一次非常好的經驗。

感謝大家的欣賞我們的作品和團員之間的無間合作，很高興得到了比賽的第一名。
特別感謝昨日加入我們的 Denial ，補足了我們在於 Web design 經驗上的不足。
畢竟，一群做 Linux Embedded System 的人突然跑來玩 Web，缺乏相當多的 domain knowledge。

昨天不只一次被問到：你們是如何做到一天之內衝出一個網站的？你們是如何分工的？

其實這也道出了相當多人的相同問題。
這個問題回家想了很後，其實我的答案還是：團隊合作。

事實上大家都知道團隊合作的重要性，可是不知道如何做到。
其實，我個人認為這是沒有標準答案的。

試著把自已的想法寫下來，供自已分析和與大家分享。

人最重要：
當初決定留在台灣，就是抱著一個願望：在台灣，打造出一個有國際一流水準的軟體團隊。
我個人對於自已的 career path 的許多重大決定也是為了完成這個夢想。
很幸運的，在多年的尋覓之後，我們找到了一些有共同想法的伙伴，一群想追求一流而且真的很努力的 FOSS developer 找到了彼此，組成團隊。

事實上，我們之中的任何一個人，都是可以獨當一面的軟體工程師，技術能力也和歐美 hackers 同步。但我們也相當了解，在現在的軟體世界中，要和世界一流的團隊比，我們每個人的時間體力和專長真的不夠多。要真的做出什麼，我們必需互相信賴。
每一個人的專長都不相同，興趣領域也不同，不過都有所專精。
最重要的，信任和分享是我們相當大的特色。

John 特色擅長於洞悉情勢，有相當驚人的觀察力，對問題提出精確的看法
Tick 擅長結構性的思考，演算法選用，軟體系統架構分析和軟體風險估計及開發
Olv 對於新技術的理解能力一流，對於面對的技術可以快速的確實掌握
Erin 擅長提出破壞性思考，提供大家不同面向的思考和刺激
Jeremy 擅長把任務完成，面對問題可提出相當好的分析和實作
Julian 擅長於感性的思考，為技術帶來來自外太空的創意和美感

昨天是 Olv, Erin 和我三人受邀參加活動。面對這個題目，三人對於 App engine 各自 survey 結束後，我們開了一次的 brain storm meeting。我可以對不同題目所需要的技術可以快速的提供 scope 和風險分析，而 Erin 提出了相當多很有意思的想法和 Idea，Olv 很快速的理解問題的核心並提出更進一步的看法。當 Erin 說出 "依時間搜尋照片" 七個字時，我和 Olv 兩人都突然不說話了，思考著這個 idea 的可能性。害 Erin 以為這個 idea 不好。我和 Olv異口同聲的說出，“不，這個 idea 很棒。” 是的，這個題目的可能性很高，還不知有人做過，資料相依性應該很高，也是我們能力所及的。
再來就依著這個題目開始做了各種可能性的 brain storm。這是一個我們三個人一天可以做完的題目，我列出這個題目及各種可能性所需的所有技術項目，針對各個項目提出可選擇的技術和風險分析，Olv 針對著這題目提出許多更進一步的看法，和可能性。我們最大的風險是，我們沒有 html 和 javascript 的專長。
題目和項目決定後，我提出一個可以從很小很小的結構開始長大的軟體架構提出 API，把所有問題切成小塊小塊的，並立刻把 framework 實作出來。一個小時後， Olv 和 Erin 就可以進入開發，大約在兩個小時內，我們已經進入遞迴開發的階段，我維持軟體架構的彈性，Olv 神快的把每個小問題解掉，並找出我沒有想清楚的地方提出漂亮的修正。
很幸運的，昨天在活動中找到了一位 web 的開發者 Denial 加入我們的開發，對於 html 及javascript 的風險立刻變得相當的低。活動開始後，我們立刻把開發環境架好，開始把針對 web 這方面開始開發。並提出每個項目完成優先順續，和重要性，並把工作分配下去。在開發中，我們快速的交換各自分配到的 topic 所學到的 infomation。提出問題，和分享自已所了解的東西。其中“腦力激盪、分析、尋找答案、提出想法、實作”是不停的約以一個小時為週期巡迴發生。開始兩個多小時後我分配到的部份就做完了，過沒多久 Olv 的部份也實作完成，再來就開始把 nice to have 的部份一一補上，測試，美化以及互相 support。幫忙把沒做完的地方做出來。
因為得到了 Denial 的技術支援，和 Google Jeff 的 information sharing，我們做出來的比
本來估三人個可以做到的部份還要多。還把本來列為 nice to have 的地理資訊部份實作了出來。Olv 在完成工作後，也開始發揮幽默，把我們本來很工程師的形式的網頁改寫成山寨 Google theme。最後兩小時，大家全力衝刺收尾和 javascript 的部份。

這也是我們團隊成員第一次一起參加這種限時的軟體比賽，証明了我們的團隊能力，對於我們團隊有相當大鼓舞作用，也一再的讓我們深深的體會到，雖然每個人的能力都很不錯，如果能團隊運作起來威力是加乘的。

最後，感謝 Google 舉辦這個活動，和大家的欣賞。

Eagle outside my window!

2009-01-12T16:41:00.006+08:00

When I was thinking about an algorithm of project at home. I heard some noise just outside the window. All my cats were rushing around like crazy. After some while, the noise does not stop, and I decide to take a look about that. I was stunned by what I saw. An eagle is just standing out side my window, eating a dove!! I live in Taipei, a mega-city without eagle for a long long time. When I was a boy, I live in the suburb of a small city, Chai-Yi, there were always eagle on the sky. I have not seen eagle in nature for a long time since I move to Taipei.
Suddenly, a eagle is standing out side my window. I am so surprised about this. Maybe the environment is getting better gradually.
It eyes are so beautiful, I have never observe an eagle so closely, less the 1 meteor. But while it's eating, it remind me it's a hunter. It can kill my cats easily with it's claw. This point made me a little bit nervous. Anyway beside of this, I am very happy to see an eagle out side the window.

My color

2009-01-02T14:38:00.001+08:00

Your rainbow is shaded blue.

What is says about you: You are a tranquil person. You appreciate friends who get along with one another. You share hobbies with friends and like trying to fit into their routines.

Find the colors of your rainbow at spacefem.com.

還蠻妙的~

墨子

2008-12-27T20:47:00.008+08:00

近來看到了一些事。感謝友人介紹墨子給我。以古鑒今，讀得我汗流直下…不得不佩服古人的智慧，真的是真知灼見。歷史果然是以不同的面貌一再重演。今日看著一些人花了大把大把的銀子，得到的卻是一個謊言。雖然花了很多工夫來說服自己，這些是別人的錢，而且這也不在手臂範圍內，在自己的範圍內對得起自己，對得起投資人。投資人也不是笨蛋，如果事態這麼明顯了還看不出來，他們自己就要承受風險。看著台灣投資人的錢就這樣的被糟蹋，揮霍，心裏相當的難過。
一場大卡司的真實戲碼在眼前上映著，一面難過著一個看似美好的機會在眼前破滅, 也一面慶興著自己在年輕之時就可以上到這麼昂貴的一課，學到相當寶貴的經驗。更加了解在夢想這條路上有那些陷阱，和風險。在這場大卡司的戲碼中，看著一個有理想有才華的人被小人包圍，看著他的恐懼、看著他逃避、封閉自我、在精神上吸毒、不停的欺騙、最後沉淪，變得和他身旁的人沒兩樣。我們雖然被一些人欺騙、惡搞、看似受害者，雖然我們幫不上什麼忙，在這恐怖的經驗之中替他感到痛心，替投資時間、金錢於他的人感到可惜，也學得深刻的教訓，也許能保持自我且依然年輕的我們才是最大的受益者。

這讓我想起了第一份工作的公司所標榜的企業精神："誠信正直"。真的說得很好。

夢想讓我們充滿熱情、創意讓我們與眾不同、技術讓我們拿到門票、運氣讓我們得以進入門檻，而要真正的成功：“誠信正直” 真的很重要。

這真的很難，也很重要。我想…成功的人那麼少，也許就是要真正落實實在太難了吧，不然也不用拿出來標榜。
修鍊、修鍊…

國高中時，完全不讀不下去的古文。沒想到在經歷了一些事之後，讀起來卻是異常的深刻…熟悉…
念書、念書…

墨子、卷一

親士
入國而不存其士，則亡國矣。見賢而不急，則緩其君矣。非賢無急，非士無與慮國，緩賢忘士而能以其國存者，未曾有也。

昔者文公出走而正天下，桓公去國而霸諸侯，越王句踐遇吳王之醜，而尚攝中國之賢君。三子之能達名成功於天下也，皆於其國抑而大醜也。太上無敗，其次敗而有以成，此之謂用民。

吾聞之曰：“非無安居也，我無安心也。非無足財也，我無足心也。”是故君子自難而易彼，眾人自易而難彼，君子進不敗其志，內究其情，雖雜庸民，終無怨心，彼有自信者也。是故為其所難者，必得其所欲焉，未聞為其所欲，而免其所惡者也。是故偪臣傷君，諂下傷上。君必有弗弗之臣，上必有詻詻之下。分議者延延，而支苟者詻詻，焉可以長生保國。

臣下重其爵位而不言，近臣則喑，遠臣則唫，怨結於民心，諂諛在側，善議障塞，則國危矣。桀紂不以其無天下之士邪？殺其身而喪天下。故曰：“歸國寶，不若獻賢而進士。

今有五錐，此其銛，銛者必先挫。有五刀，此其錯，錯者必先靡，是以甘井近竭，招木近伐，靈龜近灼，神蛇近暴。是故比干之殪，其抗也；孟賁之殺，其勇也；西施之沈，其美也；吳起之裂，其事也。故彼人者，寡不死其所長，故曰：“太盛難守也。”

故雖有賢君，不愛無功之臣；雖有慈父，不愛無益之子。是故不勝其任而處其位，非此位之人也；不勝其爵而處其祿，非此祿之主也。良弓難張，然可以及高入深；良馬難乘，然可以任重致遠；良才難令，然可以致君見尊。是故江河不惡小谷之滿己也，故能大。聖人者，事無辭也，物無違也，故能為天下器。是故江河之水，非一水之源也。千鎰之裘，非一狐之白也。夫惡有同方取不取同而已者乎？蓋非兼王之道也。是故天地不昭昭，大水不潦潦，大火不燎燎，王德不堯堯者，乃千人之長也。

其直如矢，其平如砥，不足以覆萬物，是故溪陝者速涸，逝淺者速竭，墝埆者其地不育。王者淳澤不出宮中，則不能流國矣。

修身
君子戰雖有陳，而勇為本焉。喪雖有禮，而哀為本焉。士雖有學，而行為本焉。是故置本不安者，無務豐末。近者不親，無務來遠。親戚不附，無務外交。事無終始，無務多業。舉物而闇，無務博聞。

是故先王之治天下也，必察邇來遠，君子察邇而邇脩者也。見不脩行，見毀，而反之身者也，此以怨省而行脩矣。譖慝之言，無入之耳，批扞之聲，無出之口，殺傷人之孩，無存之心，雖有詆訐之民，無所依矣。

是故君子力事日彊，願欲日逾，設壯日盛。君子之道也，貧則見廉，富則見義，生則見愛，死則見哀。四行者不可虛假，反之身者也。藏於心者，無以竭愛。動於心者，無以竭恭。出於口者，無以竭馴。暢之四支，接之肌膚，華髮隳顛，而猶弗舍者，其唯聖人乎！

志不彊者智不達，言不信者行不果。據財不能以分人者，不足與友。守道不篤，偏物不博，辯是非不察者，不足與游。本不固者末必幾，雄而不脩者，其後必惰，源濁者流不清，行不信者名必秏。名不徒生而譽不自長，功成名遂，名譽不可虛假，反之身者也。務言而緩行，雖辯必不聽。多力而伐功，雖勞必不圖。慧者心辯而不繁說，多力而不伐功，此以名譽揚天下。言無務多而務為智，無務為文而務為察。故彼智無察，在身而情，反其路者也。善無主於心者不留，行莫辯於身者不立。名不可簡而成也，譽不可巧而立也，君子以身戴行者也。思利尋焉，忘名忽焉，可以為士於天下者，未嘗有也。

所染
子墨子言見染絲者而嘆曰：“染於蒼則蒼，染於黃則黃。所入者變，其色亦變。五入必而已，則為五色矣。故染不可不慎也。”

非獨染絲然也，國亦有染。舜染於許由、伯陽、禹染於皋陶、伯益，湯染於伊尹、仲虺，武王染於太公、周公。此四王者所染當，故王天下，立為天子，功名蔽天地。舉天下之仁義顯人，必稱此四王者。

夏桀染於干辛、推哆，殷紂染於崇侯、惡來，厲王染於厲公長父、榮夷終，幽王染於傅公夷、蔡公穀。此四王者所染不當，故國殘身死，為天下僇。舉天下不義辱人，必稱此四王者。

齊桓染於管仲、鮑叔，晉文染於舅犯、高偃，楚莊染於孫叔、沈尹，吳闔閭染於伍員、文義，越句踐染於范蠡大夫種。此五君者所染當，故霸諸侯，功名傅於後世。

范吉射染於長柳朔、王胜，中行寅染於籍秦、高彊，吳夫差染於王孫雒、太宰嚭，智伯搖染於智國、張武，中山尚染於魏義、偃長，宋康染於唐鞅、佃不禮。此六君者所染不當，故國家殘亡，身為刑戮，宗廟破滅，絕無後類，君臣離散，民人流亡。舉天下之貪暴苛擾者，必稱此六君也。

凡君之所以安者，何也？以其行理也，行理性於染當。故善為君者，勞於論人，而佚於治官。不能為君者，傷形費神，愁心勞意，然國逾危，身逾辱。此六君者，非不重其國，愛其身也，以不知要故也。不知要者，所染不當也。

非獨國有染也，士亦有染。其友皆好仁義，淳謹畏令，則家日益，身日安，名日榮，處官得其理矣，則段干木、禽子、傅說之徒是也。其友皆好矜奮，創作比周，則家日損，身日危，名日辱，處官失其理矣，則子西、易牙、豎刀之徒是也。《詩》曰：“必擇所堪。”必謹所堪者，此之謂也。

法儀
子墨子曰：“天下從事者，不可以無法儀，無法儀而其事能成者無有也。雖至士之為將相者，皆有法，雖至百工從事者，亦皆有法。百工為方以矩，為圓以規，衡以水，直以繩，正以縣。無巧工、不巧工，皆以此五者為法。巧者能中之，不巧者雖不能中，放依以從事，猶逾己。故百工從事，皆有法所度。”

今大者治天下，其次治大國，而無法所度，此不若百工辯也。然則奚以為治法而可？當皆法其父母，奚若？天下為父母者眾，而仁者寡，若皆法其父母，此法不仁也。法不仁不可以為法，當皆法其學，奚若？天下之為學者眾，而仁者寡，若皆法其學，此法不仁也。法不仁不可以為法，當皆法其君，奚若？天下之為君者眾，而仁者寡，若皆法其君，此法不仁也。法不仁不可以為法。故父母、學、君三者，莫可以為治法。

然則奚以為治法而可？故曰莫若法天。天之行廣而無私，其施厚而不德，其明久而不衰，故聖王法之。既以天為法，動作有為，必度於天，天之所欲則為之，天所不欲則止。然而天何欲何惡者也？天必欲人之相愛相利，而不欲人之相惡相賊也。奚以知天之欲人之相愛相利，而不欲人之相惡相賊也？以其兼而愛之，兼而利之也。奚以知天兼而愛之，兼而利之也？以其兼而有之，兼而食之也。

今天下無大小國，皆天之邑也。人無幼長貴賤，皆天之臣也。此以莫不犓羊牛、豢犬豬，絜為酒醴粢盛，以敬事天，此不為兼而有之，兼而食之邪？天苟兼而有食之，夫奚說以不欲人之相愛相利也？故曰：“愛人利人者，天必福之，惡人賊人者，天必禍之。”曰：“殺不辜者，得不祥焉。夫奚說人為其相殺而天與禍乎？是以知天欲人相愛相利，而不欲人相惡相賊也。”

昔之聖王禹、湯、文、武，兼愛天下之百姓，率以尊天事鬼，其利人多，故天福之，使立為天子，天下諸侯皆賓事之。暴王桀、紂、幽、厲，兼惡天下之百姓，率以詬天侮鬼。其賊人多，故天禍之，使遂失其國家，身死為僇於天下。後世子孫毀之，至今不息。故為不善以得禍者，桀、紂、幽、厲是也。愛人利人以得福者，禹、湯、文、武是也。愛人利人以得福者有矣，惡人賊人以得禍者亦有矣！

七患
子墨子曰：國有七患。七患者何？城郭溝池不可守而治宮室，一患也。邊國至境四鄰莫救，二患也。先盡民力無用之功，賞賜無能之人，民力盡於無用，財寶虛於待客，三患也。仕者持祿，游者愛佼，君脩法討臣，臣懾雨不敢拂，四患也。君自以為聖智而不問事，自以為安彊而無守備，四鄰謀之不知戒，五患也。所信不忠，所忠不信，六患也。畜種菽粟不足以食之，大臣不足以事之，賞賜不能喜，誅罰不能威，七患也。以七患居國，必無社稷；以七患守城，敵至國傾。七患之所當，國必有殃。

凡五穀者，民之所仰也，君之所以為養也。故民無仰則君無養，民無食則不可事。故食不可不務也，地不可不力也，用不可不節也。五穀盡收，則五味盡御於主，不盡收則不盡御。一穀不收謂之饉，二穀不收謂之旱，三穀不收謂之凶，四穀不收謂之餽，五穀不收謂之饑。歲饉，則仕者大夫以下皆損祿五分之一。旱，則損五分之二。凶則損五分之三。餽，則損五分之四。饑，則盡無祿，稟食而已矣。故凶饑存乎國，人君徹鼎食五分之三，大夫徹縣，士不入學，君朝之衣不革制，諸侯之客，四鄰之使，雍飧而不盛，徹驂騑，塗不芸，馬不食粟，婢妾不衣帛，此告不足之至也。

今有負其子而汲者，隊其子於井中，其母必從而道之。今歲凶，民饑道餓，重其子此疚於隊，其可無察邪？故時年歲善，則民仁且良；時年歲凶，則民吝且惡。夫民何常此之有？為者疾，食者眾，則歲無豐。故曰：“財不足則反之時，食不足則反之用。”故先民以時生財，固本而用財，則財足。故雖上世之聖王，豈能使五穀常收而旱水不至哉？然而無凍餓之民者，何也？其力時急而自養儉也。故《夏書》曰：“禹七年水。”《殷書》曰：“湯五年旱。”此其離凶餓甚矣。然而民不凍餓者，何也？其生財密，其用之節也。

故倉無備粟，不可以待凶饑；庫無備兵，雖有義不能征無義；城郭不備全，不可以自守；心無備慮，不可以應卒。是若慶忌無去之心，不能輕出。夫桀無待湯之備，故放；紂無待武之備，故殺。桀、紂貴為天子，富有天下，然而皆滅亡於百里之君者，何也？有富貴而不為備也。故備者，國之重也；食者，國之寶也；兵者，國之爪也。城者所以自守也。此三者國之具也。

故曰：以其極賞，以賜無功，虛其府庫，以備車馬、衣裘、奇怪，苦其役徒，以治宮室觀樂；死又厚為棺槨，多為衣裘。生時治臺榭，死又脩墳墓。故民苦於外，府庫單於內，上不厭其樂，下不堪其苦。故國離寇敵則傷，民見凶饑則亡，此皆備不具之罪也。且夫食者，聖人之所寶也。故《周書》曰：“國無三年之食者，國非其國也；家無三年之食者，子非其子也。”此之謂國備。

辭過
子墨子曰：古之民，未知為宮室時，就陵阜而居，穴而處，下潤濕傷民，故聖王作為宮室。為宮室之法，曰：室高足以辟潤濕，邊足以圉風寒，上足以待雪霜雨露，宮牆之高，足以別男女之禮，謹此則止。凡費財勞力，不加利者，不為也。役，脩其城郭，則民勞而不傷；以其常正，收其租稅，則民費而不病。民所苦者非此也，苦於厚作斂於百姓。是故聖王作為宮室，便於生，不以為觀樂也。作為衣服帶履，便於身，不以為辟怪也，故節於身，誨於民，是以天下之民可得而治，財用可得而足。

當今之主，其為宮室則與此異矣。必厚作斂於百姓，暴奪民衣食之財，以為宮室，臺榭曲直之望，青黃刻鏤之飾。為宮室若此，故左右皆法象之，是以其財不足以待凶饑、振孤寡，故國貧而民難治也。君實欲天下之治，而惡其亂也，當為宮室不可不節。

古之民，未知為衣服時，衣皮帶茭，冬則不輕而溫，夏則不輕而凊。聖王以為不中人之情，故作誨婦人治絲麻，梱布絹，以為民衣。為衣服之法：冬則練帛之中，足以為輕且暖；夏則絺綌之中，足以為輕且凊，謹此則止。故聖人之為衣服，適身體和肌膚而足矣。非榮耳目而觀愚民也。當是之時，堅車良馬不知貴也，刻鏤文采，不知喜也。何則？其所道之然。故民衣食之財，家足以待旱水凶饑者，何也？得其所以自養之情，而不感於外也。是以其民儉而易治，其君用財節而易贍也。府庫實滿，足以待不然。兵革不頓，士民不勞，足以征不服。故霸王之業，可行於天下矣。

當今之主，其為衣服則與此異矣，冬則輕煥，夏則輕凊，皆已具矣。必厚作斂於百姓，暴奪民衣食之財，以為錦繡文采靡曼之衣，鑄金以為鉤，珠玉以為珮，女工作文采，男工作刻鏤，以為身服，此非云益煥之情也。單財勞力，畢歸之於無用也，以此觀之，其為衣服非為身體，皆為觀好，是以其民淫僻而難治，其君奢侈而難諫也。夫以奢侈之君，御妤淫僻之民，欲國無亂，不可得也。君實欲天下之治而惡其亂，當為衣服不可不節。

古之民未知為飲食時，素食而分處，故聖人作誨男耕稼樹藝，以為民食。其為食也，足以增氣充虛，彊體適腹而巳矣。故其用財節，其自養儉，民富國治。今則不然，厚作斂於百姓，以為美食芻豢，蒸炙魚鱉，大國累百器，小國累十器，前方丈，目不能遍視，手不能遍操，口不能遍味，冬則凍冰，夏則餲饐，人君為飲食如此，故左右象之。是以富貴者奢侈，孤寡者凍餒，雖欲無亂，不可得也。君實欲天下治而惡其亂，當為食飲，不可不節。

古之民未知為舟車時，重任不移，遠道不至，故聖王作為舟車，以便民之事。其為舟車也，完固輕利，可以任重致遠，其為用財少，而為利多，是以民樂而利之。故法令不急而行，民不勞而上足用，故民歸之。

當今之主，其為舟車與此異矣。完固輕利皆已具，必厚作斂於百姓，以飾舟車。飾車以文采，飾舟以刻鏤，女子廢其紡織而脩文采，故民寒。男子離其耕稼而脩刻鏤，故民饑。人君為舟車若此，故左右象之，是以其民饑寒並至，故為姦邪。姦邪多則刑罰深，刑罰深則國亂。君實欲天下治而惡其亂，當為舟車，不可不節。

凡回於天地之間，包於四海之內，天壤之情，陰陽之和，莫不有也，雖至聖不能更也。何以知其然？聖人有傳：天地也，則曰上下；四時也，則曰陰陽；人情也，則曰男女；禽獸也，則曰牡牝雄雌也。真天壤之情，雖有先王不能更也。雖上世至聖，必蓄私，不以傷行，故民無怨。宮無拘女，故天下無寡夫。內無拘女，外無寡夫，故天下之民眾。當今之君，其蓄私也，大國拘女累千，小國累百，是以天下之男多寡無妻，女多拘無夫，男女失時，故民少。君實欲民之眾而惡其寡，當蓄私不可不節。

凡此五者，聖人之所儉節也，小人之所淫佚也。儉節則昌，淫佚則亡，此五者不可不節。夫婦節而天地和，風雨節而五穀孰，衣服節而肌膚和。

三辯
程繁問於子墨子曰：“夫子曰：‘聖王不為樂’，昔諸侯倦於聽治，息於鐘鼓之樂；士大夫倦於聽治，息於竽瑟之樂；農夫春耕、夏耘、秋斂、冬藏，息於瓴缶之樂。今夫子曰：‘聖王不為樂’，此譬之猶馬駕而不稅，弓張而不弛，無乃非有血氣者之所不能至邪？”

子墨子曰：“昔者堯舜有茅茨者，且以為禮，且以為樂。湯放桀於大水，環天下自立以為王，事成功立，無大後患，因先王之樂，又自作樂，命曰《護》，又脩《九招》。武王勝殷殺紂，環天下自立以為王，事成功立，無大後患，因先王之樂，又自作樂，命曰《象》。周成王因先王又自作樂，命曰《騶虞》。周成王之治天下也，不若武王。武王之治天下也，不若成湯。成湯之治天下也，不若堯舜。故其樂逾繁者，其治逾寡。自此觀之，樂非所以治天下也。”

程繁曰：“子曰：‘聖王無樂’。此亦樂已，若之何其謂聖王無樂也？”子墨子曰：“聖王之命也，多寡之。食之利也，以知饑而食之者智也，因為無智矣。今聖有樂而少，此亦無也。”

迷人的 git

2008-12-14T22:39:00.014+08:00

如果你常常寫 code，一定會遇到一種情況：寫改目前會動的 code，又怕會改壞…這時，就是 SCM (Source Code Management) 程式的時候了。

前一陣子，不知怎麼的，好幾個朋友問我，他們公司/專案要選 SCM，要選用那一個呢？

SCM 百百種… CVS SVN SVK Monotone bitkeeper git etc. etc.
要用那一個比較好呢？

在過去…我會說 SVN， SVN 比 CVS 方便多了，流水號的機制讓開發過程相當的清晰。
現在我強烈推薦 git
自從用了 git 之後～我已經離不開 git 了…

為什麼呢？
1. 因為我用 notebook 寫 code，這表示我可能會在辦公室寫，在家寫，睡不著時在床上寫，在無聊的會議中寫，在坐車時寫，在山林中寫… 而且我寫的東西大多要merge 回 upstream。可是很多地方是沒有網路的。或是網路不好…如果我用SVN 的話…就必需開始用 quilt寫 patch 了…管理 Code 變得相當的麻煩。
Git 是一個分散式的 SCM，也就是在你目前工作的環境下，就是一個完整的 source code repository. 當你從網路上用 git 抓下 code 的同時，你已經把完整的開發 tree 抓回來，放在你的電腦之中了…而 commit code 時也是 commit 到你 local 端之中。所以你就可以一直寫，到處寫，直到你有網路之時再一次 push 回去…
2. 我很愛改 Code，而 git 的版本管理是用 patch 做出來的，也就是說 branch 會變得相當的容易。當我想做任何風險較大的變動時，可以先開一個 branch 出來，在裏面惡搞一翻。如果結果不錯的話，就 merge 回主要的 branch。
3. git 超級快，因為 git 把所有的 patch 都抓回來了，要做 diff ，翻 log 就變成超級快速而且穩定的事。
4. 支援 SVN 和 CVS，git-svn 可以把 svn 之中的所有 commit 變成 git 之中的一個 branch。
也就是不管upstream 用的是 SVN or CVS ，我都可以用 git 來管理。事實上，還有一些更好玩的玩法。
5. SHA1-hash 的版本管理方式，讓 git 跳脫 SVN 之類強烈線性的版本管理…可以 rebase, cherry-pick ...
6. 開始一個 repository 超級方便，git init 就好了

Anyway 說了這麼多好處…怎麼用呢？就先給 link 嘍…
戒色夫 "我愛 Git"
Git User manual

我不打算在這寫另一個 manual 就寫幾個個人覺得很實用的 use cases.
1．做實驗
當你的 master branch 可以 run，但你想要對某個演算法大修時…
a. git checkout -b test_xxxx
b. 大修你的演算法…且做細部的 commit，直到完成
c. git checkout master 回到本來的 master
d. git pull 把再新的 master 拉回來
e. git checkout test_xxxx
f. git rebase master 把再新的 master commit rebase 上去…可能會要解 conflict
(c, d, e, f, 可變成 git fetch origin/master; git rebase -i origin/master)
g. git checkout master
h.1 git rebase test_xxxx 把 test_xxxx 的東西再 rebase 過來
h.2 git cherry-pick xxxxxx 把某個 patch 挑過來
i. git push 把修改送回main stream

2．用 git-svn 搬 SVN repository
如 project P 要從 repository A 搬到 B 玩法如下
a. mkdir A_svn; pushd A_svn; git svn init http://A/trunk/ ;git svn fetch; popd
b git clone file://`pwd`/A_svn B_svn
c. cd B_svn; git svn init http://B/trunk/
d. git checkout -b master_tmp
e. git svn init http://B/trunk/ ; git svn fetch
f. git checkout -b svn --track git-svn
g. git checkout master; git rebase svn
h. git-rev-list master_tmp (suppose the last line is 532d2f35aa73331d409475efa84c00a1afa0e1a0)
i. git svn set-tree 532d2f35aa73331d409475efa84c00a1afa0e1a0
j. git rebase master_tmp; git svn dcommit

3. 粉飾太平
當 git commit 了一些笨笨的 code
可以用 git rebase -i xxxx 來拿掉/合並一些 commit

心目中的 Linux development 課程建議

2008-11-03T17:06:00.006+08:00

早上讀了一封某國立大學資訊系教授的信，百感交集。也不想評論些什麼…
就說說自已的想法罷了
我個人覺得，一個活在 AC 2008 Embedded GNU/Linux Software Developer 要會以下一些東西。
我認為…這只是基礎。這些會了，再來談創意…
光是空想，手上沒有工具，或是有工具不會用…只是白搭。

技術方面
* C programming
-- study forever...
-- Learning how to tracing code - Learning from the master

* Shell programming
-- Bash & awk & sed & grep & diff & patch
-- Python | Perl | Ruby

* Software testing
-- smoke test
-- boundary test
-- stress test
...

* cross toolchain.
-- Static link & Share Library
-- ABI
-- Dependency tree
-- How kernel execute programs & ELF study

* SCM
-- git
-- svn
-- cvs
-- patch
---- quilt

* Distribution structure
-- How system boots
-- Build a distribution from scratch

* Misc tools
-- gdb
-- valgrind
-- gprof
-- gcov
-- doxygen
-- autotools

文化方面
* Mailing List
* Bugzilla
* Hacker ethics
* IRC
* English
* Eat your dog food
* Coding style
* Knowledge management skill - search & skip

很明顯以上不是一門課就可以上完的，不過可以分散在幾門課之中。
0. 計概
1. OS
2. C programming
3. System programming
4. XXX 專題

作為：
. 老師自已開始始用 GNU/Linux or any Unix like system 把自已丟進 FOSS 的世界…會更有 fu

. 鼓勵學生在大一時，就學習用 GNU/Linux，以及使用公開格式文件。
學校為什麼要為 MS 做免費的廣告呢？
要求學生使用不是每個人都買得起的東西，使用不公開格式的文件…
這是不道德也不經濟的。
學生也可以真正的體會 FOSS 的文化，有興趣的人還可以真正深入了解系統的運作。

. 要求學生使用 gpg keys 以及使用 ssh key

. 作業用 git+ssh 繳交…

. 教導學生使用 Unix 下的一些超級工具
-- 一旦學會了…一輩子受益。可惜…很多老師自已不會，學一下吧。 ~>_<~

. 要求學生加入有名的 open source 的專案，成為期中作業。（以 commit log 為準）

. OS 課程之中，指派學生 Trace Linux kernel code ，對照 textbook 內容，且 present 給大家，作為作業。

. Algorithm 課程中，指派學生 Trace glibc | stdc | stdc++ | java library code ，使用，且學習用它們的 API 自已 cleanroom 一個出來，用 test framwork 來測。

. C programming 中，學生的每個程式作業，都要擺出 autotools 的架式，以及使用 doxygen 產生文件 (或不同工具)

. RTFM, 選一些重要的 manual 叫學生讀，學會讀文件和學會讀 code 是一樣重要的。

. 出幾題如 pythonchallenge 之類的上機作業給學生…

. 要求程式作業要先交 .h 檔，先上 git

. 鼓勵學生訂 mailing list, 為課程開 mailing list，在上面討論課程和作業

. 老師也要學習新把戲 ;-) 如果您在教 GNU/Linux development 而上面的任何 Item 不清楚的話，或不了解怎麼做的話…也許要再 update 一下您的 knowledge 了。

基礎很重要。手中有工具，才能玩遊戲。

小弟其實懂得不多，每天也還忙著學新東西，不過看完了某教授的信後，心裏是這麼想的。

Neo 機器人

2008-10-30T21:57:00.005+08:00

月初從朋友那拿了一個控制 servo 的 LSC chip，以及一雙由 servo 組成的腳…
就在想，能不能拿 Neo 來做機器人呢？

Neo 上有兩個 g-sensor ,GPS chip，2.5G GSM chip， bluetooth，還有 wifi…
如果它能動…那會有多可怕… 拿它來開船、開飛機。可用 bluetooth wifi 和 GSM 來遙控…
應該會是一個很好玩的東西…

為了可以在 Neo 上能快快樂樂的玩 servo ，我開了個小案子：LSCD

把 servo 的 driver 寫好，再寫一個 python-binding... 就可以快快樂樂的玩了

liblscd 是控制 chip 的 API 可讀寫每個servo 的角度和速度。
pylsc 是 liblscd 的 python binding
在 tests 中還有一個 robot.py ，可以用來控制由 servo 組合而成的 robot...
未來想把 pylsc 寫成 freesmartphone 的一個 service 如此就可以和 phone event manager 整合在一起… (感覺起來可以做很多壞事 :P )

怎麼玩呢？
1. kernel 要有 HIDDEV drvier (Debian default 有，Ubuntu 沒有), Neo 從今天開始的 stable kernel 就會有 :P

2.1 在 laptop 上玩:
a. 安裝 gcc python cython pyrex python2.5-dev intltool libgettextpo-dev libtool automake autoconf make subversion
b. > svn checkout http://lscd.googlecode.com/svn/trunk/ lscd c. > cd lscd > ./autogen.sh > make > sudo make install d. 接上 LSC device, sudo chmod 777 /dev/usb/hiddev0 e. 就可以進 test 來玩 robot.py 了 2.2 在 Neo 上玩 a. wget http://lscd.googlecode.com/files/liblscd0_armv4t.opk b. opkg installliblscd0_armv4t.opk c. 用 wifi or bluetooth 連進Neohttp://wiki.openmoko.org/wiki/Wifi http://wiki.openmoko.org/wiki/Manually_using_Bluetooth#Bluetooth_networking_with_a_Linux_systemd. 把 usb 切到 host mode http://wiki.openmoko.org/wiki/USB_host#Selecting_USB_host_modes
e. 接上 LSC device (要有一個 mini 公 <----> USB B公的線, 可以用組合的) example: (mini公＜－－＞ A 公 | A 母 <--> A 母 | A公＜－－＞B 公) f. 就可以玩了 ^_^ 除了接線外…一切都可寫成 script :P

kernel indent 備忘

2008-10-23T14:55:00.001+08:00

indent -kr -i8 -ts8 -sob -l80 -ss -bs -ps1

也可以看 scripts/Lindent

Share Screen 備忘

2008-09-10T14:12:00.004+08:00

Screen 是一個很古老又好用的工具，雖然自已不是很常用…不過有時在幫別人做一些事情時，我們可以用 screen 的 share 功能，多人同時使用同一個 screen。在 demo，教學上實在蠻方便的。
很久之前有在用，不過一陣子沒用後就忘了，寫下來以免自已又忘掉。

1． sudo chmod u+s /usr/bin/screen
2． sudo chmod 755 /var/run/screen
3． screen
4．在另一個 terminal 上 screen -x

如要多人 share

1. ^a + :multiuser on
2. ^a + :acladd

3. 另一個人就可以 screen -x /[pid] 連上去

Using git-svn migrate svn repository server

2008-07-30T00:54:00.009+08:00

Suppose we create a project on one SVN repository server say A, however that server is going to close and disappear. And we still want to develop that project. So we found another repository server say B as our new host. However if we cannot use svnadmin commit on server B.(if you can you can use this) How do we migrate?

git-svn gives us a chance to do such thing.

Now we have server A and want to migrate project to server B.

support you are in /tmp
1. git-svn clone svn://server_A/my_project my_project_from_A
2. git clone file:///tmp/my_project_from_A my_project_sent_to_B
3. cd my_project_sent_to_B
4. git-svn init svn+ssh://whoyouare@server_B/my_project
(Here svn://server_B/my_project should be empty, make sure you can commit)
5. git-svn fetch
6. git-svn set-tree [the very first one commit in master]
note:1
7. git-svn dcommit
Done, Happy hacking...

Step 1: clone the svn log from old repository (let it read only)
Step 2: does not clone the svn infomation in server_A, so that we will have a clean space to do the hack
Step 4, 5: get the information from Server_B and get the initial point

Step 6: push the very first one commit in master to server B svn
Step 7: commit the whole tree to server B

Combining these skills actually you can migrate/convert/clone many kinds of SCM.

extension reading:GIT first SVN later
Note 1:If you meet
CONFLICT (delete/modify): XXXX deleted in HEAD and modified in adding License declare. Version adding License declare or XXXX left in tree.

you can
git status
then
git add (those unmerged files/directories)
git rebase --continue

Easy Sample to create ipk files

2008-07-17T16:14:00.004+08:00

step 1. ceate 2 new temp dirs say "_ipkg_temp" "_ipkg_tar"
step 2. use _ipkg_temp as root directory put your stuff there:
for example:
usr/bin/lala.sh
step 3. pushd _ipkg_temp; tar -czf ../ipkg_tar/data.tar.gz .; rm -rf * ; popd
step 4. create control file in _ipkg_temp
fill the following fields: (CONTROL="control")

        echo "Package: Your_package_name"   >  ${CONTROL}
        echo "Version: 0.1"             >> ${CONTROL}
        echo "Description: your_descriptions">> ${CONTROL}
        echo "Section: base"            >> ${CONTROL}
        echo "Priority: optional"       >> ${CONTROL}
        echo "Maintainer: Noname"      >> ${CONTROL}
        echo "Architecture: all"        >> ${CONTROL}
        echo "Homepage: http://ooo.xxx.vvv/svn/trunk"       >>  ${CONTROL}
        echo "Tags: group::unknown"       >> ${CONTROL}
        echo "Depends: ooxxooxx"    >> ${CONTROL}
        echo "Source: http://ooxxooxx.ooxx.vvvoo/" >>  ${CONTROL}

then tar -czf ../_ipkg_tar/control.tar.gz .
step 5. in _ipkg_tar create debian-binary file contents 2.0
echo "2.0" > debian-binary
step 6. in _ipkg_tar ar the ipkg file
ar -crf ooxx_0.1_arm.ipkg debian-binary data.tar.gz control.tar.gz

Done :-)

reference http://code.google.com/p/comic-reader/source/browse/trunk/packer/pack_eet2ipk.sh

Icescream

2008-07-03T23:40:00.006+08:00

和大家分享一個好物： ICE SCREAM

它是一個分散式的 compiler 架構…
在Debian 和 Ubuntu 下相當好安裝… 只要
sudo aptitude install icecc icecc-monitor
然後
export PATH=/usr/lib/icecc/bin:$PATH
就好了

在同一個網域下，把一台機器設成 scheduler (一台就好)
cat /etc/default/icecc
# Defaults for icecc initscript
# sourced by /etc/init.d/icecc
START_ICECC="true"
START_ICECC_SCHEDULER="false"

把 false 改成 true
sudo /etc/init.d/icecc restart
一切就搞定了…

今天下午用了 10 台 4 CPU 的機器玩了一下 compile qtopia
make -j 20
本來要一個 CPU 要compile 快兩個小時的東西，十幾分鐘就搞定了。

^_^

sudoku solver partII

2008-06-25T23:39:00.005+08:00

Sudoku Solver 比賽順利結束了，這個比賽相當看重速度，所以在加速和結構上做了相當大的取捨，也對於 python 這個語言的特性有一些更深入的了解。（這是小弟的第二支 python 程式）
和大家分享一下小弟的加速過程…

1. 第一步當然是先寫 Test Framework
Filename: testcase.py


#!/usr/bin/python

import sys
import tick_solver

if sys.argv.__len__() >= 2 and sys.argv[1] :
    name = sys.argv[1]
else:
    name = "case_01.txt"

bb = tick_solver.Board()
bb.file_read(name)

def TC_Board_group_get(bb):
    if bb.group_get(0, 0) == 0 and \
            bb.group_get(2, 2) == 0 and \
            bb.group_get(2, 3) == 1 and \
            bb.group_get(8, 8) == 8 and \
            bb.group_get(5, 7) == 5 and \
            bb.group_get(6, 7) == 8 and \
            bb.group_get(3, 10) == -1 and \
            bb.group_get(3, 0) == 3:
                print "group_get passed!!"
    else:
        print "group_get failed!!"

def TC_Board_data_print(bb):
    bb.data_print()
    bb.pretty_print()

def TC_Board_group_print(bb):
    for i in range(0,9):
        print "Rows["+str(i)+ "]=" + str(bb.Rows[i].left)
        print "Columns["+str(i)+ "]=" + str(bb.Columns[i].left)
        print "Groups["+str(i)+ "]=" + str(bb.Groups[i].left)

def TC_Board_possible_value_get(bb):
    for x in range(0,9):
        for y in range(0,9):
            print "("+str(x)+","+str(y)+") = "+str(bb.possible_value_get(x,y))
            
def TC_Board_puzzle_solving(bb):
    bb.puzzle_solving()
    bb.pretty_print()

import cProfile
def _TC_Board_profileing():
    BB.run(LALA)

def TC_Board_profileing():
    cProfile.run('BB.run(LALA)')

LALA = bb.data[:]
TC_Board_group_get(bb)
TC_Board_data_print(bb)
TC_Board_group_print(bb)
TC_Board_possible_value_get(bb)
bb.pretty_print()
BB = tick_solver.Board()
TC_Board_profileing()
BB.pretty_print()

再開始實做… （小弟習慣先寫 test case 再來寫實做，testcase 會和程式一同成長）
2. 決定演算法
從google 上找出sudoku 的rule
a. 每個 raw 的九個數字都不同
b. 每個 column 的九個數字都不同
c. 每個 group 的九個數字都不同
依這三條 rule 找出 candidates , 再從candidate 最少的 cell 猜起。
trace 的路徑是走迷宮的方式。

3. 開出 functions 實作每個 function , 先不管速度，先正確了再說

Filename: tick_solver.py



ROWS=9
COLUMNS=9
TOTAL_ELEMENTS=81

class Group:
    def __init__(self):
        self.left = range(1, COLUMNS+1)
    def set(self, x):
        if self.left.__contains__(x):
            self.left.remove(x)
            return True
        return False
    def unset(self, x):
        if not self.left.__contains__(x):
            self.left.append(x)
            return True
        return False
    def candidate(self):
        return self.left

class Cmd_Node:
    def __init__(self, x, y, v, Data):
        self.x = x
        self.y = y
        self.v = v
        self.D = []
        self.tried = []
        for d in Data:
            if d != v:
                self.D.append(d)
        self.tried.append(v)

    def retry(self):
        v=self.D.pop()
        self.tried.append(v)
        self.v = v;
        return v;
    def pretty_print(self):
        print "x="+str(self.x)+"  y="+str(self.y)+"  v="+str(self.v)+"  D="+str(self.D)+ "  Tried="+str(self.tried)

class Board:
 def __init__(self, name="case_01.txt"):
            self.num_rest=TOTAL_ELEMENTS
            self.trace = []
            self.DATA = []
            self.data = []
            self.Rows = []
            self.Columns = []
            self.Groups  = []
            self.name = name
            for i in range(0, ROWS):
                self.Rows.append(Group())
                self.Columns.append(Group())
                self.Groups.append(Group())
            for i in range(0, ROWS):
                self.data.append([0, 0, 0, 0, 0, 0, 0, 0, 0])
                self.DATA.append([[], [], [], [], [], [], [], [], []])
            if not self.file_read(self.name):
                print "Warning: Bad sudoku!!"

 
        # index from 0 - 8
 def value_set(self, x, y, v):
            if (v==0):
                return True
            if self.Columns[y].candidate().__contains__(v) and \
                    self.Rows[x].candidate().__contains__(v) and \
                    self.Groups[self.group_get(x,y)].candidate().__contains__(v):
                self.data[x][y]  = v
                self.Columns[y].set(v)
                self.Rows[x].set(v)
                self.Groups[self.group_get(x,y)].set(v)
                self.num_rest = self.num_rest - 1;    
                return True
            return False

        def value_unset(self, x, y):
            v = self.data[x][y]
            self.data[x][y] = 0
            self.Columns[y].unset(v)
            self.Rows[x].unset(v)
            self.Groups[self.group_get(x,y)].unset(v)
            self.num_rest = self.num_rest + 1;
            for x in range(0,9):
                for y in range(0,9):
                    self.DATA[x][y] = self.possible_value_get(x,y)


        def group_get(self, x, y):
            #if (x < 0 or x > 8 or y < 0 or y > 8):
            #    return -1
            return int(x/3)*3 + int(y/3) 

        def data_print(self):
            print self.data

        def pretty_print(self):
            for i in range(0,ROWS):
                print self.data[i]

        def file_read(self, name):
            f = open(name, "r")
            for x in range(0,9):
                for y in range(0,9):
                    if not self.value_set(x,y,int(f.read(2))):
                        print "Bad sudoku!!"
                        return False
            return True

        def possible_value_get(self, x, y):
            if (self.data[x][y] != 0):
                return
            ans = [];
            Group = self.Groups[self.group_get(x, y)].candidate()
            Row   = self.Rows[x].candidate()
            Column= self.Columns[y].candidate()
            for i in Group:
                if i in Row and i in Column:
                    ans.append(i);
            return ans;

        def puzzle_solving_iterate(self):
            min_x = 0
            min_y = 0
            min=10
            for x in range(0,9):
                for y in range(0,9):
                    pos = self.possible_value_get(x,y)
                    self.DATA[x][y] = pos
                    if pos == None:
                        continue
                    if len(pos) == 1:
                        v = pos[0]
                        self.value_set(x,y,v)
                        self.trace.append(Cmd_Node(x,y,v, pos))
                    if pos.__len__() < min:
                        min_x = x
                        min_y = y
                        min = pos.__len__()
            if min == 1:
                return True
            #guess has to be made
            if self.DATA[min_x][min_y].__len__() > 0:
                guess = self.DATA[min_x][min_y][0]
                self.trace.append(Cmd_Node(min_x, min_y, guess, self.DATA[min_x][min_y]))
                return self.value_set(min_x, min_y,guess)
            return False

        def puzzle_solving(self):
            while self.num_rest > 0:
                if self.puzzle_solving_iterate():
                    continue
                continue_flag=True
                while continue_flag:
                    cmd = self.trace.pop()
                    if cmd.D.__len__()==0:
                        self.value_unset(cmd.x, cmd.y)
                        continue
                    self.value_unset(cmd.x, cmd.y)
                    for x in range(0,9):
                        for y in range(0,9):
                            pos = self.possible_value_get(x,y)
                            self.DATA[x][y] = pos
                    while cmd.D.__len__() > 0:
                        v = cmd.retry()
                        if self.DATA[cmd.x][cmd.y].__contains__(v):
                            self.value_set(cmd.x, cmd.y, v)
                            self.trace.append(cmd)
                            continue_flag = False
                            break

4. run a lot of test cases to check out the bottleneck

如 case


0 7 8 1 0 0 5 0 0
0 0 6 0 0 0 0 0 0
5 0 0 0 4 0 0 0 0
0 1 0 0 0 0 0 0 0
0 0 4 8 0 0 0 0 0
0 0 0 0 0 9 2 0 3
0 0 1 0 0 2 0 0 8
9 6 3 0 0 0 0 5 0
0 0 0 4 0 0 3 0 9

以下是test case 分析出來的結果


         172502 function calls in 0.651 CPU seconds

   Ordered by: standard name

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        1    0.000    0.000    0.651    0.651 :1()
        1    0.000    0.000    0.651    0.651 testcase.py:45(_TC_Board_profileing)
        1    0.000    0.000    0.002    0.002 tick_solver.py:102(file_read)
    34101    0.318    0.000    0.507    0.000 tick_solver.py:111(possible_value_get)
       98    0.033    0.000    0.188    0.002 tick_solver.py:123(puzzle_solving_iterate)
      909    0.004    0.000    0.005    0.000 tick_solver.py:14(unset)
        1    0.006    0.006    0.649    0.649 tick_solver.py:150(puzzle_solving)
    53544    0.079    0.000    0.079    0.000 tick_solver.py:19(candidate)
      341    0.002    0.000    0.002    0.000 tick_solver.py:23(__init__)
       20    0.000    0.000    0.000    0.000 tick_solver.py:34(retry)
        1    0.000    0.000    0.002    0.002 tick_solver.py:43(__init__)
      442    0.007    0.000    0.017    0.000 tick_solver.py:64(value_set)
       27    0.000    0.000    0.000    0.000 tick_solver.py:7(__init__)
      303    0.064    0.000    0.424    0.001 tick_solver.py:78(value_unset)
     1152    0.004    0.000    0.006    0.000 tick_solver.py:9(set)
    18535    0.044    0.000    0.044    0.000 tick_solver.py:90(group_get)
     4397    0.006    0.000    0.006    0.000 {len}
    52821    0.073    0.000    0.073    0.000 {method 'append' of 'list' objects}
        1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}
      323    0.001    0.000    0.001    0.000 {method 'pop' of 'list' objects}
       81    0.000    0.000    0.000    0.000 {method 'read' of 'file' objects}
     1152    0.002    0.000    0.002    0.000 {method 'remove' of 'list' objects}
        1    0.000    0.000    0.000    0.000 {open}
     4249    0.008    0.000    0.008    0.000 {range}

我們會發現
possible_value_get被 call 了 34101 次，花了 0.318 秒
candidate 被 call 了 53544 次…花了 0.079 秒
list 的 append 被 call 了 52821 次花了 0.073 秒

種種的數據告訴我 possible_value_get 是最大的 bottleneck
array 的 operation 過於大量且昂貴
而在這，我選擇的方式是…改變 Group 存數字的方式：用 binary operations
所以 Group 就變成了


class Group:
    def __init__(self, value=0x1ff):
        self.left = value
    def set(self, x):
        if self.left & (1 << (x-1)):
            self.left &= (~(1<< (x-1)))
            return True
        return False
    def unset(self, x):
        if not self.left & (1 << (x-1)):
            self.left |= (1 << (x-1))
            return True
        return False
    def contains(self, x):
        return not not self.left & (1 << (x-1))
    def len(self):
        ans = 0
        v = self.left;
        while v:
            v &= v -1
            ans += 1
        return ans

def len(v):
    ans=0
    while v:
        v &= v - 1
        ans += 1
    return ans

def min_value(V):
    v=1
    while not V & 1:
        V = V >> 1
        v+=1
    return v

而 possible_value_get 變成了


        def possible_value_get(self, x, y):
            return self.Groups[(int(x/3)*3 + int(y/3))].left & self.Rows[x].left & self.Columns[y].left

沒錯…就變成了兩個 operations
而時間從變成 0.651


27546 function calls in 0.126 CPU seconds
   Ordered by: standard name

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        1    0.000    0.000    0.126    0.126 :1()
        1    0.000    0.000    0.126    0.126 testcase.py:45(_TC_Board_profileing)
        1    0.001    0.001    0.002    0.002 tick_solver.py:114(file_read)
     7280    0.024    0.000    0.024    0.000 tick_solver.py:127(possible_value_get)
      128    0.042    0.000    0.104    0.001 tick_solver.py:136(puzzle_solving_iterate)
     1161    0.002    0.000    0.002    0.000 tick_solver.py:14(unset)
        1    0.007    0.007    0.124    0.124 tick_solver.py:172(puzzle_solving)
     1404    0.002    0.000    0.002    0.000 tick_solver.py:19(contains)
    12148    0.028    0.000    0.028    0.000 tick_solver.py:29(len)
      415    0.001    0.000    0.001    0.000 tick_solver.py:37(__init__)
       30    0.000    0.000    0.000    0.000 tick_solver.py:44(retry)
        1    0.000    0.000    0.002    0.002 tick_solver.py:56(__init__)
       27    0.000    0.000    0.000    0.000 tick_solver.py:7(__init__)
      526    0.007    0.000    0.013    0.000 tick_solver.py:76(value_set)
     1404    0.003    0.000    0.003    0.000 tick_solver.py:9(set)
      387    0.003    0.000    0.006    0.000 tick_solver.py:90(value_unset)
      490    0.001    0.000    0.001    0.000 {method 'append' of 'list' objects}
        1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}
      387    0.001    0.000    0.001    0.000 {method 'pop' of 'list' objects}
      161    0.000    0.000    0.000    0.000 {method 'read' of 'file' objects}
        1    0.000    0.000    0.000    0.000 {open}
     1591    0.003    0.000    0.003    0.000 {range}

從快的我們會發現 bottleneck 變成了
12148 0.028 0.000 0.028 0.000 tick_solver.py:29(len)
7280 0.024 0.000 0.024 0.000 tick_solver.py:127(possible_value_get)
由於我是用 binary operation 算 len 變成一個 cost 相當高的事。而小弟覺得用查表法實在不夠好玩… 就是不肯用，所以就找出 len 的使用點，只做最必要的計算。(其實還可以用其它變數去存…這也會比較快)
而possible_value_get 其實已經很快了…可是因為被 call 的次數很多，所以太花時間（大多在 type checking 和 stack jump）所以就直接 inline 到被 call 的地方

如此一直找 bottleneck 的位置，不停的 "反" refactoring
最後變成


         2655 function calls in 0.039 CPU seconds

   Ordered by: standard name

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        1    0.000    0.000    0.039    0.039 :1()
      387    0.002    0.000    0.002    0.000 tick_solver.py:107(value_unset)
        1    0.000    0.000    0.000    0.000 tick_solver.py:137(array_get)
        1    0.031    0.031    0.038    0.038 tick_solver.py:149(puzzle_solving)
      387    0.001    0.000    0.001    0.000 tick_solver.py:29(len)
      415    0.001    0.000    0.001    0.000 tick_solver.py:44(__init__)
       30    0.000    0.000    0.000    0.000 tick_solver.py:51(retry)
        1    0.000    0.000    0.000    0.000 tick_solver.py:68(reinit)
       27    0.000    0.000    0.000    0.000 tick_solver.py:7(__init__)
        1    0.000    0.000    0.039    0.039 tick_solver.py:84(run)
      526    0.003    0.000    0.003    0.000 tick_solver.py:92(value_set)
      490    0.001    0.000    0.001    0.000 {method 'append' of 'list' objects}
        1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}
      387    0.001    0.000    0.001    0.000 {method 'pop' of 'list' objects

又快了三倍 ^_^

然而在高興之餘卻發現到有一些 test case 會跑非常的久


tick@tock:~/work/sudoku>./testcase.py case_09.txt 
[0, 0, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 9, 0, 0]
[0, 0, 0, 0, 6, 0, 1, 0, 0]
[0, 0, 0, 0, 1, 0, 0, 0, 0]
[0, 0, 0, 0, 9, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 5, 0]
[0, 0, 0, 0, 0, 0, 8, 0, 0]
[0, 9, 0, 0, 0, 0, 0, 3, 0]
[0, 0, 0, 7, 0, 0, 0, 0, 0]
         3838777 function calls in 47.685 CPU seconds

   Ordered by: standard name

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        1    0.000    0.000   47.685   47.685 :1()
        1    0.000    0.000   47.685   47.685 testcase.py:47(_TC_Board_profileing)
        1    0.000    0.000    0.001    0.001 tick_solver.py:134(array_get)
        1   36.462   36.462   47.684   47.684 tick_solver.py:181(puzzle_solving)
   639734    1.038    0.000    1.038    0.000 tick_solver.py:29(len)
   568664    1.425    0.000    1.425    0.000 tick_solver.py:37(__init__)
    71141    0.297    0.000    0.297    0.000 tick_solver.py:44(retry)
        1    0.000    0.000    0.000    0.000 tick_solver.py:61(reinit)
       27    0.000    0.000    0.000    0.000 tick_solver.py:7(__init__)
        1    0.000    0.000   47.685   47.685 tick_solver.py:77(run)
   639886    3.827    0.000    3.827    0.000 tick_solver.py:85(value_set)
   639734    2.801    0.000    2.801    0.000 tick_solver.py:99(value_unset)
   639850    0.893    0.000    0.893    0.000 {method 'append' of 'list' objects}
        1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}
   639734    0.942    0.000    0.942    0.000 {method 'pop' of 'list' objects}


[7, 6, 9, 1, 2, 8, 3, 4, 5]
[1, 2, 8, 3, 4, 5, 9, 6, 7]
[3, 4, 5, 9, 6, 7, 1, 2, 8]
[6, 5, 7, 2, 1, 3, 4, 8, 9]
[2, 8, 3, 5, 9, 4, 6, 7, 1]
[9, 1, 4, 8, 7, 6, 2, 5, 3]
[5, 7, 2, 4, 3, 1, 8, 9, 6]
[8, 9, 1, 6, 5, 2, 7, 3, 4]
[4, 3, 6, 7, 8, 9, 5, 1, 2]

這是因為我走迷宮時用相當簡單的 guess ，找出最小的 candidate
而很不幸，在一些迷宮中…（尤其是那些只有唯一解的）一但走錯… cost 就會走很遠，再走回來…這是我在演算法上的miss。所以就再加上了一些演算法來做相當複雜的 guess。而演算法的選擇也是很出現機率最高的來選擇… 只為 hard guess 相當的花時間…所以我只有在題目相當困難時 (最少candidate 的cell 依然有超過三個選擇時) (關鍵少數) 才去做。其它的，就交給暴力走迷宮法。

而 hard guess 也很成功的減少了 retry 的次數… ^^;


tick@tock:~/work/sudoku>./testcase.py case_09.txt 
[0, 0, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 9, 0, 0]
[0, 0, 0, 0, 6, 0, 1, 0, 0]
[0, 0, 0, 0, 1, 0, 0, 0, 0]
[0, 0, 0, 0, 9, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 5, 0]
[0, 0, 0, 0, 0, 0, 8, 0, 0]
[0, 9, 0, 0, 0, 0, 0, 3, 0]
[0, 0, 0, 7, 0, 0, 0, 0, 0]
         372 function calls in 0.028 CPU seconds

   Ordered by: standard name

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        1    0.000    0.000    0.028    0.028 :1()
        1    0.000    0.000    0.001    0.001 tick_solver.py:137(array_get)
        1    0.025    0.025    0.027    0.027 tick_solver.py:149(puzzle_solving)
       71    0.000    0.000    0.000    0.000 tick_solver.py:44(__init__)
        1    0.000    0.000    0.000    0.000 tick_solver.py:68(reinit)
       27    0.000    0.000    0.000    0.000 tick_solver.py:7(__init__)
        1    0.000    0.000    0.028    0.028 tick_solver.py:84(run)
      152    0.001    0.000    0.001    0.000 tick_solver.py:92(value_set)
      116    0.000    0.000    0.000    0.000 {method 'append' of 'list' objects}
        1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}


[8, 2, 5, 1, 7, 9, 3, 4, 6]
[4, 1, 6, 3, 2, 5, 9, 7, 8]
[9, 3, 7, 4, 6, 8, 1, 2, 5]
[7, 5, 9, 2, 1, 6, 4, 8, 3]
[3, 4, 8, 5, 9, 7, 6, 1, 2]
[1, 6, 2, 8, 4, 3, 7, 5, 9]
[5, 7, 1, 9, 3, 2, 8, 6, 4]
[2, 9, 4, 6, 8, 1, 5, 3, 7]
[6, 8, 3, 7, 5, 4, 2, 9, 1]

有些地方被 inline 掉了 :P

以下是目前的 source code, 蠻髒的，不過也蠻好玩的

Filename: tick_solver.py



ROWS=9
COLUMNS=9
TOTAL_ELEMENTS=81

class Group:
    def __init__(self, value=0x1ff):
        self.left = value
    def set(self, x):
        if self.left & (1 << (x-1)):
            self.left &= (~(1<< (x-1)))
            return True
        return False
    def unset(self, x):
        if not self.left & (1 << (x-1)):
            self.left |= (1 << (x-1))
            return True
        return False
    def contains(self, x):
        return not not self.left & (1 << (x-1))
    def len(self):
        ans = 0
        v = self.left;
        while v:
            v &= v -1
            ans += 1
        return ans

def len(v):
    ans=0
    while v:
        v &= v - 1
        ans += 1
    return ans

def min_value(V):
    v=1
    while not V & 1:
        V = V >> 1
        v+=1
    return v

class Cmd_Node:
    def __init__(self, x, y, v, Data):
        self.x = x
        self.y = y
        self.v = v
        self.D = Data
        self.D &= ~( 1 << (v-1) )

    def retry(self):
        v=0
        while not self.D & (1 << v):
            v+=1
        self.D &= ~(1 << v);
        v+=1
        self.v = v;
        return v;
    def pretty_print(self):
        print "x="+str(self.x)+"  y="+str(self.y)+"  v="+str(self.v)+"  D="+str(self.D)

from test_module import *

class Board(TestModule):
 def __init__(self):
            self.reinit()

        def reinit(self):
            self.num_rest=TOTAL_ELEMENTS
            self.trace = []
            self.DATA = []
            self.data = []
            self.Rows = []
            self.Columns = []
            self.Groups  = []
            for i in  xrange(0,9):
                self.Rows.append(Group())
                self.Columns.append(Group())
                self.Groups.append(Group())
                self.data.append([0, 0, 0, 0, 0, 0, 0, 0, 0])
                self.DATA.append([ 0, 0, 0, 0, 0, 0, 0, 0, 0])


        def run(self, array):
            self.reinit()
            self.array_get(array)
            self.puzzle_solving()
            return self.data

 
        # index from 0 - 8
 def value_set(self, x, y, v):
            if (v==0):
                return True
            mask = (1<< (v-1))
            if mask & self.Columns[y].left & self.Rows[x].left & self.Groups[(int(x/3)*3 + int(y/3))].left:
                self.data[x][y]  = v
                mask = ~mask
                self.Columns[y].left &= mask
                self.Rows[x].left &= mask
                self.Groups[(int(x/3)*3 + int(y/3))].left &= mask
                self.num_rest = self.num_rest - 1;    
                return True
            print "Set ("+str(x)+", "+str(y)+")="+str(v) +" Failed!!!"
            return False

        def value_unset(self, x, y):
            v = self.data[x][y]
            self.data[x][y] = 0
            mask = (1 << (v-1))
            self.Columns[y].left |= mask
            self.Rows[x].left |= mask
            self.Groups[(int(x/3)*3 + int(y/3))].left |= mask
            self.num_rest = self.num_rest + 1;


        def data_print(self):
            print self.data

        def pretty_print(self):
            for i in xrange(0,9):
                print self.data[i]

        def file_read(self, name):
            f = open(name, "r")
            for x in  xrange(0,9):
                for y in  xrange(0,9):
                    while True:
                        v = f.read(1)
                        if v >= '0' and v <= '9':
                            break;
                    if not self.value_set(x,y,int(v)):
                        print "Bad sudoku!!"
                        return False
            return True

        def array_get(self, array):
            for x in xrange(0,9):
                for y in xrange(0,9):
                    if not self.value_set(x,y,array[x][y]):
                        print "Bad sudoku!!"
                        return False
            return True

        def possible_value_get(self, x, y):
            return self.Groups[(int(x/3)*3 + int(y/3))].left & self.Rows[x].left & self.Columns[y].left


        def puzzle_solving(self):
            while self.num_rest > 0:
                min=10
                for x in  xrange(0,9):
                    for y in  xrange(0,9):
                        if self.data[x][y]:
                            continue
                        pos = self.Groups[(int(x/3)*3 + int(y/3))].left & self.Rows[x].left & self.Columns[y].left
                        self.DATA[x][y] = pos
                        if pos == None:
                            continue
                        lentmp = 0
                        v = pos;
                        while v:
                            v &= v -1
                            lentmp += 1

                        if lentmp == 1:
                            v = 0
                            while not (pos & 1 << v):
                                v += 1
                            v += 1
                            self.value_set(x,y,v)
                            self.trace.append(Cmd_Node(x,y,v, pos))
                        if lentmp < min:
                            min_x = x
                            min_y = y
                            min = lentmp
                if min == 1:
                    continue
                #guess has to be made
                if min > 0:
                    guess = 0
                    if min == 2:
                        while not (self.DATA[min_x][min_y] &  1 << guess):
                            guess += 1
                        guess += 1
                    else: # give a better guess here
                        Row = min_x % 3
                        R_base = min_x/3
                        Column = min_y % 3
                        C_base = min_y/3
                        V = self.DATA[min_x][min_y]
                        # remove hidden 
                        while V:
                            a = V & 1
                            V = V >> 1
                            guess += 1
                            if not a:
                                continue
                            row_single_check = 0
                            column_single_check = 0
                            mask = (1 << (guess-1))
                            for i in [0, 1, 2]:
                                if Row != i and (self.Rows[R_base + i].left & mask):
                                        row_single_check += 1
                                if Column != i and (self.Columns[C_base + i].left & mask):
                                        column_single_check += 1
                            if row_single_check == 2  or column_single_check == 2:  # guess first
                                break
                        #guess = self.hard_guess_find(min_x, min_y, self.DATA[min_x][min_y])
                    self.trace.append(Cmd_Node(min_x, min_y, guess, self.DATA[min_x][min_y]))
                    if self.value_set(min_x, min_y,guess):
                        continue


                continue_flag=True
                while continue_flag:
                    cmd = self.trace.pop()
                    lentmp = len(cmd.D)
                    if lentmp==0:
                        self.value_unset(cmd.x, cmd.y)
                        continue
                    self.value_unset(cmd.x, cmd.y)
                    for x in xrange(0,9):
                        for y in  xrange(0,9):
                            if self.data[x][y]:
                                continue
                            self.DATA[x][y] = self.Groups[(int(x/3)*3 + int(y/3))].left & self.Rows[x].left & self.Columns[y].left
                    while lentmp > 0:
                        if lentmp==1:
                            v = cmd.retry()
                            if self.DATA[cmd.x][cmd.y] & (1<< (v-1)):
                                self.value_set(cmd.x, cmd.y, v)
                                self.trace.append(cmd)
                                continue_flag = False
                                break
                        else:  # when there are more than one candidates, may be we can take long time to find out a better guess
                            v = self.hard_guess_find(cmd.x, cmd.y, cmd.D)
                            if self.DATA[cmd.x][cmd.y] & (1<< (v-1)):
                                cmd.D &= ~ (1<<(v-1))
                                self.value_set(cmd.x, cmd.y, v)
                                self.trace.append(cmd)
                                continue_flag = False
                                break
                        lentmp = len(cmd.D)

        def hard_guess_find(self, x, y, V):
            Row = x % 3
            R_base = x/3
            Column = y % 3
            C_base = y/3
            v = 0
            # remove hidden 
            while V:
                a = V & 1
                V = V >> 1
                v += 1
                if not a:
                    continue
                row_single_check = 0
                column_single_check = 0
                mask = (1 << (v-1))
                for i in xrange(0,3):
                    if Row != i and (self.Rows[R_base + i].left & mask):
                            row_single_check += 1
                    if Column != i and (self.Columns[C_base + i].left & mask):
                            column_single_check += 1
                if row_single_check == 2  or column_single_check == 2:  # guess first
                    return v
            return v

以下是跑 1000 個 test case 的分析圖 (用 octave 畫的)

可以看得出來其實大多數的 test case 都在 0.01 秒做完，而比較久的也在 0.02 秒內做完. 中位數在 0.003 秒
其實還有相當多地方可以改進… 如查表，pattern map等等…
不過…我個人覺得以一個小比賽來說…可以了… ^_^;

Sudoku solver

2008-06-19T00:37:00.003+08:00

在公司內辦了一場 Python Sudoku solver 比賽
下星期二才會正式跑 benchmark ^^
今早寫了一下，加上一些 turning
就看著 code 是如何的一步一步的加速…
從開始到現在，竟然已經加速了 1000 多倍了…
可是 code 也越來越噁心…簡直就是反refactoring
為了讓比賽更好玩… 先把 code post 出來了 ^_^

反正… just for fun :)

Filename: tick_solver.py



ROWS=9
COLUMNS=9
TOTAL_ELEMENTS=81

class Group:
   def __init__(self, value=0x1ff):
       self.left = value
   def set(self, x):
       if self.left & (1 << (x-1)):
           self.left &= (~(1<< (x-1)))
           return True
       return False
   def unset(self, x):
       if not self.left & (1 << (x-1)):
           self.left |= (1 << (x-1))
           return True
       return False
   def contains(self, x):
       return not not self.left & (1 << (x-1))
   def len(self):
       ans = 0
       v = self.left;
       while v:
           v &= v -1
           ans += 1
       return ans

def len(v):
   ans=0
   while v:
       v &= v - 1
       ans += 1
   return ans

class Cmd_Node:
   def __init__(self, x, y, v, Data):
       self.x = x
       self.y = y
       self.v = v
       self.D = Data
       self.D &= ~( 1 << (v-1) )

   def retry(self):
       v=0
       while not self.D & (1 << v):
           v+=1
       self.D &= ~(1 << v);
       v+=1
       self.v = v;
       return v;
   def pretty_print(self):
       print "x="+str(self.x)+"  y="+str(self.y)+"  v="+str(self.v)+"  D="+str(self.D)


class Board():
 def __init__(self):
           self.num_rest=TOTAL_ELEMENTS
           self.trace = []
           self.DATA = []
           self.data = []
           self.Rows = []
           self.Columns = []
           self.Groups  = []
           for i in range(0, ROWS):
               self.Rows.append(Group())
               self.Columns.append(Group())
               self.Groups.append(Group())
               self.data.append([0, 0, 0, 0, 0, 0, 0, 0, 0])
               self.DATA.append([ 0, 0, 0, 0, 0, 0, 0, 0, 0])

       def run(self, array):
           self.array_get(array)
           self.puzzle_solving()


       # index from 0 - 8
 def value_set(self, x, y, v):
           if (v==0):
               return True
           if self.Columns[y].contains(v) and \
                   self.Rows[x].contains(v) and \
                   self.Groups[(int(x/3)*3 + int(y/3))].contains(v):
               self.data[x][y]  = v
               self.Columns[y].set(v)
               self.Rows[x].set(v)
               self.Groups[(int(x/3)*3 + int(y/3))].set(v)
               self.num_rest = self.num_rest - 1;   
               return True
           return False

       def value_unset(self, x, y):
           v = self.data[x][y]
           self.data[x][y] = 0
           self.Columns[y].unset(v)
           self.Rows[x].unset(v)
           self.Groups[(int(x/3)*3 + int(y/3))].unset(v)
           self.num_rest = self.num_rest + 1;


       def group_get(self, x, y):
           if (x < 0 or x > 8 or y < 0 or y > 8):
               return -1
           return int(x/3)*3 + int(y/3)

       def data_print(self):
           print self.data

       def pretty_print(self):
           for i in range(0,ROWS):
               print self.data[i]

       def file_read(self, name):
           f = open(name, "r")
           for x in range(0,9):
               for y in range(0,9):
                   while True:
                       v = f.read(1)
                       if v >= '0' and v <= '9':
                           break;
                   if not self.value_set(x,y,int(v)):
                       print "Bad sudoku!!"
                       return False
           return True

       def array_get(self, array):
           for x in [0, 1, 2, 3, 4, 5, 6, 7, 8]:
               for y in [0, 1, 2, 3, 4, 5, 6, 7, 8]:
                   if not self.value_set(x,y,array[x][y]):
                       print "Bad sudoku!!"
                       return False
           return True

       def possible_value_get(self, x, y):
           return self.Groups[(int(x/3)*3 + int(y/3))].left & self.Rows[x].left & self.Columns[y].left

       def puzzle_solving_iterate(self):
           min_x = 0
           min_y = 0
           min=10
           for x in range(0,9):
               for y in range(0,9):
                   if self.data[x][y]:
                       continue
                   pos = self.Groups[(int(x/3)*3 + int(y/3))].left & self.Rows[x].left & self.Columns[y].left
                   self.DATA[x][y] = pos
                   if pos == None:
                       continue
                   lentmp = len(pos)
                   if lentmp == 1:
                       v = 0
                       while not (pos & 1 << v):
                           v += 1
                       v += 1
                       self.value_set(x,y,v)
                       self.trace.append(Cmd_Node(x,y,v, pos))
                   if lentmp < min:
                       min_x = x
                       min_y = y
                       min = lentmp
           if min == 1:
               return True
           #guess has to be made
           if min > 0:
               guess = 0
               while not (self.DATA[min_x][min_y] &  1 << guess):
                   guess += 1
               guess += 1
               self.trace.append(Cmd_Node(min_x, min_y, guess, self.DATA[min_x][min_y]))
               return self.value_set(min_x, min_y,guess)
           return False

       def puzzle_solving(self):
           while self.num_rest > 0:
               if self.puzzle_solving_iterate():
                   continue
               continue_flag=True
               while continue_flag:
                   cmd = self.trace.pop()
                   lentmp = len(cmd.D)
                   if lentmp==0:
                       self.value_unset(cmd.x, cmd.y)
                       continue
                   self.value_unset(cmd.x, cmd.y)
                   for x in range(0,9):
                       for y in range(0,9):
                           if self.data[x][y]:
                               continue
                           self.DATA[x][y] = self.Groups[(int(x/3)*3 + int(y/3))].left & self.Rows[x].left & self.Columns[y].left
                   while lentmp > 0:
                       v = cmd.retry()
                       if self.DATA[cmd.x][cmd.y] & (1<< (v-1)):
                           self.value_set(cmd.x, cmd.y, v)
                           self.trace.append(cmd)
                           continue_flag = False
                           break

邪惡的小案子

2008-06-14T06:27:00.002+08:00

提升大家宅度的邪惡計畫：
http://code.google.com/p/comic-reader/

Integrate Ecore_main_loop into gMainLoop

2008-02-13T16:04:00.004+08:00

If we want to write a program with two kinds of event driven GUI libraries, we have to run each event processing function. There are some ways to do that.

When I was writing a program with EFL and glib, I met this problem.

There are two ways come up to me:
1. Write a multi thread program and each runs a main loop.
2. Put one main loop into another.

When I tried first one by writing two threads to dealing this problem, it works well, but I am very worry about the entropy of this program. It's too high, and complicated. I have to write spin lock to protect data.


static gpointer  pk_thread(gpointer data) {
     PConnect * pc = (PConnect *)data;
     pc->loop =  g_main_loop_new (NULL, FALSE);
     debug("g_main_loop_run starts\n");
     g_main_loop_run(pc->loop);
}

PConnect *  pconnect_initial() {
     PConnect * pc  = (PConnect *)malloc (sizeof(PConnect));
     memset(pc, 0, sizeof(PConnect));
     if (! g_thread_supported ()) {
             g_thread_init (NULL);
     }
     dbus_g_thread_init();
     g_type_init ();
     pc->thread = g_thread_create(pk_thread, (gpointer)pc, FALSE, &pc->error);
     return pk_dbus_initial(pc);
}

The IPC becomes a nightmare.

After thinking for a while, I tried to merge ecore main loop into glib main loop.
Learning from Integrating QT/GTK
Both Ecore and Glib provides iterator event processing, so that I can wrap the ecore_main_loop_iterate into a GSource.

Make GMainLoop do a ecore_main_loop_iterate() once at each event processing by making preparing and checking always returns true.

Filename: mainlooptesting.c


#include <stdio.h>
#include <glib.h>
#include <Ecore.h>


static gboolean GEvas_prepare (GSource *source, gint *timeout_) {
     return TRUE;
}

static gboolean GEvas_check(GSource *source) {
     return TRUE;
}

static gboolean GEvas_dispatch (GSource *source, GSourceFunc  callback, gpointer user_data) {
     ecore_main_loop_iterate ();
     return TRUE;
}

static GSourceFuncs  Iterator_funcs = {
     GEvas_prepare,
     GEvas_check,
     GEvas_dispatch,
     NULL,
     NULL,
     NULL
};

int evas_timer(void *data) {
     printf("evas_timer ran!!!\n");
     return 1;
}
gboolean  glib_timer(gpointer data) {
     printf("glib_timer ran!!!\n");
     return TRUE;
}

int main (void) {
     GMainContext *context = g_main_context_default();
     GSource *source = g_source_new(&Iterator_funcs,sizeof(GSource));
     GMainLoop *loop = g_main_loop_new (context,FALSE);
     g_source_attach((GSource *)source, context);

     ecore_timer_add(1.0f,evas_timer,NULL);
     g_timeout_add(500,glib_timer,NULL);

     g_main_run(loop);
}

I test each main loop by adding a timer event, and the following are results.
./a.out
glib_timer ran!!!
glib_timer ran!!!
evas_timer ran!!!
glib_timer ran!!!
glib_timer ran!!!
evas_timer ran!!!
glib_timer ran!!!
glib_timer ran!!!
evas_timer ran!!!
glib_timer ran!!!
glib_timer ran!!!
evas_timer ran!!!
^C

Works \^_^/

宅男遇上 Wii remote

2008-01-14T08:48:00.000+08:00

前幾天看到同事分享 Johnny Lee的影片。心中有蠻大的震憾。一直認為 Wii Remote 已經很神奇了…沒想到還有那麼多的玩法…果然厲害。就開始想在自己的機器上玩玩 Wii Remote.

沒想到一切都是如此的美好： Ubuntu 已經有了 CWiid 的 package.
直接安裝後，把 bluetooth 打開，就可以玩了

身為一名陽光宅男…當然好好的研究一下這個好玩的東西…
也就寫了一支小小的程式…可以依 Wii remote 的水平改變小 Icon 的位置。

Filename: wii_toy.c


#include <wiimote.h>
#include <wiimote_api.h>
#include <Ecore_Evas.h>
#include <Ecore.h>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>

#define WIDTH 800
#define HEIGHT 600

Ecore_Evas  *   ee;
Evas        *   evas;

struct remoter {
     Evas_Object *   o;
     wiimote_t *wii;
     double x,y,size;
};

inline void set_wiiremote(wiimote_t *wii) {
     wii->led.one  = 1;
     wii->mode.ir = 1;
     wii->mode.acc =1;
}

inline void change_position(struct remoter *handle) {
     if ( abs(handle->wii->tilt.x) <= 90 &&
                     abs (handle->wii->tilt.y) <= 90) {

             handle->x += (double)handle->wii->tilt.x/10.0f;
             handle->y += (double)handle->wii->tilt.y/10.0f;
     }
     handle->x = handle->x <= 0 ? 0 : handle->x >= WIDTH - handle->size?  WIDTH-handle->size :  handle->x;
     handle->y = handle->y <= 0 ? 0 : handle->y >= HEIGHT - handle->size? HEIGHT-handle->size : handle->y;


//      fprintf(stderr, "remote: x=%3.3f y=%3.3f\n",handle->x,handle->y);
     evas_object_move(handle->o, handle->x,handle->y);
}

inline void show_status(wiimote_t *wii) {
     fprintf(stderr, "AXIS x=%03d y=%03d z=%03d\n",
             wii->axis.x,
             wii->axis.y,
             wii->axis.z);
     fprintf(stderr, "TILT x=%.3f y=%.3f z=%.3f\n",
             wii->tilt.x,
             wii->tilt.y,
             wii->tilt.z);
     fprintf(stderr, "FORCE x=%.3f y=%.3f z=%.3f\n",
             wii->force.x,
             wii->force.y,
             wii->force.z);
     fprintf(stderr,"\n");
}

int scan_wii_event(void *data) {
     struct remoter *handle=(struct remoter *)data;
     if (wiimote_is_open(handle->wii))  {
             if (wiimote_update(handle->wii) < 0) {
                     printf("Update Failed!! Exit!!\n");
                     wiimote_disconnect(handle->wii);
                     exit(1);
             }
             if (handle->wii->keys.home) {
                     printf("Home pressed!! Exit!!\n");
                     wiimote_disconnect(handle->wii);
                     exit(1);
             }
             change_position(handle);
             //show_status(handle->wii);
     }
     return 1;
}

int main(int argc,char **argv) {
     struct remoter handle;
     if (argc < 2) {
             fprintf(stderr, "Usage: test1 BDADDR\n");
             exit(1);
     }
     Evas_Object *   background;
     ecore_evas_init();

     ee = ecore_evas_software_x11_new(NULL, 0,  0, 0, WIDTH, HEIGHT);
     ecore_evas_title_set(ee, "Tick's Wii Toy");
//      ecore_evas_borderless_set(ee, 1);  // borderless
     ecore_evas_borderless_set(ee, 0);  // border
     ecore_evas_show(ee);


     evas = ecore_evas_get(ee);
     evas_font_path_append(evas, "fonts/");


     background = evas_object_rectangle_add(evas);
     evas_object_color_set(background,30,30,30,255);
     evas_object_resize(background, WIDTH, HEIGHT);
     evas_object_move( background,0 ,0 );
     evas_object_focus_set(background, 1);
     evas_object_show( background);

     handle.size = 64;
     handle.x=(WIDTH-handle.size)/2;
     handle.y=(HEIGHT-handle.size)/2;
     handle.o = evas_object_image_add(evas);
     evas_object_image_file_set (handle.o, "/home/tick/work/e17/icon.png" ,NULL);
     if (evas_object_image_load_error_get(handle.o)) {
             printf("Evas can't load PNG files. Check Evas has PNG\n");
             return 1;
     }
     evas_object_color_set(handle.o,255,255,255,128);
     evas_object_move(handle.o, handle.x,handle.y);
     evas_object_resize(handle.o,handle.size,handle.size);
     evas_object_image_fill_set(handle.o, 0, 0, handle.size, handle.size);
     evas_object_show(handle.o);

     printf("Please press 1+2 to connect Wii remote!!\n");
     handle.wii = wiimote_open(argv[1]);
     if (!handle.wii) {
             fprintf(stderr, "unable to open wiimote:\n");
             exit(1);
     }
     printf("Connecting.......\n");
     set_wiiremote(handle.wii);
     ecore_timer_add(.01,scan_wii_event, &handle);
     ecore_main_loop_begin();

     return 0;
}

使用:
1．先下 /etc/init.d/bluetooth start 打開bluetooth
2．按下 Wii remote 的 1+2 鍵
3．當 Wii remote 的Led 還在閃時，做 hcitool scan 找出你的 remote bdaddr
4． compile 完程式後，打 ./wii_toy 00:1A:E9:3B:CA:49 <--- 每個人的 wii remote 不一樣就可以玩了


tick@tock:~/work/e17>hcitool scan
Scanning ...
     00:1A:E9:3B:CA:49       Nintendo RVL-CNT-01
tick@tock:~/work/e17>gcc `pkg-config --libs ecore-evas evas` -I/usr/local/include/libcwiimote-0.4.0/libcwiimote/ -lcwiimote -lbluetooth -Wall -pipe -D_ENABLE_TILT -D_ENABLE_FORCE  -g2 -o wii_toy wii_toy.c
tick@tock:~/work/e17>./wii_toy 00:1A:E9:3B:CA:49
Please press 1+2 to connect Wii remote!!
Connecting.......

有圖有真象

學習 Evas

2008-01-13T14:05:00.000+08:00

這陣子開始需要用 Evas 寫一些東西…
個人覺得學一個 library 最快的方法就是去真的拿它去寫程式。
如我的一個好友常說的：學中作，作中學 ^^
所以就寫了支小小的玩具… 和大家分享…

亂畫一個方塊，設定一個重力場，和一個 boundary反彈機制. ( 和一些阻泥 (mark 掉了)) 加上一個色彩空間的旋轉。就玩起來了 ^^

程式:

Filename: toy.c


#include <Ecore_Evas.h>
#include <Ecore.h>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>

#define WIDTH 400
#define HEIGHT 400

Ecore_Evas  *   ee;
Evas        *   evas;
Evas_Object *   base_rect;

double rotation[3][3] = { {0 , 0 , 1},
                          {1, 0, 0}, 
                          {0   , 1, 0}
};

struct bouncer {
        Evas_Object *o;
        int w,h;
        double xs,ys;
        double x,y;
        double color[3];
}; 

inline void change_color(struct bouncer *bounce) {
        double X[3];
        int i,j;
        int R,G,B;
        for (i=0;i<3;i++) {
                X[i]=bounce->color[i];
                bounce->color[i]=0;
        }
        for (i=0;i<3;i++) {
                for (j=0;j<3;j++) {
                        bounce->color[i] += rotation[i][j]*X[j];
                }
        }
        R=bounce->color[0] < 0 ? bounce->color[0] + 255: bounce->color[0];
        G=bounce->color[1] < 0 ? bounce->color[1] + 255: bounce->color[1];
        B=bounce->color[2] < 0 ? bounce->color[2] + 255: bounce->color[2];
        evas_object_color_set( bounce->o , R, G, B, 255);
}

inline void center(struct bouncer *bounce,double *x,double *y) {
        *x = bounce->x + bounce->w/2;
        *y = bounce->y + bounce->h/2;
}

inline void grav(struct bouncer *bounce) {
        const double G=300;
        double Gx,Gy,Gs;
        double x,y;
        double dist;
        center(bounce,&x,&y);

        dist = pow(pow(WIDTH/2-x,2) + pow(HEIGHT/2-y,2),0.5);
        Gs = G/pow(dist,2);
        Gx = (WIDTH/2 - x)/dist;
        Gy = (HEIGHT/2 -y)/dist;
        Gx = Gx * Gs;
        Gy = Gy * Gs;

        bounce->xs += Gx;
        bounce->ys += Gy;

        // Slow down~~
        //bounce->xs = abs(bounce->xs) > 13 ? bounce->xs *(1/ pow(bounce->xs-10,2)): bounce->xs;
        //bounce->ys = abs(bounce->ys) > 13 ? bounce->ys *(1/ pow(bounce->ys-10,2)): bounce->ys;
        printf ("x=%2.2f y=%2.2f dist=%4.2f Gs=%2.2f Gx=%2.2f Gy=%2.2f xs=%2.2f ys=%2.2f\n",x,y,dist,Gs,Gx,Gy,bounce->xs,bounce->ys);
}
inline void calculate_pos(struct bouncer *bounce) {
        grav(bounce);
        bounce->x += bounce->xs;
        bounce->y += bounce->ys;

        // bounce 
        bounce->xs = bounce->x >=0 ?  bounce->x + bounce->w <= WIDTH ? bounce->xs : -bounce->xs : -bounce->xs; 
        bounce->ys = bounce->y >=0 ? bounce->y + bounce->h <= HEIGHT? bounce->ys : - bounce->ys : - bounce->ys;
}

int move(void *data) {
        struct bouncer *bounce =(struct bouncer *)data;
        calculate_pos(bounce);
        evas_object_move(bounce->o,bounce->x,bounce->y);
        change_color(bounce);
        return 1;
}

int main() {
        struct bouncer bounce;
        ecore_evas_init();

        ee = ecore_evas_software_x11_new(NULL, 0,  0, 0, WIDTH, HEIGHT);
        ecore_evas_title_set(ee, "Tick's Evas Study");
//      ecore_evas_borderless_set(ee, 1);  // borderless
        ecore_evas_borderless_set(ee, 0);  // border
        ecore_evas_show(ee);


        evas = ecore_evas_get(ee);
        evas_font_path_append(evas, "fonts/");


        bounce.o = evas_object_rectangle_add(evas);
        bounce.w=bounce.h= (double)WIDTH/4;
        bounce.x=(double)(WIDTH - bounce.w)/3;
        bounce.y=(double)(HEIGHT-  bounce.h)/6;
        bounce.xs=-1.1; bounce.ys=1.1;
        bounce.color[0]=128;
        bounce.color[1]=64;
        bounce.color[2]=255;
        change_color(&bounce);
        evas_object_resize( bounce.o,  bounce.w,  bounce.h);
        evas_object_move( bounce.o,bounce.x,bounce.y);
        evas_object_show( bounce.o);

        ecore_timer_add((double)0.01,move,&bounce);

        ecore_main_loop_begin();

        return 0;
}

codecovert

2008-01-09T15:53:00.000+08:00

Covert C code to Google prettyprint format

Filename: /usr/local/bin/codecovert


#!/bin/bash
for FF in $@;
do
      if [ -e $FF ];then
              echo Filename: $FF
              echo "<pre class=\"prettyprint\">"
              sed    -e 's/&/\&amp;/g'  -e 's/</\&lt;/g' -e 's/>/\&gt;/g'   $FF
              echo "</pre>"
      fi
      echo
done

Hello world

2008-01-09T15:26:00.000+08:00


BITS 32

;section .text
;global _start
;_start:
jmp short two

one:
pop ecx  ; using the db
; write
xor eax,eax
mov al, 4
xor ebx,ebx
mov bl, 1
xor edx, edx
mov dl, 13
int 0x80

;exit
xor eax,eax
mov al, 1
xor ebx, ebx
int 0x80

two:
call one
db      "Hello_World!!"

Warning of "system" and "pipe"

2008-01-09T14:33:00.001+08:00

I chatted with my friend about some security issues days before. I had mentioned about the function call "system" and "pipe" shall be avoid in many cases. It's very simple idea, but as I know many programmers even do not know it's very dangerous.
Please NEVER NEVER NEVER use this function to important programs.
NEVER allow user to touch the args, or PATH.
Please~~~


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void fake_ls(int args,char **argv) {
     char buf[50];
     char *ptr=buf;
     int i;
     sprintf(buf,"ls");
     for (i=1;i<args;i++) {
             ptr = buf + strlen(buf);
             sprintf(ptr," %s",argv[i]);
     }
     printf("The command you send is: '%s'\n",buf);
     system(buf);
}
int main (int args,char **argv) {
     printf("argv=%p\n",argv);
     fake_ls(args,argv);
}

you can use the following argument to execute
extra command: "-al\;cat /etc/passwd"
It's very easy to see how terrible it is. :-)

新年快樂

2007-12-30T21:26:00.000+08:00

2007 年再 26.5 小時後就結束了…
發生了好多事。

希望 2008 年是會大好年。

Quilt － Patches 整合 Script

2007-11-03T13:13:00.000+08:00

在社群中開發程式往往是用 patch 來做來開發工具。
Developer 會在 mail list 上發 patch 出來，而 Maintainer 會把這些 patches 整合起
個，做好 review 再一個一個 commit 上 mainstream 之中。而當 Patch 的量很大，而又>有相依性之時…
一個 Open Source Project 的 Maintainer 要如何管理這些 Patch 呢？

[Quilt]就是這樣的一個好用的工具。

假設今天你在 maintain 一個案子，叫 ”mypro“ 放在 /work/mypro 底下而你拿到了 5 個
patches
001_ooxx.patch
002_lalal.patch
003_lele.patch
004_bad.patch
005_conflict.patch

你可以在 /work/mypro/ 下建立一個 patches 的目錄（如果想自已指定請 export QUILT_PATCHES="...."）
把 patches 放在 /work/mypro/patches 之中
再建一個檔案 /work/mypro/patches/series 把這五個patches 依序寫入 series 中，一行一個 patch, 如果有base 目錄不同的問題 (quilt default 是打 patch -p1) 可在後面加上 -p.
假設 003_lele.patch 這個 patch 是在 /work/mypro 下用 svn diff > 003_lele.patch 做出來的, 那在 series 之中就要寫成：
003_lele.patch -p0

所以 series 就會變成
---------------------
001_ooxx.patch
002_lalal.patch
003_lele.patch -p0
004_bad.patch
005_conflict.patch
---------------------

如此設好之後，就可以用 "quilt push" 打 patch ，用 "quilt pop " 退回上層…
如果要一次打完所有 patch 可以用 quilt push -a 一次打完…想退回 code base 時，就用 quilt pop -a 一路退到底。

可以用 quilt top 看你上一個打的 patch 是那個 patch ，用 quilt next 看下一個是那個 patch
如果發現 patch 有些地方需要修改，可以用quilt edit <檔案> 做修改…修改好了之後，可以用 quilt refresh 把修改寫入 "上一個打的 patch" ，也就是 quilt top 看得到的那個。

如果要寫新的 patch 可以用 quilt new ，加上 quilt edit <要修改的檔名>，做完後用 quilt refresh 把 diff 寫入 patch。

因為你打了多個 patch 之後 svn diff 就會混合了多個 patch ，如果只想看上個打的 patch 的影響可用 quilt diff 來看。

一般來說，如果你要手動修改你的 series 檔。可先 quilt pop -a 退回 code base 再做修改…如手動 mark 掉一些patch 或加上註解，註解是由 '#' 做為開頭。

如果code base 改變了…可 quilt pop -a 退回開頭，再 svn update (cvs )，再把一些已被 commit 的 patch remove 掉（這個要檢查一下，一般來說有 commit 都會說明 commit 了那些 patch ），再一個一個 push 回來

而如果你想 commit code 時，也可一面 push 一面 commit 。等 commit 完了，再把 series 裏已 push 且 commit 的 patch mark 掉，然後直接砍掉 /work/mypro/.pc 這個目錄…這是 quilt 管理 diff 的目錄…如此就可以直接可 upstream 同步。 (如果你是 maintainer )

當你要 release patch 到 mail list 前，可以把你的 code base 的版號（最好是 HEAD），和你之前相依的 patch （如果有的話），一起 release 出來。如果 release 的 patch 多於兩個。最好也把 series release 出來。

--
Reference:
How To Survive With Many Patches or Introduction to Quilt

十年

2007-10-28T22:12:00.000+08:00

人總是在失去後才覺得珍貴。

這幾天正好是我們認識十週年，雖然分手好一段時間了，而我們又各自有了新的戀情。
聽到這首歌，份外有感覺。

對不起，我們錯過了…


十年 - 陳奕迅     曲︰陳小霞   詞︰林夕    編︰陳輝陽
   如果那兩個字沒有顫抖
   我不會發現我難受
   怎麼說出口　也不過是分手
   如果對於明天沒有要求
   牽牽手就像旅遊　成千上萬個門口
   總有一個人要先走

 懷抱既然不能逗留　何不在離開的時候
   一邊享受　一邊淚流

 十年之前　我不認識你
   你不屬於我　我們還是一樣
   陪在一個陌生人左右
   走過漸漸熟悉的街頭

 十年之後　我們是朋友
   還可以問候　只是那種溫柔
   再也找不到擁抱的理由
   情人最後難免淪為朋友

   直到和你做了多年朋友
   才明白我的眼淚　不是為你而流
   也為別人而流

Stack Dump Debug Tip

2007-10-22T23:46:00.001+08:00

In developing embedded system, developer may encounter an ambiguous condition that the system so limited that cannot run gdb, and the network is also too unstable to run gdb-server. And the rootfs is too small that core dump is not available. In such miserable condition there is still a powerful debug skill: stack dump.

Before using this skill, we have to know how a program runs. The stack's bottom is at higher address in memory, and it growth toward lower address.

And program accesses memory from low to high. That is we can use printf("%x %x"); to print out the data in stack.

Another important tip is CFLAGS += -finstrument-functions. This flag make us can insert code when entering and exiting a function. This way, we can construct our own stack dump without the help of gdb. If you turn the flag -finstrument-functions on, you should implements the following two functions:
void __cyg_profile_func_enter(void *func,void *caller) __attribute__((__no_instrument_function__));
void __cyg_profile_func_exit(void *func,void *caller) __attribute__((__no_instrument_function__));

These functions are designed for profiling and analysing code performance and coverage. In this case use use it to create a function stack.

We can use signal() to set the signal handler to dump the stack when a signal received.

Here are the demo codes:


----------------------------------------------------------------
### File: Makefile
CFLAGS=-finstrument-functions -g2
CC=gcc

all:
 gcc $(CFLAGS) -o stackdemo stackdemo.c stack_util.c
----------------------------------------------------------------
/** @file stack_util.h
*  @auther Tick
*  @License GPL
*/

#ifndef __TICK_DEMO_STACK___
#define __TICK_DEMO_STACK___

void setSignalHandler();
void SignalHandler(int) __attribute__((__no_instrument_function__));
void DumpStack(int sig) __attribute__((__no_instrument_function__));
void __cyg_profile_func_enter(void *func,void *caller) __attribute__((__no_instrument_function__));
void __cyg_profile_func_exit(void *func,void *caller) __attribute__((__no_instrument_function__));

#endif
----------------------------------------------------------------
/** @file stack_util.c
*  @auther Tick
*  @License GPL
*/

#include "stack_util.h"

#include <signal.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>

#include <stdio.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/ioctl.h>


#define _STACK_BUFFER_SIZE 4096
void *__stack_buffer_[_STACK_BUFFER_SIZE];
int __stack_pid_buffer[_STACK_BUFFER_SIZE];
int __stack_buffer_index__private__ =0;
volatile int __stack_spin_lock__=0;
inline void dumpstack() {
int i,max=__stack_buffer_index__private__;
printf("Stack Trace:\n");
for (i=0;i<__stack_buffer_index__private__;i++) {
 printf("[%3d] pid:[%3d]   0x%08x\n",i,__stack_pid_buffer[i],__stack_buffer_[i]);
}
}

void setSignalHandler() {
int ans;
struct sigaction act,oldact;
act.sa_handler=DumpStack;
act.sa_flags= SA_ONESHOT | SA_NOMASK;
//act.sa_flags= SA_RESETHAND;
ans=sigaction(SIGUSR1,&act,&oldact);
if (ans) {
 printf("Set SIGUSR1 Failed!!!!!\n");
 printf ("ErrorNumber: %d\n",errno);
}else {
 printf("Set SIGUSR1 OK!!!!!\n");
}

signal(SIGHUP,SignalHandler);
signal(SIGINT,SignalHandler);
signal(SIGQUIT,SignalHandler);
signal(SIGILL,SignalHandler);
signal(SIGKILL,SignalHandler);
signal(SIGSEGV,SignalHandler);
signal(SIGTERM,SignalHandler);
signal(SIGPWR,SignalHandler);
}

void DumpStack(int sig) {
struct sigaction act,oldact;
act.sa_handler=DumpStack;
act.sa_flags= SA_ONESHOT | SA_NOMASK;
sigaction(SIGUSR1,&act,&oldact);

printf("Stack:\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n");

printf ("Signal Type: %d\n",sig);
printf ("ErrorNumber: %d\n",errno);
printf ("PID: %d\n",getpid());
dumpstack();
}

void SignalHandler(int sig) {
if (sig==SIGTERM || sig==SIGKILL) {

 //close device here
}
if (sig==SIGTERM) {
 printf ("Signal Type: %d\n",sig);
 printf ("PID: %d goes die\n",getpid());
 fflush(stdout);
 fflush(stderr);
 sleep(1);
 exit(0);
}

printf("Stack:\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n");

printf ("Signal Type: %d\n",sig);
printf ("ErrorNumber: %d\n",errno);
printf ("PID: %d\n",getpid());
printf ("\n");
dumpstack();
fflush(stdout);
fflush(stderr);
if (sig==SIGSEGV || sig==SIGILL) {
 //exit(EXIT_FAILURE);
 // If you want to kill whole tick when page fault happens
 // please USE "exit(EXIT_FAILURE);"
 _exit(129);
}
}


void __cyg_profile_func_enter(void *func,void *caller) {
while (__stack_spin_lock__) ;
__stack_spin_lock__=1;
if (__stack_buffer_index__private__ < _STACK_BUFFER_SIZE) {
__stack_buffer_[__stack_buffer_index__private__]=func;
__stack_pid_buffer[__stack_buffer_index__private__]=getpid();
__stack_buffer_index__private__++;
}
__stack_spin_lock__=0;
}
void __cyg_profile_func_exit(void *func,void *caller) {
while (__stack_spin_lock__) ;
__stack_spin_lock__=1;
int i,pid=getpid();
if (__stack_buffer_index__private__ > 0) {
 for (i=__stack_buffer_index__private__-1;i >0;i--) {
     if (__stack_pid_buffer[i]==pid) {
         break;
     }
 }
 for (;i<__stack_buffer_index__private__-1;i++) {
     __stack_buffer_[i]=__stack_buffer_[i+1];
     __stack_pid_buffer[i]=__stack_pid_buffer[i+1];
 }
 __stack_buffer_index__private__--;
}
__stack_spin_lock__=0;
}
----------------------------------------------------------------
/**
* @file stackdemo.c
* @author Tick
* @license GPL
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <ctype.h>
#include "stack_util.h"

struct LALA {
int data;
int lala;
};

void run_me_will_crash_null_point () {
struct LALA *lala=NULL;
lala->lala++;
}

void run_me_will_crash_divid_zero() {
int a=1;
int b= 200/ --a;
}

void run_me_will_crash_buffer_overflow() {
char buf[4];
char *src;
src =(char *) malloc (64);
memset(src,'A',64);
memcpy(buf,src,64);
}


void prompt() {
printf("What way do you want to die?\n");
printf("1. segment fault\n");
printf("2. divid zero\n");
printf("3. buffer overflow\n");
printf("> ");
}

void do_die () {
char buf[128];
while(1) {
 prompt();
 fgets(buf,sizeof(buf),stdin);
 if (isdigit(buf[0])) {
     switch (buf[0]) {
         case '1':
             run_me_will_crash_null_point();
             break;
         case '2':
             run_me_will_crash_divid_zero();
             break;
         case '3':
             run_me_will_crash_buffer_overflow();
             break;
         default:
             continue;
     }
 }
}
}

void showmaps() {
char buf[128];
sprintf(buf,"cat /proc/%d/maps",getpid());
system(buf);
}

void function_D() {do_die();}
void function_C() {function_D();}
void function_B() {function_C();}
void function_A() {function_B();}
int main (void) {
setSignalHandler();
showmaps();
function_A();
}
----------------------------------------------------------------

The following is the execution result:

----------------------------------------------------------------


tick@tock:~/work/demo>./stackdemo
Set SIGUSR1 OK!!!!!
08048000-0804a000 r-xp 00000000 08:03 127325     /home/tick/work/demo/stackdemo
0804a000-0804b000 rw-p 00001000 08:03 127325     /home/tick/work/demo/stackdemo
0804b000-08053000 rw-p 0804b000 00:00 0          [heap]
b7dc7000-b7dc8000 rw-p b7dc7000 00:00 0
b7dc8000-b7f0c000 r-xp 00000000 08:03 121895     /lib/tls/i686/cmov/libc-2.6.1.so
b7f0c000-b7f0d000 r--p 00143000 08:03 121895     /lib/tls/i686/cmov/libc-2.6.1.so
b7f0d000-b7f0f000 rw-p 00144000 08:03 121895     /lib/tls/i686/cmov/libc-2.6.1.so
b7f0f000-b7f12000 rw-p b7f0f000 00:00 0
b7f25000-b7f28000 rw-p b7f25000 00:00 0
b7f28000-b7f42000 r-xp 00000000 08:03 121912     /lib/ld-2.6.1.so
b7f42000-b7f44000 rw-p 00019000 08:03 121912     /lib/ld-2.6.1.so
bfc0f000-bfc24000 rw-p bfc0f000 00:00 0          [stack]
ffffe000-fffff000 r-xp 00000000 00:00 0          [vdso]
What way do you want to die?
1. segment fault
2. divid zero
3. buffer overflow
> 1
Stack:
0x00000001 0xbfc22948 0xffffe420 0x0000000b 0x00000033 0xc02f0000 0x0000007b 0x0000007b
0x00000000 0xb7f42ce0 0xbfc22948 0xbfc22920 0xb7f0dff4 0x00000000 0xb7f0dff4 0x00000000
0x0000000e 0x00000004 0x08048837 0x00000073 0x00210286 0xbfc22920 0x0000007b 0x00000000
0x00000000 0x00000004 0xb7f38068 0x00000011 0x00000008 0xb7f42ff4 0xb7f28468 0xb7f28000
0xbfc226e8 0xbfc22704 0x00000000 0xbfc22800 0xbfc226dc 0xbfc22768 0xb7df2b5a 0xbfc22818
0xbfc226e8 0x00000080 0x00000000 0x00000000 0xb6d55b68 0x00000000 0x00000000 0x00000000
0x00000000 0xb7f27db4 0xb7f303e2 0xb7f12000 0x00013425 0xb7f42ff4 0xbfc22aa4 0xb7f2b22b
0xb7f432a0 0xb7f43820 0x00000000 0x00000000 0x00000000 0x00000000 0xbfc2286c 0x00000000
0xbfc227d4 0xb7df2b13 0xbfc227e0 0xb7f0ef64 0x00000080 0x08048ec0 0x10000000 0xb7f27b38
0x00000004 0x080484f4 0x0d696910 0xb7f27b38 0xbfc2279c 0xb7f30c0b 0xb7dd9df6 0x080484ea
0xb7f43941 0x080484ea 0x0d696913 0xb7f27b48 0xbfc227bc 0xb7f30c0b 0xb7dd9e74 0x080484e0
0xb7f43941 0xb7f43934 0xb7dd0dac 0xbfc2000d 0xb7f35c99 0x080483e8 0xb7f43940 0xb7f42ff4
0xbfc22800 0xb7f27b0c 0xbfc22834 0xb7f30fc0 0xb7e2e0d4 0xb7e983b8 0xb7f0e440 0xb7f0dff4
0xb7f3efbc 0xbfc22800 0xbfc228e4 0x22494966 0x00000003 0xb7dcbc4c 0xb7dcada0 0xffffffff
0x22494966 0x0000000b 0xbfc22828 0x00000000 0x00000000 0x00000001 0x00000516 0xb7f27b48
0xb7f27858 0x08048467 0xb7dd485c 0x08048308 0x00000001 0xb7f42ff4 0xb7f43820 0xbfc228d8
0xbfc228f4 0xb7f31166 0x08048308 0xbfc228d8 0xb7f437c4 0x00000001 0xb7f27b48 0x00000001
0x00000000 0x00000001 0xffffffff 0xbfc22884 0xb7e2c179 0xb7f0e4e0 0xb7f25000 0x00000002
0xbfc228a4 0xbfc228e4 0xbfc22920 0xb7f43668 0x08048467 0x22494966 0x00000000 0x00000000
0x00000400 0xb7f0dff4 0xb7f0e440 0x00000000 0xbfc228b4 0xb7e2d50b 0xb7f0e440 0xb7f0e440
0xbfc228cc 0xb7e2e8d4 0xb7f0e440 0xb7e2b86f 0xb7f0dff4 0xb7f24001 0x00000001 0xb7e2206d
0xbfc22975 0xb7dd0dac 0xb7f27858 0x00000001 0xffffffff 0xb7f42ff4 0x08048308 0xb7f43668
0xbfc22930 0xb7f34e73 0xb7f43820 0xb7f27b48 0x00000001 0x00000001 0x00000000 0x0077b858
0x80cd0000 0xbfc22948 0x0804882d 0x08048814 0x08048ac2 0xb7f42ce0 0x00000000 0xbfc229f8
0xb7f3a660 0xb7f0f0c4 0xbfc22974 0xb7dec4d0 0x00000000 0xbfc229f8 0x08048ac2 0xbfc22974
0x00000080 0xb7f0e440 0xb7f27858 0x00000000 0x00000031 0xb7f42ff4 0x08048298 0xb7f43668
0xbf000a31 0xb7f34e73 0xb7f43820 0xb7f27b38 0x00000001 0x00000001 0x00000000 0x0804847c
0x00000006 0x00000000 0x0804acc4 0xb7dd106c 0xb7dff940 0xbfc229b4 0x08049039 0xbfc22a78
0x0000188d 0x00000000 0xb7f0dff4 0x00000001 0x0000188c 0xbfc22a78 0x08048b3f 0x08048ad8
0x08048c4c 0x0000188c 0x0d696910 0x00000000 0x080f0d30 0x08048e34 0x08048ff7 0xbfc22a98
0xff0a0000 0xbfc22a18 0x08048b70 0x08048b52 0x08048ba3 0xb7f42ff4 0x08048ff7 0xb7f43668
0xb7f0dff4 0xbfc22a38 0x08048ba3 0x08048b85 0x08048bd6 0x00000001 0x08048ff7 0x0804843b
0xb7f0dff4 0xbfc22a58 0x08048bd6 0x08048bb8 0x08048c09 0xb7f42ce0 0x08048ff7 0xbfc22a78
0xb7f0dff4 0xbfc22a78 0x08048c09 0x08048beb 0x08048c51 0xb7e5bc08 0xc0000000 0xb7ed2939
0xff0a0000 0xbfc22a98 0x08048c51 0x08048c1e 0xb7dde050 0xbfc22aa8 0x080490f9 0xb7f35800
0xbfc22ab0 0xbfc22b08 0xb7dde050 0xb7f42ce0 0x080490e0 0xbfc22b08 0xb7dde050 0x00000001
0xbfc22b34 0xbfc22b3c 0xb7f43820 0x00000000 0x00000001 0x00000001 0x00000000 0xb7f0dff4
0xb7f42ce0 0x00000000 0xbfc22b08 0x90556081 0xafc02a91 0x00000000 0x00000000 0x00000000
0xb7f3a660 0xb7dddf7d 0xb7f42ff4 0x00000001 0x08048790 0x00000000 0x080487b1 0x08048c1e
0x00000001 0xbfc22b34 0x080490e0 0x080490d0 0xb7f35800 0xbfc22b2c 0xb7f3fead 0x00000001
0xbfc23864 0x00000000 0xbfc23870 0xbfc23883 0xbfc238ba 0xbfc238ca 0xbfc238de 0xbfc238e9
0xbfc23938 0xbfc23953 0xbfc2398c 0xbfc2399e 0xbfc239a8 0xbfc23c23 0xbfc23c59 0xbfc23c89
Signal Type: 11
ErrorNumber: 22
PID: 6284

Stack Trace:
[  0] pid:[6284]   0x08048c1e
[  1] pid:[6284]   0x08048beb
[  2] pid:[6284]   0x08048bb8
[  3] pid:[6284]   0x08048b85
[  4] pid:[6284]   0x08048b52
[  5] pid:[6284]   0x08048a1e
[  6] pid:[6284]   0x08048814
[  7] pid:[6284]   0x08048c70

----------------------------------------------------------------
You can use "objdump -S -x stackdemo ｜ less" to find out the address's corresponding function.

. If the function crashed in library, you can using the address - the address of library (shown in /proc/xxx/maps) and find out the offset. This offset is the crash point in library. (using objdump)

簡易版 Minicom

2007-09-23T15:18:00.000+08:00

昨天坐車下南部，在車上心血來潮想在 NEO1973上玩Minicom 結果發現手上沒有 minicom的 package。人在車上又沒有網路…想玩東西又沒得玩…就自已寫嘍…
然後就在車上開始 coding ...
發現還蠻有趣的，大概到台中的時候完成，之後就在車上一直玩…
玩到 Notebook 沒電 @_@ 4 cell 的電池果然是不夠力啊

執行檔是 tickminicom
使用方法是 ./tickminicom [device] [speed]
default 的 device 是 /dev/ttySAC0 ，speed 是 115200
跳脫字元是 '%'

因為是自已寫的，所以可以很直接的測試幾個想知道的性質…

Filename: Makefile


CC=arm-angstrom-linux-gnueabi-gcc
all:
  $(CC) -o tickminicom tick_minicom.c util.c
  gcc -o tickminicom_x86 tick_minicom.c util.c

Filename: debug.h


#ifndef __MPENV_DEBUG_H__
#define __MPENV_DEBUG_H__

#include <assert.h>

#define CONFIG_DEBUG

#ifdef CONFIG_DEBUG
 #include <stdio.h>
 #define debug(f, a...)                                             \
do{                                                             \
  printf ("DEBUG: (%s, %d): %s: ",__FILE__, __LINE__, __FUNCTION__);      \
  printf (f, ## a);                               \
} while (0)
 #else
    #define debug(f, a...)
#endif

#define error(f, a...)                                             \
do{                                                             \
  printf ("ERROR: (%s, %d): %s: ",__FILE__, __LINE__, __FUNCTION__);      \
  printf (f, ## a);                               \
} while (0)


#endif

Filename: util.h


#ifndef __TICK_MINICOM_UTIL_H__
#define __TICK_MINICOM_UTIL_H__

#include <termios.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>

/// Be aware 'x' cannot be a expression or this function cause unpredicable result.
#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))

struct bdrt {
int bps;
u_int32_t b;
};

static struct bdrt bdrts[] = {
  { 0, B0 },
  { 9600, B9600 },
  { 19200, B19200 },
  { 38400, B38400 },
  { 57600, B57600 },
  { 115200, B115200 },
  { 230400, B230400 },
  { 460800, B460800 },
  { 921600, B921600 },
};

int getche(int fd);

int open_device(char *device,int speed);

int set_baud(int fd,int rate);

#endif

Filename: util.c


#include "util.h"
#include "debug.h"
#include <string.h>

int getche (int fd) {
  int i;
  char ch;
  struct termios old, new;
  tcgetattr (fd, &old);
  memcpy (&new,&old, sizeof (struct termios));
  new.c_lflag = ~(ICANON | ECHO);
  tcsetattr (fd, TCSANOW,&new);
  i = read (fd,&ch, 1);
  tcsetattr (fd, TCSANOW, &old);
  if (i == 1) {
          return ch;
  }
  else {
      debug("fd %d ERROR\n",fd);
      return -1;
  }
}

int set_baud(int fd,int rate) {
int i,rt;
u_int32_t bd = 0;
struct termios ti;
for (i = 0; i < ARRAY_SIZE(bdrts); i++) {
  if (bdrts[i].bps == rate) {
      bd = bdrts[i].b;
      break;
  }
}
if (bd==0) {
  error("Cannot set Baud Rate!!\n");
  return -1;
}
rt = tcgetattr(fd, &ti);
if (rt<0) {
  error ("Cannot get attr i=%d\n",rt);
  return rt;
}
rt = cfsetispeed(&ti, B0);
if (rt<0) {
  error("Cannot set input baud to B0!!\n");
  return rt;
}
debug("Open uart with speed %d\n",bdrts[i].bps);
rt = cfsetospeed(&ti, bd);
if (rt < 0) {
  error("Cannot set baud rate %d\n",bdrts[i].bps);
  return rt;
}
ti.c_cflag |= CRTSCTS;  // hardware control
return tcsetattr(fd, 0, &ti);
}

/**
* Open Uart for testing
* return value is the fd
*/
int  open_device (char *device,int speed) {
int fd;
if (device==NULL) {
  error("device is invalid (NULL pointer)\n");
  return -1;
}
debug("Try to open device %s!\n",device);
fd = open(device,O_RDWR);
if (fd < 0) {
  error("cannot open uart %s, fd is %d\n",device,fd);
  error("%s\n",strerror(errno));
  return -1;
}
if (set_baud(fd,speed) < 0)  {
  error("Set Baud rate failed!!\n");
  return -1;
}
return fd;
}

Filename: tick_minicom.c


/**
* @file tick_minicom.c
* @brief a tiny uart client
* @license GPL (General Public License)
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include "debug.h"
#include "util.h"

#define DEFAULT_UART "/dev/ttySAC0"
#define DEFAULT_BAUD 115200

static int keep_run=1;



/// Set '%' as the escape code
void input_command(int input,int output)  {
int i;
char buf[1];
while(keep_run)  {
  i=getche(input);
  if (i< 0) {
      debug("file closed!!\n");
      keep_run=0;
      break;
  }
  if (i=='%') {
      debug("User entered the escape code.\n");
      debug("Exiting program!\n");
      keep_run=0;
      break;
  }
  buf[0]=i;
  write(output,buf,1);
}
}

void read_from_uart(int input,int output) {
int i;
char buf[1];
while (keep_run) {
  i=getche(input);
  buf[0]=i;
  i=write(output,buf,1);
}
}

int main (int args,char **argv) {
int uart;
int pid;
char buf[128];
if (args==1) {
  uart=open_device(DEFAULT_UART,DEFAULT_BAUD);
} else if (args==2) {
  uart=open_device(argv[1],DEFAULT_BAUD);
} else {
  uart=open_device(argv[1],atoi(argv[2]));
}
if (uart<0) {
  error("Open device failed !!\n");
  return 0;
}else {
  debug("Open Uart and set baud rate OK!!\n");
}
keep_run=1;
pid=fork();
if (pid) {  // parent
  input_command(0,uart);
  debug("Exiting Tick's minicom\n");
}else {  // child
  pid = getppid();
  read_from_uart(uart,1);
  debug("Try to close uart\n");
  debug("Result of close uart=%d\n",close(uart));
}
sprintf(buf,"kill -9 %d",pid);
system(buf);
}

MPENV

2007-09-08T14:37:00.000+08:00

大概在一年多前使用 QT2 寫了一些Embedded System 的 MMI，
因為某些外在因素整體架構有點亂。
而在當時就開使構思寫一個精簡的 MMI Framework.
定義一些在 Embedded System MMI 的寫作方式，資源控管等東西…
目標是讓降低 Programmer 寫 MMI 時要顧慮的東西，如 status，resource，
只要專心寫要寫的東西就好了。

幾個月前和幾個朋友聊到這個想法，也就在 SourceForge 註冊了這個案子.
MPENV (Modulized Pages Environment)

簡單來說，就是用 MVC 的架構來寫一個 MMI Framework.
目前我們只定義了 Module 和 Pages 的介面及跳躍方式。
離目標還有一大段的距離。不過我們正在努力。

我們使用C++，GTK/GLib 為開發平台，目前不使用 GTKmm。
而 UI component 是用手寫 or gtk_builder 做出來。

這幾天還在想如何把 controller 實做出來 :P

目前有一大堆手寫文件，希望在不久的將來我可以把文件整理一下寫個 SDS 再向大家介紹它。

--
文筆不好, 真是苦手啊 ~_~
ToDo: 表達能力

One Day Off

2007-08-17T20:13:00.000+08:00

西元 2007 年 8 月 17 日颱風天

這幾天天氣相當的不穩定，小弟連續磕了幾天的普拿疼後，昨天一整天完全沒有工作情緒，今天終於決定不去上班了。
只想好好的睡一覺。好好的放鬆一下。

睡到了十點，恣意的發呆了一下，頭也比較不痛了。
下午到家附近學生時期常去的水餃店吃了中餐，好久沒去那家店了，沒想到老闆還跑來和我聊了一下天，他們以為我搬家了 :P

吃完中餐，發了點小瘋，突然想回台大看看。也就去了。台大多出了許多建築物，舟山路也變成學校的一部分。

颱風越來越大，一個人在校園裏漫遊。回想起那一段刻骨銘心的感情。埸景依舊，兩人依偎的身影卻只在回憶之中。

到新總圖，四樓左側最後面坐了下來。暑假期間，沒什麼人。這是我大學最喜歡的位子，離我喜歡的書很近。大學時，有數不盡的時光泡在這裏。一個人靜靜的慢慢回味。

我很喜歡坐在這裏，人生中有許多重大的決定，很多新的想法，讀出心得，感受出知識的威力都在這裏發生。

畢業多年，回到這裏，也是在思考人生的走向，我們在這時代，我們背負的責任。我是否對得起多年前坐在這心中充滿理想的小子。

回到系館教室，獨自一人坐在裏頭。這是我大學時代最後一次考試的教室。也是在這間教室之中，我聽到一位老師說： Java 的 try catch 改善了過去 C 語言中例外處理的弱勢，這是一個新發明，是專家們深入研究程式語言後的發明。而未來做這件事的人，就是在座的各位。

是的，也許我要更加的努力。

毀壞 Partition 之 Office 2003 Word 救援

2007-08-13T23:48:00.000+08:00

身為一名軟體工程師，常常會被親戚朋友問一堆怪怪的電腦問題。
昨天就收到了兩個壞掉的隨身碟。一個 512 MB 另一個 1G 。
它們的 MBR 和 superblock 都被病毒給毀了

可是裏面的 Doc 檔又特別重要… ~_~

身為一個好人，為了未來的幸福…當然義不容辭一定要把它們救回來嘍

以下是我的救援 steps
1. 把 flash 插入可愛的 Linux 機器中。
"dmesg" check 一下是否硬體壞掉。
硬體 OK 但沒有 partition info
2. 用 "fdisk /dev/sda" check MBR
ok 真的爛了 @_@
3. 用 dd if=/dev/sda of=honey_512M.img 備份下來

4. check 資料是否完全爛掉，還好，data 還在

因為苦主說明 word 檔很重要~~ 所以就專攻 word 檔嘍
苦主用的是 office 2003，因此小弟就找了幾個 office 2003 的 word check 了一下檔頭檔尾

Good Luck!!
發現大多數的 word 檔檔頭是以 D0 CF 11 E0 A1 B1 1A E1 開頭
以 6F 63 75 6D 65 6E 74 2E 38 00 F4 39 B2 71 結尾
因此先用 hexdump + head + tail 剪一個出來驗證
驗證 OK !!

5. 隨手寫一支小小的程式把這個區段的 word 檔給一個個 copy 出來
雖然不是所有資料都救回來了，但最重要的救回來了就好了 ^_^

6. ./recover honey_512M.img

這個方法可以 recover 回文字量少(小檔案)，沒有使用 macro 的doc 檔
如果檔案較大，大於 block size 那就比較麻煩了，就要去讀file system 的資料
幸運的是，絕大多數的檔案都是小檔案。
如果檔案中有圖片，就很可能變成圖片壞了，文字還是救得回來。

以下是小程式的 source Code:

Filename: recover.c
Composer: Tick
License: GPL


#include <stdio.h>
#include <stdlib.h>
#include <string.h>

const int PREFIX[] = {0xD0, 0xCF, 0x11, 0xE0, 0xA1, 0xB1, 0x1A, 0xE1};
const int SURFIX[] = {0x6F, 0x63, 0x75, 0x6D, 0x65, 0x6E, 0x74, 0x2E, 0x38, 0x00, 0xF4, 0x39, 0xB2, 0x71};

void showExit (char *arg) {
   printf("This program is used to recover MS office files from broken image\n");
   printf("Usage: %s <image file>\n",arg);
}

void recordFile(FILE *foo,char *file,int start,int end) {
   FILE *fp=NULL;
   if (!foo || !file || strlen(file)==0) {
       printf("Invalid file to record (%d,%d)\n",start,end);
       return;
   }
   fp = fopen(file,"w");
   if (fp == NULL) {
       printf("open record file %s failed!!\n",file);
       return;
   }
   fseek(foo,start,SEEK_SET);
   while (ftell(foo) < end) {
       fputc(fgetc(foo),fp);
   }
   fclose(fp);
}


void scanFile(FILE * foo) {
   int c;
   int index=0,index_e=0;
   int start=0,end=0;
   int fid=1;
   char buf[256];
   while (!feof(foo)) {
       c = fgetc(foo);
       //    printf("get 0x%02x at %d PREFIX[%d]=0x%02x\n", c, (int)ftell(foo),index,PREFIX[index]);
       if (c==PREFIX[index]) {
           index++;
       }else {
           index=0;
       }
       if(index==(sizeof(PREFIX)/sizeof(PREFIX[0]))) {
           printf("Get PREFIX at %d index = %d\n",(int)ftell(foo)-index, index);
           start=(int)ftell(foo)-index;
           index=0;
       }

       if (start!=0) {
           if (c==SURFIX[index_e]) {
               index_e++;
           }else {
               index_e=0;
           }
           if (index_e==(sizeof(SURFIX)/sizeof(SURFIX[0]))) {
               end=(int)ftell(foo);
               printf("     File starts at %d end at %d size %d bytes\n",start,end,end-start);
               sprintf(buf,"%04d.doc",fid++);
               recordFile(foo,buf,start,end);
               start=0;
               index_e=0;
           }
       }
   }
}

int main (int args,char **argv) {
   FILE *foo;
   if(args == 1 ) {
       showExit(argv[0]);
       return 0;
   }
   foo = fopen(argv[1],"r");
   if (!foo) {
       printf("Open File %s failed!!\n",argv[1]);
       return 0;
   }
   printf("Open File OK!!\n");
  
   scanFile(foo);
  
   fclose(foo);
}

春待草

2007-07-28T15:57:00.000+08:00

自從聽到黑野宏通大師的曲子後，深深著迷。
其中我最喜歡的就是這首 "春待草"
剛剛突然想把它錄起來…
於是使用 Audacity 和 Lame 錄起壓成 mp3
由於沒有良好的錄音設備，有相當大的背景噪音，請多包涵
和大家分享…

使用笛4C:

另一把 7C

隨手筆記 murmur

2007-07-28T13:06:00.000+08:00

七月天，份外悶熱。不想開冷氣…

難得星期六空閒了一下，左手是 Harry Potter 7 ，右手是 Mozart 小夜曲的譜。
正在恣意的浪費寶貴的假期…

跟了我四年多的 Laptop 越來越怪， device 一個一個壞去，還是撐著用…
想買新的 Laptop
用了十幾年的電視也一直晃動，畫面歪曲變型…
想玩Wii 看來也要買新電視…

Wish List:
Laptop
TV
Wii

啊…又想省錢…
過去的教育一直告訴我，錢要省下來，用來投資做資產分配，
不需要慾望的就要省下來…
未來生活才有保障…

說得容易，可是當慾望和理財衝突時。
看著別人享樂，自己卻努力克制慾望…
心情並不快樂…
Laptop 應該是要買了…因為這是我吃飯的工具…
TV，Wii... 我可能也沒時間看，沒時間玩 ~_~ 先省下來吧… >_<

想做好多事，想玩好多東西。沒時間，就是沒時間…
想多陪陪心愛的人，想做陶笛，吹陶笛，想看 Harry potter，想把一些技術上的心得寫下來，想玩 Wii ，…
Wish List 好長…
而每天工作時間又超長。想省下時間做自己想做的事，真的好難…

可是當真的有時間時，唯一想做的事就是，好好休息…真的太累了…只想躺在床上，好好的睡一覺。

這陣子在工作上看到了許多 "人事" 上的現象，有一些心得…
工作從興趣變成了工作…真是可悲~
賠掉了時間，出賣靈魂，又只賺那麼一點錢…還被別人說是阿宅…
我到底在追求什麼啊？

想讓心愛的人有好的生活，想讓未來能活得更有尊嚴。
想真正做出一些有趣的東西，有趣的事…
想讓台灣的資訊人才能真正的產生應有的價值，創造價值…
建構一流的 Team ，做一流的事…
可是自己光有一點技術，會做事，但不抵 "人事" 的力量。

到這年頭還相信："誠信正直" 看起來真的幼稚了點。
我不期待別人如此，只希望自己能夠堅持下去。

我不是阿宅，我只是丁了點…

發洩完了…吹笛子去…

Synergy 鍵盤滑鼠共用程式

2007-07-12T23:31:00.000+08:00

幾天前看到同事在玩，才知道原來有一個這麼方便的工具。

Synergy

以下是 PC Home 上的簡介:
Synergy －讓你用一套鍵盤滑鼠掌控身邊的所有電腦你是否有多部電腦呢？那麼當你要切換不同的電腦時，是透過什麼樣的方式呢？KVM？遠端遙控？這些都落伍了，讓筆者所介紹的這款 Synergy 來幫助你透過一套鍵盤滑鼠控制所有的電腦吧！

更酷的是，它可以同一套程式跑在不同的 OS 之上，就變成一下在 Windows 一下在 Linux 一下又可以滑到 Mac 之上。

不過，在使用之前，要先設一在機器為Server (就是你正在用滑鼠的那台) 其它台設成 client (要指定好 server 是誰)。
再者，要設定好每台電腦之間的關係，而且要注意一件事：要設定好兩者之間的相互關係。
如

A <---> B

我們可以說： A 在 B 的左邊如此滑鼠滑過 B 的左邊邊線時，就會跑到 A 上面
而如果我們希望滑鼠滑過 A 的右邊邊線時滑鼠可以回到 B 上的話，我們還要定義
B 在 A 的右邊。
當然，這個關係可以不是 1-1，onto 的，也就是你可以用這個程式做一個滑鼠迷宮 @_@
但我想大概沒人這麼自虐吧 :P
畢竟，這是一個做來讓我們方便使用的程式。

ps 因為這個程式只認 IP ，就提供服務，所以在某些情況下， keyboard 和 mouse 是有機會被別人搶走的 (大家可以想一想 :P)

[轉貼] screen 教學

2007-07-09T17:20:00.000+08:00

一篇不錯的 Screen 入門文
留著做備忘 :P
來源: http://plog.longwin.com.tw/post/1/249

screen 教學

screen 是個非常好用的工具(Linux, BSD.. 等).

這個網址有很詳細的教學: screen 簡介.

下面將一些重點部份轉貼過來..

使用 screen

在命令列下打 screen 就會進入 screen 的天地：
% screen

注意，所有 screen 的指令都是以 Ctrl 鍵加上 a 鍵開始的，在之後以 C-a 代表，C-a c 代表按住 Ctrl 鍵不放再按 a 鍵，然後放開按 c 鍵；而 C-a C-c 代表按住 Ctrl 鍵不放再按 a 鍵，然後放開後再按住 Ctrl 鍵不放按 c 鍵。

開啟，關閉，切換

C-a c 或 C-a C-c 開啟新的視窗，並同時切換到這個新的視窗
C-a n 或 C-a C-n 或 C-a (space) 切換到下一個視窗（0->1 1->2 ...）
C-a p 或 C-a C-p 切換到上一個視窗（1->0 2->1 ...）
C-a C-a 切換到上一個顯示過的視窗（不是照順序切換）
C-a 0 切換到第 0 個視窗
C-a (1..9) 切換到第 (1..9) 個視窗
C-a w 或 C-a C-w 會列出目前所開啟的視窗
0$ tcsh 1$ tcsh 2*$ tcsh 3$ tcsh

有星號 "*" 的表示目前顯示中的視窗，之後的 tcsh 代表這個視窗的 title ，預設是以開啟時的 shell 名稱
C-a K 關閉所有的視窗並退出 screen
C-a ' 或 C-a " 會出現 "Switch to window:" 字樣，輸入號碼後就可切到該視窗
單一視窗使用中的指令

C-a C 清除目前的視窗內容
C-a d 或 C-a C-d 脫離（detach）目前的 screen ，並放到背景執行（不管開了幾個視窗），下面會再提到
C-a D D 強力脫離，除了放到背景執行外，並自動 logout
C-a C-g 虛擬嗶聲（visual bell）的切換，可以在畫面上顯示訊息代表一般的嗶聲
C-a H 紀錄目前視窗所有顯示過的東西（檔名為 screenlog.n n 為視窗號碼）
C-a i 或 C-a C-i 顯示目前視窗的資訊
(11,24)/(80,24)+1000 +(+)flow -ins -org +wrap +app -log -mon +r G0 [BBBB]

C-a l 或 C-a C-l 重繪視窗，如果有字顯示亂掉了可以用這個指令
C-a m 或 C-a C-m 或 C-a (enter) 可以顯示最近一次顯示過的訊息
C-a t 或 C-a C-t 顯示系統的時間及主機名稱還有負載
C-a v 顯示版本資訊
C-a x 或 C-a C-x 如果你要暫時離開目前位置又不想先 logout ，那可以用這個來鎖住 screen
C-a S 將營幕畫面暫停
C-a q (C-a S 暫停) 的回復
C-a ? 線上求助畫面
複製/卷軸模式
按下 C-a [ 就可以進入複製/卷軸模式（只有在目前視窗才算，其他視窗照常）基本上跟 vi 很像：

h, j, k, l 分別為向左，向下，向上，向右移動一格（或是一行）
0 移到該行最左邊
^ 與 $ 分別移到該行最左邊及最右邊的非空白字元
w 以字為單位往前移動並移到字首
b 以字為單位往後移動並移到字首
e 以字為單位往前移動並移到字尾
C-b 向上捲一頁
C-f 向下捲一頁
C-u 向上捲半頁
C-u 向下捲半頁
/ 與 ? 向下或向上尋找字串
(space) 第一次按下到第二次按下的區域會被複製到暫存區內
(ESC) 離開複製/卷軸模式
接著按下 C-a ] 便可以把剛剛存到暫存區內的內容複製出來。

善用 screen
前面提到當按了 C-a d 脫離了 screen 後，會回到沒有執行 screen 時的狀態，但是同時在之前 screen 裡每個視窗內在跑的 process （不管是前景或背景執行的）仍然繼續執行，即使 logout 也不會有影響。所以你可能接著離開身邊的電腦，然後跑出去喝個水，或者另外找個舒服的地方坐下來再接著剛剛的工作。

好，當你重新登入（login）之後，要怎麼接回剛剛的 screen 呢？重打 screen 只會讓電腦另外又開個 screen 給你，你所要做的事就是加些參數：

screen -ls 顯示目前個人所有的 screen
% screen -ls
There are screens on:
1188.ttyp4.SungSung (Attached)
76920.ttypq.SungSung (Detached)
2 Sockets in /tmp/screens/S-AlanSung.

上面的 Attached 表示你現在連接的 screen ，而 Detached 則表示沒有連接的，最後則是共有多少個 screen 數量
screen -r 就是重新回到（resume）screen 裡，如果你只有開一個 screen ，那只要簡單地打
% screen -r

就沒問題了，但是像上面那個，如果你有了兩個以上的 screen ，這樣就有問題了
% screen -r
There are several screens on:
1188.ttyp4.SungSung (Detached)
76920.ttypq.SungSung (Detached)
Type "screen [-d] -r [pid.]tty.host" to resume one of them.

如它的訊息所述，你可以加上它的 process id 或是使用的 tty 加上主機名來決定要接回那一個 screen 。假設在這裡我們要接回 process id 為 1188 的那一個，就打
% screen -r 1188
或
% screen -r ttyp4
或
% screen -r ttyp4.SungSung
或
% screen -r 1188.ttyp4.SungSung
都可以

screen -d 假設現在自己的電腦突然當機，或是網路突然斷了一時連不上去，等到好了之後，想要接回來原來的 screen 卻發現
% screen -r
There is a screen on:
1188.ttyp4.SungSung (Attached)
There is no screen to be resumed.

這時候 -d 這個參數就派上用場了，讓你可以控制某個 screen 脫離（detach），接著再加上 -r 把這個 screen 接手回來
% screen -d
[1188.ttyp4.SungSung detached.]
% screen -r
或直接
% screen -d -r

screen -wipe 有時候不小心跳電了，這時候重開機後當然也不會有 screen 留著，但是由於 screen 會有紀錄所有的 screen ，因為雖然舊的沒有了，可是還是有紀錄在，因此這個指令就是把廢棄不用的 screen 給"擦拭乾淨"（wipe）
There are screens on:
69103.ttyp5.SungSung (Removed)
529.ttyp0.SungSung (Detached)
1 socket wiped out.
1 Socket in /tmp/screens/S-AlanSung.

會用了上面所介紹的功能，你可以現在進入 bbs ，進入聊天室跟人聊天或是在上面發表文章到一半，發現計中要關門了，你可以從容的 detach ，回家之後再連回來 attach ，繼續剛剛的話題或發表文章，而對方可能根本沒發覺。只要你連線的主機不當機，那電話線或網路再怎麼不?都不必怕斷線。

如果你需要更多詳細的資料，可以善用線上手冊（manual pages）或是 info 這個指令
% man screen
% info screen

作者 jon ( Document-Ebook ) :: 迴響 (2):: 靜態連結網址

請問split怎麼用？ [回覆]

嗯..screen很好用，不過這一篇教學滿基本的，所以想請問在screen中的split功能怎麼使用？

Comment by spancer (12/09/2005 16:53)

回 spancer [回覆]

之前倒是沒這樣子試過, 剛剛去 man 了一下 screen,
Ctrl-a S 就可以 split,
Ctrl-a tab 就可以切到下面的視窗,
Ctrl-a Ctrl-a 下面的視窗就可以到處切換,
Ctrl-a Q 就將分割的視窗關掉,
(當看到一片黑的時後, 總之就 Ctrl-a Ctrl-a 就對了)

Comment by Tsung (12/09/2005 17:09)

2007陶笛與塤的形音色美

2007-06-27T09:32:00.000+08:00

陳鏡老師將於苗栗陶瓷博物館舉辦為期一個月的陶笛與塤的創作展, 同時也邀請多位國內陶笛製作者共同參加.

展覽期間也有多場精彩的陶笛音樂演出及陶笛相關的研討會. 這場夏日盛會, 您非去不可.

地點: 苗栗陶瓷博物館
時間: 2007 年 8/01 ~ 8/31
官網: 2007陶笛與塤的形音色美

白鷺鷥獲邀在 8/4 開幕音樂茶會上演出. 預計曲目為

莫札特小夜曲
玩具兵進行曲
四月望雨
白鷺鷥

敬請期待 .....

---------------------
◆指導單位：行政院文化建設委員會．國立臺灣工藝研究所
◆主辦單位：苗栗縣政府．苗栗陶瓷博物館
◆協辦單位：陶藝雜誌、中華民國陶藝協會、苗栗縣陶藝協會、苗栗縣陶笛協會、白鷺鷥陶笛樂團、台中市陶笛樂團、彰化縣陶笛樂團、換日線陶笛隊、嘉義市樂耕陶笛隊、Rubato陶笛音樂藝術樂團

◆展期：2007年08月01日起至08月31日止
◆會場：苗栗陶瓷博物館（苗栗縣旅客服務映像園區）
◆地址：苗栗縣公館鄉館南村館南352號
◆電話：037-236-818 傳真：037-238-288
◆陶笛參展作家：林孟德、李生鴻、李焜剛、何財銘、吳寶安、吳淑櫻、官鋒忠、范欽章、許浩倫、郭慶榮、陳國祥、陳鏡、張志名、楊文涵、劉鼎魁、潘國隆、蔡宗翰、謝永清、藍鈺雯（以上順序依姓氏筆劃排列）

◆記者會：2007年08月02日（四）上午10點整
◆出席名單：參與展覽及演出的朋友等自由參加

◆開幕音樂茶會：2007年08月04日（六）上午10點整
◆演奏名單：許浩倫、蘇義堡、黃文琪、陳鏡、白鷺鷥陶笛樂團、台中市陶笛樂團、彰化縣陶笛樂團、 Rubato陶笛音樂藝術樂團等

◆複管陶笛表演＆陶笛製作示範：2007年08月12日（日）上午10點整
◆演出名單：許浩倫、陳鏡

◆陶笛吹奏＆製作研討會：2007年08月19日（日）上午10點整
◆演出及主講名單：苗栗縣陶笛協會、換日線陶笛隊、潘旭建

◆陶笛吹奏表演：2007年08月26日（日）上午10點整
◆演出名單：嘉義市樂耕陶笛隊、王明中

◆策展人：陳鏡（桼采匋）
◆相關展覽圖片請至 http://photo.xuite.net/ceramicist/1743318

◆【苗栗縣旅客服務映像園區】占地2.1公頃餘
位置－位於苗栗縣公館鄉南方約兩公里，省六號公路左側；距離中山高速公路僅三公里餘。
特色－本為陸軍基地，已廢棄多時，苗栗縣政府以閒置空間再利用方式，改造為：
1、觀光旅遊資訊中心
2、苗栗縣陶瓷博物館
3、成為苗栗地區農業特產展現中心點
4、地區景觀公園
5、客家文化特色園區
http://www1.mlc.gov.tw/culture/01.php?id=24

檢查 library dependency 的小工具

2007-06-26T16:14:00.000+08:00

在開發"手工打造"的 Embedded System 時，可能會遇到library depency 的問題
而我們不見得能一下子就知道這個 library 的 dependency (請使用 ldd or objdump)

愛偷懶的小弟因為懶得算 dependency，就寫了一支小 script 幫我算

它可以把我所指定的程式所依賴的 library 找出來，如果在我的 target 之中沒有它就把它從 library source copy 過來 (這樣就可以找出 library 的最小集合)

它可以搭配其它 script 使用，做到完全自動化計算 library dependency

個人覺得還蠻方便的，分享給大家

File: checklib.sh



#!/bin/bash
# This software may be used and distributed according to the terms
# of the GNU General Public License (GPL), incorporated herein by reference.
# Drivers based on this skeleton fall under the GPL and must retain
# the authorship (implicit copyright) notice.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.

#composer Tick


LIB_SOURCE_PATH="/Project/tank/lib/ /usr/toolchain/arm-linux/arm-linux/lib"
REFERENCE_LIB_PATH="/path to my project rootfs/disk/lib/"
TARGET_LIB_PATH="/path to my project rootfs/disk/lib/"

LIBS=""
for file_tmp in $@;do
FILE=`file $file_tmp`
    if (( `echo $FILE | grep "dynamically linked" | wc -l` == 0 )) ;then
        continue;
    fi
    if [ "`echo $FILE | awk '{print $7}'`" = "80386," ];then
OBJDUMP="objdump"
    else
OBJDUMP="arm-linux-objdump"
    fi
    LIBS+=`${OBJDUMP}  -p $file_tmp   | awk '/NEEDED/ {printf("%s  ",$2); }'`
done

for lib_tmp in $LIBS;do
IS_exist=0
    for SS in ${REFERENCE_LIB_PATH};do
        if (( `find $SS -name ${lib_tmp} | wc -l` > 0));then
IS_exist=1;
            break;
        fi
    done
    if (( ${IS_exist} > 0  )); then
        continue;
    fi
SRC_LIB=""
    for SS in  ${LIB_SOURCE_PATH};do
SRC_LIB="${SRC_LIB} `find ${SS} -name ${lib_tmp}`"
    done
    if [ $SRC_LIB ];then
SRC_BASE=`echo $SRC_LIB | awk '{stop=index($0,".so");ans=substr($0,0,stop-1);print ans}'`
        echo "You are going to copy the following libraries to ${TARGET_LIB_PATH}:"
        echo "cp -av ${SRC_BASE}[0-9.]*[!a] to ${TARGET_LIB_PATH}"
        echo -n "continue? "
        read ans;
        if [ "$ans" = "y" ]  || [ "$ans" = "Y" ];then
            cp -av ${SRC_BASE}[\.0-9\-]*[!a] ${TARGET_LIB_PATH}
        fi
    else
        echo "Warning: I cannot find ${lib_tmp} from the LIB_SOURCE_PATH you set!!"
        echo "It might be missed not in somewhere else."
        echo "Please check if it is not in '${LIB_SOURCE_PATH}'"
    fi
    echo
    echo
done

[舊文]list_head 的用法

2007-06-23T20:57:00.000+08:00

三年前寫的文章
有機會再來討論一下這個好玩的東西

引言回覆
發表 list_head 的用法
在 linux kernel 之中做double link list 時有個東西實在是又好用，又強大，速度又快。
那就是 list head
其實這個東西和我們在資料結構中學的沒兩樣。
只是這個玩意運用了 struct 的結構性，及 C 語言本身的低階能力，使得速度變得很快。


struct list_head {
　struct list_head *prev,*next;
};

他的內容只有 list_head 的兩個 pointer.也只能指 list_head
在運用時，有個 macro 叫
list_entry

他可以以 list_head 的位址，及這個 list_head 在物件中的位址，算出物件的位址。
也就是說，假設有一個物件叫 ABC 以下是內容：


struct ABC {
　int index;
　char *name;
　int score;
　struct list_head lh;
}

如果你今天拿到一個 ABC物件中的 lh 的位址(lhpt)的話，你就可以從這裏拿到該物件的位址。
e.q. struct ABC *abc = list_entry(lhpt, struct ABC,lh);
如此，list_head 就會依 lh 在 ABC 的相對位置，及 lhpt 的位址算出這個 ABC 的位址。

當有 list_head 的物件被 allocate 出來時，要記得初始化 prev 和 next
e.q. INIT_LIST_HEAD(&abc->lh);

加入串列中的用法是
list_add(&abc->lh,head);
or
list_add_tail(&abc->lh,head);

刪除是
list_del(&abc->lh);
但是，有一點一定要記得 list_del 不會清掉 abc->lh 的內容
但是會清掉 abc->lh->prev 的 next 和 abc->lh->next 的 prev
如果要清得乾淨一點，就要用 list_del_init(&abc->lh);
那就會 abc->lh->prev == abc->lh->next==&abc->lh

--
會不會寫得太難懂啦 ~_~

星期五二月 20, 2004 8:18 am

[舊文] bash shell script 程式設計

2007-06-23T20:48:00.000+08:00

這是三年前寫的舊文嘍~ 放在這懷舊一下

bash shell script 程式設計(序言,1,2,3,4,5,6,完)

發表 bash shell script 程式設計(序言,1,2,3,4,5,6,完)
相信所有玩過 Unix的人都會同意 shell script 是一個十分強大的工具，可以用來幫助自已在短時間內解決許多枯\躁而乏味的工作，而且讓工作變得有趣。
對於 shell script 要怎麼寫，為什麼會想到這麼寫？對於這個問題，我個人的答案是：用多了，就知道了。有時很聰明的想法，往往是靈機一動，就想到了。我會建議大家，如果寫了好用的 script 就把他留下來，給個好名字。有時候用得上時，就會很高興有這個自製的工具。
當然，要寫 script 之前，要先了解一些東西。
1. 資料流
>, >> , < , | , #&># .....
2. 一些好用的工具
cat
grep
awk
sed
find
more
........ everything you can use.
3. 變數
4. 指令代換
5. 判斷式
if else fi
6. 流程控制
while for
....
在之後的幾篇文章中，我會慢慢把一個個 topic 寫完...
希望不會寫得太糟 Razz

tick 在星期五二月 06, 2004 12:11 am 作了第 8 次修改
星期六一月 17, 2004 12:42 am

發表資料流
UNIX是第一個支援資料流的作業系統。
什麼是資料流呢？
就是把程式的輸入和輸出想像成一個串流，
在 Unix 之下，任和一個一般的程式都會直接開三個檔案。
0. stdin
1. stdout
2. stderr
這三個檔案分別是資料流的輸入和輸出，及錯誤輸出


stdin ====> 程式 =====> stdout
　　　　　　　　∟==> stderr

在 default 之下，stdin 是接著 keyboard
stdout 是接著 tty (你想成 monitor 就好了)
stderr 也是接著 tty

資料流既然是"流"，那當然可以轉向。
"<" 這個指令呢就是把 stdin 接上後面的檔案如 cat <>" 是把 stdout 寫入後面的 file
如檔案內有東西，會把檔案內的東西清空才寫入。

">>" 和 ">" 相同，但不會把檔案內的東西清空，而是寫在檔尾
如


cat test.txt >> foo

"|" (pipe)這個呢則是把前面的stdout 接到後面程式的 stdin
如
cat test.txt | more
這樣， cat 的輸出就可以被 more 接下來。

> >> 還可以把 stderr 轉到 stdout
如
2>&1
也可把 stdout 轉到 stderr
如
1>>&2

在 shell script 中資料流轉向，和pipe 是十分常用的技巧
(應該說是基本工夫)
在一般下指令的時候也是很常用上
如
cat pbsd.c | grep CONFIG_PBS

有時候如果要做一些比較複雜的動作。接個四五個 pipe 再加上轉向，也不為過

--
過年期間我不能上網，所以我會在自己的 notebook 寫，等回台北再 post 上來

星期日一月 18, 2004 1:45 am

如果有好的能力，沒有好的工具，那也是沒有用，但很幸運的是，
之前的 Unix Programer 寫了許多方便自己的工具，相同的那些工具\r
也能方便我們。
下面是一些工具的簡單介紹。(都可用 pipe 和轉向)
cat :
　　把檔案打開，印到 stdout 上
grep :
　　 grep 是一個在輸入資料中找出指明要找的字串的那一行文字的工具。
　　如
　　 grep "I Love Shell Script" test.txt
　　就是把 test.txt 這個檔案中，有 "I Love Shell Script" 這個字串的那一行印>到
　　stdout 中。
　　cat test.txt | grep "I Love Shell Script" #也是一樣的
awk :
　　一個用來分析內文的工具，它可以掃描文章內容，找出你要的文字，且
　　依你的要求做輸出，你可以把它當做 grep 的加強版。
　　awk 的語法很像 C 語言，所以對會寫 C 語言的人而言，這是一個很好用的工具
　　如
　　awk '{print NR,$0}' text.txt
　　就會把 text.txt 的內容印出來，且加上行數
sed :
　　這個工具可以幫你把你想換掉的字串一次換掉

awk 和 sed 這兩個工具是十分強大的工具，它們可以做到的事十分的多
遠比它一開始被定義時所想到的功能還多，多到可以寫一本書來談。\r
O'Reilly 就有出一本 awk & sed 的書，有興趣的話可以找一本來看看。

find:
　　這個工具可以依你的要求，找出你想要的檔案，在系統管理上很好用。
　　可是依時間，大小，檔名，修改時間等等的選項來找檔案。

more (less) :
　　把 stdin or 檔案內容分成一頁一頁的來看，一般來說， less 比較強一些。
　　可以支援 vi 的語法，但目前 more 也一一支援了。

以上每個工具都是十分好用的工具。
但我沒有詳細的談，詳細的東西呢，你可以用 man 這個工具來看。
如
man find
然後你就會了解為什麼我只說一下它們的功能了 Smile

星期二一月 27, 2004 11:34 am

發表變數參數
在 bash 中設定變數很容易
不用指定形態
直接指定就可以了
如
myvar="I love linux."
就是指定 myvar 這個變數為 "I love linux." 這個字串
使用這個變數呢，則是用 $myvar 來使用
如
echo $myvar

如想對變數做運算，可用 let
let "expression"

如 let i=i+1

在 shell script 中，可以在 script 加上參數
而參數會依你所打入的指令依序定義
如有一個script 叫 showme
#!/bin/bash
# filename showme
echo $0
echo $1
echo $2

執行結果如下
>./showme abc def
./showme
abc
def

如果要 show出所有參數，可以 $* 表之。
要知道參數數量，可以 $# 表之
$$ 為 script 執行時的 pid

--
寫著寫著，有一些東西不清楚，找了一下 man
發現 man 寫得真是清楚極了。

上 google 查了一下，有一個網頁整理的很好
http://www.fanqiang.com/a4/b1/index_b.html
看來我可以不用寫了 QooQ

星期二二月 03, 2004 12:47 am

發表指令代換
在 bash 之中我們可以用 ` command` 來執行指令，且將其視為一個整體，最後的結果為全部的結果
例如
ls -alF `find -size 0`
就是找出所有 size == 0 的檔案
將之結果當做是 ls -alF 的參數
這個技巧在 shell 之中很常見如
NumberOfFiles=`find | wc -l`
就是把 find | wc -l 這結果指定為 NumberOfFiles 的值

星期三二月 04, 2004 10:27 pm

發表判斷式
shell script 是一個完整的語言，當然會有 if else 等等的指令
就讓我們來看看如何使用 bash shell 的判斷式吧

在這裏我是假設大家會使用某種程式語言。

格式是如下的

if expression; then
　　list
elif list; then
　　 list
else
　　list
fi

這裏的 list 代表是一個或一堆指令的集合。
expression 代表的是一個會有return 值的指令。

如expression 不為空，或 0 就表示為 true
fi 代表這個 if 結束了如同 C 語言的 }
then 就如同 C 語言的 {

elif 後面的 list 會依序執行，到了最後如不為空，或 0 就為真也就是再執行後面的 list

對於 expression 如要寫判斷式有兩種格式
1. (( expression ))
這個格式等同於 let "expression"
這就是把 expression 內的資料做計算
例如
(( $abc + 1 ))
2. [[ expression ]]
這個格式等是可以比較這個 expression 的兩邊
如
[[ $1 == "abc" ]]
如果相同，就為 1 否則為 0
比較的運算子有 == != ! && ||
== 是全等
!= 不等
! not 運算子
&& and 運算子
|| or 運算子
如
( (( $# > 3 )) && [[ $1=="abc" ]] && ( [[ $2!="def" ]] || ![[ $3=="ghi" ]]) )

一個例子
if (( $#==0 )) ; then
echo "usage: xxx [xxx | xxxx]"
else
　if ( [[ $1 != "xxx" ]] && [[ $1 != "xxxx" ]] ) ; then
　　echo "prometer [xxx | xxxx]"
　　exit
　fi
　if [ $1 = "xxx" ]; then
　　....
　else
　　........
　fi
fi

星期三二月 04, 2004 11:00 pm

發表流程控制
在程式之中，for 和 while 讓我們省下了很多的力氣

在 bash shell 之中 for 和 while 的用法如下
for:
在bash 中 for 的用法有兩種
for name [ in word ] ; do list ; done
for (( expr1 ; expr2 ; expr3 )) ; do list ; done
第一種是從字串的array 中拿出一個，成為 name (name 為變數)
再進入迴圈中，直到array 中的字拿完為止 (list 為迴圈內容)

第二種就很像 C 語言了, 第一次跑時，一開始 run expr1
再 check expr2
跑完 list 後跑 expr3 再跑 expr2
一旦expr2 的結果是 0 or 空就跳離

while:
while 的用法
while list_a ; do list_b; done
當 list_a 的最後一個 command 結果不為 0 或空之時，就進入迴圈做 list_b

until:
until list_a; do list_b; done
和 while 相反，當 list_a 的最後一個 command 的結果不為 0 或空時，離開迴圈。

還有一些東西如 select case esac 等... 這些東西可以用 if for or while 組合而成，就不再說明了。

星期四二月 05, 2004 11:40 pm

發表 put all together
說了那麼多，我們開始來寫寫 bash shell script 吧
就拿之前post 過的 chout 為例子好了

首先，一始開寫 shell script 的人很有可能不知道如何執行 shell script
假設我們有一個 shell script 叫 chout 已經寫好了
我們有兩個方法可以執行它
1. bash chout
這個方法是執行一個 bash ，且叫它讀入 chout 並執行
2. 在 chout 的第一行加入 #!/bin/bash
(告訴你的shell 這個 shell script 指定用 bash)
再 chmod a+x chout
(指定 chout 為一個可執行檔)
之後你就可以把 chout 當一個程式來使用了。

讓我們來看看這個例子
01 #!/bin/bash
02 if (( $#==1 )) ; then
03　　ares=`find -name '*.c'`
04　　ares="$ares `find -name '*.h'`"
05 else
06 　　ares=`find -name $2`
07 fi
08 for arrs in $ares
09 do
10 　if [ -f $arrs ] && (( `cat $arrs | grep -i $1 | wc -l` > 0 )); then
11 　　echo "In file $arrs"
12 　　cat $arrs | awk '{print "#"NR"\t"$0}' | grep -i $1
13 　　echo " "
14 　fi
15 done

01 行告訴我們，這是一個 bash 的程式
02 $# 是變數的數量，也就是 : 若變數的數量為 1 則做 03 04 否則做 06
03 把 "find -name *.c" 這個指令的結果存在ares 中
04 ares 再加上 find -name *.h 的結果
06 找名字為第二個參數的檔案，且存成 ares
08 在 ares 中依序抓出一個元素，命之為 arrs ，如抓完了，做 15 行的下一行(沒有了，就是結束了)
09 10~14 是迴圈範圍
10 當 $arrs 是檔案 ( [ ] 是 test 的簡寫 (有興趣請看 man test)) 且 $arrs 有大於一行包涵第一個參數的話，做 11~13
11 應該不用解釋吧
12 為$arrs 中的內容加上行號，只 show 出有 $1 的行
13 印空白行

　
以上只是一個小小的 shell script
因為 shell script 不用 compile ，只要隨手改改，隨手寫寫就能用。
不用考慮太多形態的問題，所有程式都是指令。都是可用的function
所以在使用上很方便，只要多加一點點巧思，就可以用一點點的時間，做出一些很炫的東西。
試著玩玩看吧，保証 linux 功力會大增喔!!

Self Unit Test Framework

2007-06-23T09:42:00.002+08:00

自我測試架構
適用語言： OOP language

相信大家都知道軟體測試的重要，也明白軟體測試有助於開發者及早發現問題。
軟體測試之中有相當多的面向，而今天我要提的，是 Unit Test 這個部分。

在 OOP 的語言之中，每個元件應該有其一獨特且專一個功能 (如此才能彰顯 OOP 的優勢)
也就是說，在寫 OOP 的案子時，到最後應該會像是在玩樂高一般。把每個元件兜到它應該出現的位置。案子也就成了。

但，這只是個理想。

實際作做案子就會知道，程式一定有 bug ，而要如何 debug 就成了每個設計師的惡夢。而debug 中最最另人頭疼的，就是不知道 bug 在那。
Unit Test 就是一個很有效且快速的技術幫助設計師了解且找出問題的所在。
在表面上，做 Unit Test 看起來會多花許多工夫。不過，在案子越來越龐大時， Unit Test 可以快速的指出問題的癥結，也可以讓 PM 更明確的掌握案子的進度。
一般來說，使用 Unit Test 技術可以讓案子穩定的有進展。

在使用 Unit test 之前要了解幾件事。
1．你的物件是要做什麼的。
2．有那些 boundary 存在？
3．錯誤情況的處理為何？
4．任何你的物件會遇到的極端狀況

再依上述的認知做以下的 Test
1．正常的 input 資料是否有正常的 output (要先知道正確的結果)
2．在 boundary 時資料是否也是正常運作 lower/upper bound 都要做
3．不正常的 input 時，是否能發現，且做出正確的回應？
4．大量被使用時，是否能成功的運作？

在做測試時，你要用最嚴苛的心去測你的程式。這才是正真對你自己仁慈。

每個物件都要有一個自己的測試程式，每做一次修改(不管多小的修改)，就要跑一次，並得到一份報告。

如果物件被整合到其它物件，其它的物件也要做 Unit test
最懶也是最好的方法就是寫支小 script 一次跑完所有的 Tests
(好像很花時間？其實不然，因為它可能會在很短的時間內幫你找出本來可能要花一個月才找出來的 bug)

以下是小弟寫的 Unit Test FrameWork (可輕易的改寫成 Java 版的 :-) )
每個要被測試的物件，只要多重繼承 SelfTestUnit
然後實作下面兩個 functions

virtual bool doSelfTest() {return false;};
把你對這個物件的測試寫在裏面，並回報是否測試成功

virtual const char *myClassName(){return "Please Set ClassName Here";};
指定這個物件的名字 (for report)

而在測試程式之中寫:
Capataz cap;
cap.addSelfTester(new 被測試的物件(1));
cap.addSelfTester(new 被測試的物件(2));
cap.addSelfTester(new 被測試的物件(3));
...
cap.doTest();

就可以了...

File: selftest.h


#ifndef __TICK_CPP_SELF_TEST_FRAMWORK__
#define __TICK_CPP_SELF_TEST_FRAMWORK__

#include <vector>

class SelfTestUnit {
  public :
      virtual bool doSelfTest() {return false;};
      virtual const char *myClassName(){return "Please Set ClassName Here";};
};

class Capataz {
  public :
      //Capataz(char *file);
      //~Capataz();
      bool addSelfTester(SelfTestUnit *);
      bool addSelfTester(SelfTestUnit &);
      bool delSelfTester(SelfTestUnit *);
      bool delSelfTester(SelfTestUnit &);
      bool doTest();
  private:
      std::vector < SelfTestUnit * > _tester;
      void testReport(SelfTestUnit *,bool );
      void allPassReport(bool);
};


#ifdef SELFPROFILE
#include <stdlib.h>
#include <stdlio.h>
extern "C" void __cyg_profile_func_enter(void *func,void *caller) __attribute__((__no_instrument_function__));
extern "C" void __cyg_profile_func_exit(void *func,void *caller) __attribute__((__no_instrument_function__));
#endif //SELFPROFILE

#endif // __TICK_CPP_SELF_TEST_FRAMWORK__

File: selftest.cpp


#include <iostream>
#include "selftest.h"


bool Capataz::addSelfTester (SelfTestUnit * tester) {
  if (tester == NULL) {
      std::cout << "Try to register a NULL pointer" << std::endl;
      return false;
  }
  _tester.push_back (tester);
  return true;
}

bool Capataz::addSelfTester (SelfTestUnit & tester) {
  return addSelfTester (&tester);
}

bool Capataz::delSelfTester (SelfTestUnit * tester) {
  std::vector < SelfTestUnit * >::iterator pos;
  if (tester == NULL) {
      std::cout << "Try to remove a NULL pointer" << std::endl;
      return false;
  }
  for (pos = _tester.begin (); pos < _tester.end (); pos++) {
      if (tester == *pos) {
          _tester.erase (pos);
          return true;
      }
  }
  return false;
}

bool Capataz::delSelfTester (SelfTestUnit & tester) {
  return delSelfTester (&tester);
}

bool Capataz::doTest () {
  bool allpass = true;

  std::vector < SelfTestUnit * >::iterator pos;
  if (_tester.size () == 0) {
      std::cout << "There are no tester yet!!" << std::endl;
      return allpass;
  }

  bool btmp;

  for (pos = _tester.begin (); pos < _tester.end (); pos++) {
      std::cout << "Do Testing:" << (*pos)->myClassName () << std::endl;
      btmp = (*pos)->doSelfTest ();
      allpass = allpass && btmp;
      testReport ((*pos), btmp);
  }
  allPassReport (allpass);
  return allpass;
}


void Capataz::testReport (SelfTestUnit * stu, bool rep) {
  if (rep) {
      std::cout << "Test Report: " << stu->myClassName () << "--->OK!!" << std::endl;
  } else {
      std::cout << "Test Report: " << stu->myClassName () << "--->Failed!!" << std::endl;
  }
}

void Capataz::allPassReport (bool rep) {
  std::cout << std::endl;
  if (rep) {
      std::cout << "All Passed? Yes" << std::endl;
  } else {
      std::cout << "All Passed? No" << std::endl;
  }
}

[舊文]陶笛 DIY 心得圖

2007-06-23T04:30:00.000+08:00

因為陶韻的資料不見了，只好把以前的東西搬來這裏 @_@
慘~ 過去點點滴滴的回憶啊~

post at:
2005/08/29 17:29

[舊文]陶笛DIY 時的想法

2007-06-23T04:03:00.000+08:00

舊文回 po ，因為陶韻的資料不見了，把它放到這來嘍

星期一十月 17, 2005 7:56 pm 文章主題: DIY 時的一些....想法引言回覆
也許應該放在閒聊板 0_O

剛剛才用榔頭敲掉了一隻花了很多心血、長得很美的笛子
原因無它，"音色不夠好"，而且又被我修壞掉了

當決定要把它回收重作之時，內心其實是天人交戰的。
那隻笛子是我彷是誠的外型，做日式十二孔笛。
外型真的很美，可惜內空間沒挖好，又想用調音的調到我想要的調性
調到了，音色也毀了。

這陣子，作了好幾把笛子，在每把笛子中都灌注了多少的心血，感情。
每當一把笛子第一次發出聲音之時，總是有一種莫名的感動，就好像聽到新生兒第一次啼哭，任何人都會因此而感動…之後慢慢地從單音變成十幾個不全的音，再慢慢的一個音一個音的相對音準慢慢確立。如果幸運的話，它會從黑黑的笛子慢慢變成灰白色…此時它已經能吹奏出許多的曲子。它已經有強烈的個性，有它的優缺點。
出來的不見得是我所預期的個性，不見得是我要的音色，但每一支都讓我收獲不少。對於"陶笛"這樣東西又有更深入的體會，對於每種性質的平衡又有更深的體悟。

把笛子拿去燒，又是另一次的浴火重生，每當決定安排一次燒笛，總是會在腦海裡幻想燒出來會有什麼樣的花紋，啊~~這到目前我為是沒辦法有效的掌握…也會怕燒壞了…這時的每一隻笛子早就和我有深厚的感情，早就帶給我無窮的歡樂。往往在燒之前，都是以訣別的眼神看著它們，先做好最壞的打算。所以燒成後，總是有一種重生的感覺。

陶笛 DIY 入門真的不難，只要你有正確的工具，有點耐心，有點幸運，要一隻陶笛嗚嗚叫真的不難。
難，是難在於進階之後。要高音漂亮？低音漂亮？音色乾淨？共鳴好？聲音哄亮？有無氣聲？音是不是夠準？每個音的氣量是否平均？是否好演奏？外型好不好看？……

時至今日，學作陶笛大約半年的時日，回想起剛開始做陶笛之時，才做了幾把，就以為可以做出很好的笛子，深深覺得好笑

手下那把破碎不堪的土笛，在幾個月前，我可能會把它封成 "演奏級" 的笛子，而現在卻是期待它的轉生。

陶土就是這麼可愛，當你不滿意時，總是個可以再來一次 ^.^