无语

以前看到CPF，以为是CFP；现在看到CFP，以为是CPF。。。

9 Days in Egypt

埃及艳照新鲜出炉。怀着无比兴奋的心情去，又怀着无比激动的心情回。走马观花的鉴赏了无数的壁画，神庙，浩瀚的沙漠和尼罗河绰绰风姿。但直到今天，耳边却还萦绕着小贩“One dollar”的叫卖声，沙漠露营篝火晚会的鼓声，镜头进沙的吱吱声，还有Hany的那句“你们会想念我的”。历历在目的，却是路边无数的流浪猫和烂尾楼，无处不在的AK47旅游警察，阿拉伯的数字（正宗），和四个蒙面女侠飒爽的英姿。9天的回忆很丰富，心里面默念：我还要出去玩！

Cairo也可以称为雾都了，细沙+薄雾，能见度也只有2、30米；

传说中的萨拉丁城堡没进去很遗憾，留给下次吧；

开罗的司机开车真的很猛，这才叫见缝插针；虽然车很破，但司机叔叔很负责；

开罗旅社的“海鸥面包”大家都很爱；楼下5块钱一个的Kebab汉堡超美味；

地铁女车厢进了2次，第一次抱头第二站冲出，第二次自投罗网用毛巾蒙头做了坏人，感觉比进女厕紧张；

“How old are you？”“Yes~~Yes”；

沙漠Safari处处都是Surprise，头顶探照灯，吃到了最美味的炭烧鸡；虽然语言不通，但心里面很感激开吉普的阿拉伯F4大哥们；

中国人应该更加友好一些，对外国人也好，对本地人也好，Letting our guards down a little bit；

发烧睡在Luxor超不爽的旅店床上度过了2010年的新年；不过很感谢大家的关照，特别是Alva悉心的照顾，让偶第二天就退出了“小废废”的行列；

Luxor Bob Marley hostel is dirty; its owner was always trying to pass the buck to the travelers when something goes wrong, even yelled to us; we felt unsafe staying there;

法语的声光Show和阿斯旺High Dam花了点冤枉钱；

最后大家都放弃了砍价（狂砍）；

Aswan的国际机场只有我们5个人check-in；

“One dollar, one dollar”，“1 for 5 dollar，no？5 for 1 dollar”，“哈比比”，“呀啦呀啦”；

废片超级多；

埃及人很友好，虽然难免会瞄着你的钱袋 :-)

据说，I'm a lucky man；

想念Hany同学；舍命带我们去萨拉丁城堡的司机；沙漠中的阿拉伯F4和韩国志愿者Jin；Luxor的导游老爹，happy new year；开到Aswan的司机可爱的默罕默德同学（police man, rubbish, money money money）；

Susu很可爱，而且这次有了个新名字——“天线宝宝”；

偶像很能干，又能计划，又能砍价，又能辩论，套Alva的话“我们都叫她偶像”；

美丽的公帐引力极大，引无数埃人尽骆驼（可惜没能打折啊），而且是最后一个“挂掉”；

Alva同学尽显“小废废”本色，不过一直在照顾我，真的很感动；

最后，一定不辜负大家的希望，早日跪拜大神。

另友情TK链接同去两位女侠的picasa:
http://picasaweb.google.com/chensu0714
http://picasaweb.google.com/vickiwang810

无题

看到同住的Kwoon lim正在为病怏怏Joshua煮晚餐，我称赞他说，不愧是哥们儿啊。他回答道：没什么嘛，顺手牵羊而已嘛。

总统府一日游

关键词：高尔夫球场，植物园，稀世珍宝，没看到丹哥，热

图解CUDA中用多线调度执行来隐藏内存访问延迟的机制

最近在捣鼓CUDA，实现的几个小算法速度能提高到40～50x单线CPU的程度。可惜现在这边弄这个的人不多，基本没有“真人交流”。希望今后能用来做一些实际的项目，发挥一下潜能。嘿嘿。

最近应该会写一些心得，记录一下学习过程。我其实是一直有心做这样的事情，只是懒…… 从今天开始，哈哈。

图解CUDA中用多线调度执行来隐藏内存访问延迟的机制

GPU和device RAM之间带宽虽宽（如GTX285的150GB/s)，不过内存访问延迟依旧很大（400～600 cycles)。CPU用cache可以很好的解决内存延迟；不过GPU由于要处理的通常是大规模的数据集，源数据的locality或许并不高，即便加上很大的data cache效果也不一定好，所以索性放弃了data cache，换而采用用户可控的shared memory来开发data locality。最重要的，虽然GPU的一个处理器(SM - Streaming Multiprocessor)同时只能执行一个warp的线程(32个）,但却可以容纳大量的活动线程(active threads <= 1024)。当一个warp由于访问内存而被阻塞时，SM可以马上转为执行其他ready的warp，直到其被内存访问阻塞。只要这样转一圈的时间（执行完一圈其他的warps再转回来到第一个被阻塞的warp的时间）大于600 cycle的延迟，这个延迟就被隐藏了。

下图示意了内存访问延迟不能被完全隐藏的情况。假设SM上只有4个warp，他们需要从内存里面读取数据，在上面计算一把，循环这个过程。当然，我们也可以看成每个warp计算一次就终止了，之后新的warp会产生出来，代替原来那个warp的位置。从图里面很容易看出来虚线部分的latency是怎么被隐藏的；也很容易看出来因为每个warp的计算不够长，所以没有能够隐藏掉所有的latency。

放到现有的G200的architecture上来，每个SM最多1024个active thread，也就是32个warp。每个warp执行一个基本指令需要4个cycle。也就是说，要隐藏600 cycles需要每个warp平均执行 600/4/32 = 4.69个基本指令。这就是为什么推荐compute to memory ratio至少大于5的原因。这还是建立在理想的1024个active thread的情况下的。如果SM上thread少，这个比例还要提高。

RIP

关上灯，耳机中响起《gone too soon》的旋律。歌声中夹杂的气息，呼吸声，点点的喉音，一切听起来都那么清晰，那么近，就像那个人还在耳边歌唱，还没有离去。

我们的这个时代，没有披头士，没有猫王，但是却很幸运的有MJ。他其实一直都是一个天真的孩子。只是，这个世界太复杂。May you rest in peace，默默的，祝福。

C code for Confidence level computation for BER testing

Article is "statistical confidence levels for estimating error probability".

The first function calculates the confidence level (CL) given the number bit errors measured (n), the total number of bits tested (N), and the expected BER (ph).

// CL = 1 - (\Sigma^{0}_{N}(n * ph)^k/(k!)) * e^{-n * ph}
double solve_CL_from_N_n_ph(unsigned N, double n, double ph)
{
 double emnp = exp(-n * ph);
 double sum = 1;
 double product = 1;
 for(unsigned k = 1; k <= N; k++)
 {
  product *= (n * ph / k);
  sum += product;
 }
 sum *= emnp;
 return(1 - sum);
}

The second function computes the minimum number of bits that need to be tested to confirm a certain confidence level (CL) of an expected BER (ph). If the number of bit errors measured upon receiving of such number of bits is less than N, the hypothesis is confirmed positively. The formula to compute n given N greater than 0 is mathematically hard to solve. This function solves by trying out different values of n in a binary search manner using the first function (which is reverse of the function in question) until n is converged to a certain extent.

double solve_n_from_ph_CL_N(double ph, double CL, unsigned N)
{
  if(N==0)
    return(-log(1-CL)/ph);
  else
  {
    // solve n using binary search, based on "solve_CL_from_N_n_ph"
    double upper_n = N/ph * max(100, N), // enlarge at least 100 times
           lower_n = 100000,    // at least 100000 data
           cur_n = upper_n, next_n;
    double min_interval = 100;  // minimum internal to break the search
    while(1)
    {
      double cur_CL = solve_CL_from_N_n_ph(N, cur_n, ph);
      if(cur_CL >= CL) // if calculated value is more confident, try to reduce n
      {
        upper_n = cur_n;
        next_n = lower_n + (upper_n - lower_n)/2;
      } else
      {
        lower_n = cur_n;
        next_n = upper_n - (upper_n - lower_n)/2;
      }
      if(fabs(next_n - cur_n) < min_interval)
        break;
      cur_n = next_n;
    }
    return(cur_n);
  }
}