• 技術涵蓋： 為了加速 Android 系統整合與優化，我們建構了若干工具與提供一些創新的方法，比方說快速啟動 Android，詳情可見 0xlab::Technology
• 與知名專案與開源團隊的合作：除了過去已合作的 android-x86 與 CyanogenMod 專案外 (主要是 Graphics 與 ARM 相關效能優化)，我們也投入 Linaro 的開發，建立 Android platform 與 LAVA (Linaro Automated Validation Architecture) 的基礎
• 建立與主要 SoC 廠商的聯繫及協同開發：與兩家重要的 SoC 廠商 (排名 Top 20 半導體公司) 密切合作開發，在 Android 的基礎上，透過若干開源的創新，加強 SoC 競爭力，並導入產品設計

• 0xdroid :作為 0xlab 的 Android 參考優化與客製化設計，其成果不僅為 Beagleboard 社群所熟知，許多內部的改進也廣泛用於 CyanogenMod，間接使許多裝置與公司團體受惠。可參考 0xdroid::Roadmap 以得知細部的演進，簡單來說，在高解析度的環境，提昇了 Android 使用者體驗 (software curosr, on-screen keyboard, launcher)，另外就是進一步的 ARM 優化，從 skia, zlib, libcore, libc, 到 libagl (libGLES_android) 都有
• 0xbench : 仍是截至目前為止，我們所知的最完整 Android 開放原始碼系統效能評測工具，與上個版本相較，追加了 Web/JavaScript 效能評測、LAVA 的資料格式 (bundle)、重新啟用 libMicro 等等，詳情可見 0xbench::Benchmarks
• Linaro : 經 ARM 的支持，0xlab 投入 Linaro 開發，共同為改善開發原始碼軟體品質而努力。我們涉及的項目稍微繁雜些，從整合 Linaro toolchain、改善 Android runtime、強化 LAVA 的整合，到多媒體驗證都有
  
• aster : 全名是 "Android System Testing Environment and Runtime"，著眼於 Android 系統中許多無法透過 API 呼叫所作的 black-box test，一旦 adb daemon 正常啟動後，這個系統就可依據指定的 test case 去逐一執行並驗證，此系統也允許使用者編輯操作案例
• Android 快速開機: 利用優化過的 ARM hibernation (suspend-to-disk)，大幅縮減 Android 系統從 HW reset 到使用者得以操作的時間，可參考展示影片 "Android Fast Booting with CarHome"，相關的原始碼也一併釋出，可見 0xlab-kernel，儘管仍有頗大的進步空間，但這是完全可運作且開源的解決方案
  
• AMBER : 這是我們提供的第一個完整的應用系統，概念非常簡單，考量到現有 Android 裝置相當多元，可能是手機、筆記型電腦、平板電腦、電子書，或者數位電子，這之間要進行媒體 (media/content) 的交換往往很沒效率，而且使用者還得被繁複且多樣的多媒體格式所困擾，若無適度的轉換，通常就無法在手機或者較陽春的平板上播放。我們提出的解法，就是將動作縮減為 "push" 與 "pull"，自動偵測媒體的格式與屬性，無論在近距 (家用或小範圍) 或遠距 (透過雲端或者防火牆)，挑選最合適的途徑，讓使用者盡情觀賞與交換。同樣的，這也是開放原始碼，內建於 0xdroid
• Toolchain : 除了改善 Linaro Toolchain for Android 外，我們還改善了 Android ELF prelink，大幅縮減執行時期需要解析的 ELF 符號數量，也縮減了載入時間，近期內會提交到 AOSP
• Android Open Source Project : 已被 Google Android 計畫正式收錄 37 個修改/貢獻
  

• Twitter: http://twitter.com/0xlab
• 郵件論壇: 0xlab-devel (系統開發) ; 0xlab-discuss (一般討論)
• YouTube: http://www.youtube.com/0xlab
• 有源碼有真相: gitorious, github
  

如果你有收看 LWN.net 的話，大概知道每次 linux kernel 有新的 release 前都會有一次針對這次 release 的統計資料，看看主要的貢獻是由哪些人，哪些公司完成。藉由這次跟 0xlab 分享 Android 2.3 新特性的時候，我學 LWN.net 做了一些小統計，還滿有趣的。

Most active Android 2.3 organizations (by changesets)

4204 google.com
1354 android.com
98 sonyericsson.com
71 gmail.com
39 codeaurora.org
39 samsung.com
38 intel.com
32 nokia.com
32 holtmann.org
29 0xlab.org
25 trusted-logic.com
17 openbossa.org
11 nxp.com
11 linux.org.tw

10 ti.com
10 acer.com.tw
8 themaw.net
8 garmin.com
7 snpe.rs
7 motorola.com
7 mc.pp.se
7 googlemail.com
5 invensense.com
4 mirbsd.org
3 windriver.com
3 realvnc.com
2 teleca.com
2 sharp.co.jp

2 nvidia.com
2 motoya.co.jp
2 lge.com
2 broadcom.com
1 yahoo-inc.com
1 xs4all.nl
1 wdsglobal.com
1 uwevoelker.de
1 strongswan.org
1 stericsson.com
1 signove.com
1 saftware.de
1 richlowe.net
1 pv.com

1 promwad.com
1 pcc.me.uk
1 padovan.org
1 osbeck.com
1 nii.net
1 martin.st
1 ilovelinux.de
1 happydroid.com
1 droidmod.org
1 cpeterso.com
1 big.or.jp
1 arm.com

Most active Android 2.3 developers (by lines changed)

Jesse Wilson
Eric Laurent
Dianne Hackborn
David 'Digit' Turner
Nick Pelly
Mathias Agopian
Nick Kralevich
Brian Carlstrom
Eric Fischer
Andreas Huber

386588
364359
260033
205494
160707
124119
103004
83492
61646
61233

12.8708%
12.13%
8.65%
6.84% 
5.35%
4.13%
3.42%
2.77%
2.05%
2.03%

投影片中還研究了一下各主要開發者主要研究的方向，看 log 的時候依照這個順序去看，有一定的脈絡可尋 :)

最近為了把 TuxOnIce 整到 Android 上面，著實把 Linux 的電源管理系統中關於 suspend 與 hibernation 的部份研究了一下。而 Android 為了增加待機時間加入了 wakelock 的機制，讓情況變得更加複雜。

TuxOnIce

TOI Patch

TuxOnIce 簡稱 TOI，前身是 Software Suspend 2，是一個長期在 linux upstream 以外耕耘的一個休眠補釘，相較於早期整合到 linux kernel 內的 swsusp，TOI 的功能非常豐富，可以指定把記憶體內容儲存到多種不同的位置，如檔案或置換空間，還可以選擇不同的壓縮方法。

首先幫 ARM 平台加上基本的休眠功能，使用 Hiroshi DOYU 的 patch:

http://article.gmane.org/gmane.linux.power-management.general/20543

然後到 TOI 網站下載最新的 3.2 補釘，打上去的時候會有一些衝突但是都還滿容易解決，要注意的是某些衝突是看不出來的，例如因為函式移動位置而造成重複定義，要小心檢查。

然後因為 TOI 對於非 x86 平台有一些假設現在已經不適用，所以需要修改

https://gitorious.org/0xlab-kernel/kernel/commit/e551caf

OMAPFB

使用 Pandaboard 加上 Android 測試才發現從休眠醒來後 LCD 不會自動點亮，通常在 x86 平台上有 pm-utils 或是 hibernate script 來幫忙處理這種關閉打開 LCD 的問題，這次我是先在 kernel 內幫 OMAPFB 加上一個電源管理的呼叫，讓 kernel 醒來的時候自己重新設定 LCD。

https://gitorious.org/0xlab-kernel/kernel/commit/21e0f14

Pandaboard & Beagleboard xM

在 Pandaboard 或 Beagleboard xM 上面沒有 NAND 可以當作儲存空間，所以一般都是把檔案放在MMC 上面，第一個 patch 讓 kernel 在開機的時候不要初始化不存在的 NAND 空間

https://gitorious.org/0xlab-kernel/kernel/commit/3ae6b4c

然後因為 MMC 的 probe 需要時間，第二個 patch 讓 TOI 等待指定的 resume device 已經偵測到之後才開始進行 resume

https://gitorious.org/0xlab-kernel/kernel/commit/1078bd7

Wakelock

wakelock 是 Android 為了讓裝置可以更積極的休眠又不妨礙正常工作的進行而加入的機制，究竟是好是壞已經在 LKML 與 LWN 上面討論過非常多次，可以參考：

• Wakelocks and the embedded problem
• Blocking suspend blockers
• Suspend block api (version 7)

失眠症

開始測試 TOI 的效果時遇到的第一個問題就是失眠症，因為 wakelock 從中作梗，導致每次休眠到一半就被取消掉。原來是因為 TOI 的休眠途徑會先強制檔案系統把內容寫回，而 MMC 子系統會在寫入/讀取一段時間後嘗試進入低耗電模式，偏偏 Android 在這裡安插了一個 wakelock，導致之後要凍結所有執行緒的時候失敗。

解法，首先因為休眠的後半段路徑其實就是要準備進行關機，而一般來說休眠都是人為啟動，因此可以假設此時使用者了解工作可能還未完成，可以忽略 wakelock，所以第一個 patch 就是讓休眠的路徑不去檢查 wakelock，避免像 MMC 這樣的問題。

https://gitorious.org/0xlab-kernel/kernel/commit/3bb5d6f

接下來是一般的待機路徑，似乎是因為新的 kernel 會積極的嘗試把 MMC 變成低耗電模式，但 OMAP 預設的 MMC timeout 是 100 毫秒，把工作放在 Queue 裡面反而不斷鎖住 wakelock 讓 Android 無法休眠，第二個 patch 就是讓 MMC 子系統在準備休眠的時候就不要作無謂的掙扎，直接進入低耗電模式。

https://gitorious.org/0xlab-kernel/kernel/commit/88823b9

嗜睡症

解決了失眠症沒想到接下來遇到嗜睡症，因為手機插著 USB 的時候是不會真正睡著的，所以一直沒機會觀察 Android 睡著是怎麼樣，原來只把 kernel 叫醒是沒用的，Android 還會檢查目前的 input event 是否屬於 user activity 的範圍，是的話才會把整個系統帶醒，不然因為 wakelock 的機制，馬上就會又睡著。

參考：

• Android Power Management

These are some of the slides from the technical speakers of the Android System Development Forum on April 28th, 2011. Copyrights belong to their perspective owners and distributed under their permission.

Android RenderScript on LLVM
by 廖世偉 博士
<iframe height="525" src="http://www.slideshare.net/slideshow/embed_code/8103150" width="640"></iframe>

Is parallel programming hard? And if so, what can you do about it?
by Paul McKenney
<iframe height="525" src="http://www.slideshare.net/slideshow/embed_code/8103031" width="640"></iframe>

Guides To Analyzing WebKit Performance
by Holger Freyther and Jim (jserv) Huang 黃敬群
<iframe height="525" src="http://www.slideshare.net/slideshow/embed_code/8042012" width="640"></iframe>

Linaro and Android Kernel
by Andy Green
<iframe height="525" src="http://www.slideshare.net/slideshow/embed_code/8109213" width="640"></iframe>

There are still some slides missing and I’ll keep updating here.

import lightblue
host="12:60:41:7F:03:11"
port=16
client = lightblue.obex.OBEXClient(host,port)
client.connect()
f=file('/home/erin/Desktop/temp','w+')
client.get({'type':"x-bt/message",'name':'1'},f)
f.seek(0)
f.read()
f.close()
client.disconnect()

By coincidence, the abbreviation of this is ASDF, which is kind of geeky…

0xlab is going to co-host this event on 2011/04/28. Please refer to
http://www.digitimes.com.tw/seminar/android_1000428.htm
for more information. The introduction page is in Traditional Chinese, but some of the sessions are in English.

We think there are quite some Android summits out there, but most of them are about application development and business trends. We want to focus on the system development aspect from a more technical point of view.

Oh by the way, did I mention it’s free of charge?

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

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;
}

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;
 }