Mushsen's Blog

EC2上Hadoop集群搭建

2016-01-23T00:00:00+00:00

日子总是过得很快，却近半年时间没有记录一篇博客，开发依然在做着，却少了很多整理的动力，最近开始做恶大规模机器学习相关的东西，需要在EC2上搭建Hadoop集群，做一记录。

1. 一些Attention

在EC2上搭建Hadoop集群，可以先搭建小型集群，一个namenode，3个datanode，配好namenode、datanode的环境之后，存Image，之后要创建百个节点的cluster，从相应Image启动Instance，并修改namenode相关配置即可。
特别注意Security Group的问题，hadoop需要的端口是否都开放了，前期可以all traffic

2. Hadoop搭建步骤

2.1 EC2上set好相应的机器，

由于Elastic Ip在一个region似乎只能保留5个，所以Instance多了之后，这是个问题。
local$ sudo chmod 600 ~/.ssh/pem_key_filename
local$ ssh -i ~/.ssh/pem_key_filename 尝试登陆namenode

2.2 SSH免密码登录配置

配置~/.ssh/config,实现local免密码登录namenode
配置namenode到all datanode的免密码ssh

namenode$ ssh-keygen -f ~/.ssh/id_rsa -t rsa -P ""
namenode$ cat ~/.ssh/id_rsa.pub >> ~/.ssh/authorized_keys
cat ~/.ssh/id_rsa.pub | ssh datanode1 'cat >> ~/.ssh/authorized_keys'
cat ~/.ssh/id_rsa.pub | ssh datanode2 'cat >> ~/.ssh/authorized_keys'
cat ~/.ssh/id_rsa.pub | ssh datanode3 'cat >> ~/.ssh/authorized_keys'

之后可以从namenode免密码登录各个datanode，使用public dns或者private ip都可以

2.3 Hadoop2.7安装

可以使用ITerm2同时在多个机器安装环境（在一台机器安装环境之后存Image，从Image启动其他机器，是更好的方式）

allnodes$ sudo apt-get update
allnodes$ sudo apt-get install openjdk-7-jdk
allnodes$ java -version
allnodes$ wget http://apache.mirrors.tds.net/hadoop/common/hadoop-2.7.1/hadoop-2.7.1.tar.gz -P ~/Downloads

解压后将hadoop-2.7.1 rename成hadoop并mv到/usr/local/下
增加haoop相关环境变量，vim ~/.profile

export JAVA_HOME=/usr
export PATH=$PATH:$JAVA_HOME/bin
export HADOOP_HOME=/usr/local/hadoop
export PATH=$PATH:$HADOOP_HOME/bin
export HADOOP_CONF_DIR=/usr/local/hadoop/etc/hadoop

allnodes$ . ~/.profile

2.4 Hadoop配置(All Node)

allnodes$ sudo vim $HADOOP_CONF_DIR/hadoop-env.sh

export JAVA_HOME=/usr

vim $HADOOP_CONF_DIR/core-site.xml

<configuration>
  <property>
    <name>fs.defaultFS</name>
    <value>hdfs://`namenode_public_dns`:9000</value>
  </property>
</configuration>

vim $HADOOP_CONF_DIR/yarn-site.xml

<configuration>
  <!-- Site specific YARN configuration properties -->
  <property>
    <name>yarn.nodemanager.aux-services</name>
    <value>mapreduce_shuffle</value>
  </property> 
  <property>
    <name>yarn.nodemanager.aux-services.mapreduce.shuffle.class</name>
    <value>org.apache.hadoop.mapred.ShuffleHandler</value>
  </property>
  <property>
    <name>yarn.resourcemanager.hostname</name>
    <value>`namenode_public_dns`</value>
  </property>
</configuration>

allnodes$ sudo cp $HADOOP_CONF_DIR/mapred-site.xml.template $HADOOP_CONF_DIR/mapred-site.xml
vim $HADOOP_CONF_DIR/mapred-site.xml

<configuration>
  <property>
    <name>mapreduce.jobtracker.address</name>
    <value>`namenode_public_dns`:54311</value>
  </property>
  <property>
    <name>mapreduce.framework.name</name>
    <value>yarn</value>
  </property>
</configuration>

2.5 Hadoop配置(Name Node)

vim /etc/hosts
namenode_hostname, like ip-172-31-35-242

127.0.0.1 localhost
namenode_public_dns namenode_hostname
datanode1_public_dns datanode1_hostname
datanode2_public_dns datanode2_hostname
datanode3_public_dns datanode3_hostname

::1 ip6-localhost ip6-loopback
fe00::0 ip6-localnet
ff00::0 ip6-mcastprefix
ff02::1 ip6-allnodes
ff02::2 ip6-allrouters
ff02::3 ip6-allhosts

vim $HADOOP_CONF_DIR/hdfs-site.xml

<configuration>
  <property>
    <name>dfs.replication</name>
    <value>3</value>
  </property>
  <property>
    <name>dfs.namenode.name.dir</name>
    <value>file:///usr/local/hadoop/hadoop_data/hdfs/namenode</value>
  </property>
</configuration>

namenode$ sudo mkdir -p $HADOOP_HOME/hadoop_data/hdfs/namenode
namenode$ sudo touch $HADOOP_CONF_DIR/masters
vim $HADOOP_CONF_DIR/masters

namenode_hostname

vim $HADOOP_CONF_DIR/slaves

datanode1_hostname
datanode2_hostname
datanode3_hostname

namenode$ sudo chown -R ubuntu $HADOOP_HOME

2.6 Hadoop配置(Data Node)

vim $HADOOP_CONF_DIR/hdfs-site.xml

<configuration>
  <property>
    <name>dfs.replication</name>
    <value>3</value>
  </property>
  <property>
    <name>dfs.datanode.data.dir</name>
    <value>file:///usr/local/hadoop/hadoop_data/hdfs/datanode</value>
  </property>
</configuration>

datanodes$ sudo mkdir -p $HADOOP_HOME/hadoop_data/hdfs/datanode
datanodes$ sudo chown -R ubuntu $HADOOP_HOME

3. Hadoop Start

namenode$ hdfs namenode -format, all the data previous on it will lost
namenode$ $HADOOP_HOME/sbin/start-dfs.sh
在浏览器打开namenode_public_dns:50070，查看Cluster的状态，应该有3个Live Nodes
启动YARN以及MapReduce JobHistory Server

namenode$ $HADOOP_HOME/sbin/start-yarn.sh
namenode$ $HADOOP_HOME/sbin/mr-jobhistory-daemon.sh start historyserver

jps查看namenode的状态

namenode$ jps
JobHistoryServer
Jps
SecondaryNameNode
ResourceManager
NameNode

jps查看datanode的状态

datanodes$ jps
NodeManager
DataNode
Jps

Linux下使用crontab创建定时任务

2015-07-15T00:00:00+00:00

项目中用到了crontab做定时任务，定时任务应该是Web开发中比较常见的一种机制，比如某个状态被Locked住，一定时间后，需要将其release。而Linux提供了方便简单的命令，即可实现这一功能。

1. Crontab相关命令

查看当前用户的定时任务：crontab -l
修改、删除、新增定时任务：crontab -e
注释掉定时任务：#
删除定时任务：crontab -r
ubuntu下，crontab重启 sudo /etc/init.d/cron restart

2. 定时任务格式

59 23 * * * /home/oracle/scripts/alert_log_archive.sh > /dev/null 2 > &1

第一列C1：分钟1-59
第二列C2：小时1-23
第三列C3：日 1-31
第四列C4：月 1-12
第五列C5：星期 0-6
第六列C6：Command

C1-C5通过组合方式决定执行脚本的频率，最小频率为每分钟一次，Cn可以用*; */n; T1-T2; a, b, c四种形式

C1为表示每分钟执行，C2为表示每小时执行
C1为/n表示每n分钟时间间隔执行，C2为/n表示每n小时执行
C1为T1-T2表示从第T1分钟到第T2分钟这段时间执行，C2为T1-T2表示从第T1小时到第T2小时这段时间执行
C1为a，b，c表示第a，b，c分钟都要执行，C2为a，b，c表示第a，b，c小时执行

3. 定时任务例子

//每天23点59执行
59 23 * * * command

//每5分钟执行
*/5 * * * * command

//周一到周五每天下午20:00执行
0 20 * * 1-5 command

Wechat开发，与Server的接入步骤，验证成为开发者

2015-06-11T00:00:00+00:00

之前开发ucaslife的时候，做了一些微信开发，已经是一年半以前的事情了，微信开放的接口越来越多，包括数据统计接口、微信小店、微信门店、设备功能接口等，可玩性也越来越强。而微信也逐渐成为国内第一大的用户流量入口。

由于未来以及现在的需要，重新好好整理微信开发相关的东西，PHP始终是一门不怎么喜欢的语言，使用python/ruby重新开始走一遍微信开发的流程，当一个学习与巩固。

1. 在微信后台填写服务器配置

开发者需要依次完成：填写服务器配置（绑定业务处理的应用程序代码，微信将相应请求转发到开发者自己编写的业务处理代码）；验证服务器地址的有效性（一次性的操作，验证一次即可，即通过用户设定的token做身份标识符，微信后台与用户编写的Server做握手）；依据接口文档实现业务逻辑，即用户编写的Server。

1.1. 服务器配置

http://mp.weixin.qq.com/登陆后台，在公众平台后台管理页面 - 开发者中心页，点击“修改配置”按钮，填写服务器地址（URL）、Token和EncodingAESKey，对于Tornado来说，URL即对应一个业务处理的URL，用户用其接收微信消息和事件。Token由开发者自己填写，用作生成签名（验证代码与微信后台都需要填写，用于握手）。EncodingAESKey由开发者手动填写或随机生成，将用作消息体加解密密钥。

1.2. 验证服务器地址的有效性

开发者提交信息后，微信服务器发送GET请求到填写的服务器地址URL，GET请求携带signature、timestamp、nonce(random number)、echostr(random string) 4个参数，其中signature由token、timestamp、nonce生成，一块传到服务器，便于服务器根据自己记录的token与timestamp、nonce生成身份验证码，与signature做比对。

当服务器确定这次GET请求来自微信服务器，则原样返回echostr参数内容，接入生效，成为开发者成功，否则接入失败。

具体校验算法：将token、timestamp、nonce三个参数进行字典序排序；将三个参数字符串拼接成一个字符串进行sha1加密；开发者获得加密后的字符串可与signature对比，标识该请求来源于微信。

1.3 依据接口文档实现业务逻辑

验证URL有效后，即可成为开发者，如果公众号类型为服务号（订阅号只能使用普通消息接口），可以在公众平台网站中申请认证，认证成功的服务号将获得众多接口权限。关于服务号与订阅号的区别，订阅号会被归入到Subscriptions中，而服务号会处于会话列表中。需要注意，验证代码只需要运行一次即可。

此后用户向公众号发送消息、或者产生自定义菜单点击事件时，微信服务器将转发消息和事件到开发者填写的服务器配置URL，然后开发者可以依据自身业务逻辑进行响应，例如回复消息等。发生错误时的全局返回码说明：http://mp.weixin.qq.com/wiki/17/fa4e1434e57290788bde25603fa2fcbd.html。

用户向公众号发送消息时，公众号方收到的消息发送者是一个OpenID，是使用用户微信号加密后的结果，每个用户对每个公众号有一个唯一的OpenID。即出于保证用户隐私考虑，不可逆加密。另外微信公众号接口只支持80端口。

还有一个UnionID，暂时没看明白是干嘛的，暂时应该也用不到，在此mark。

2. 身份验证

服务器后台直接在已有的Serve上加了一个接口，因此是Nginx+Tornado的配置，Nginx监听80端口，做htt服务器，Tornado做业务处理的服务器。但是Nginx+Tornado 的架构，身份验证通不过，怀疑是处理身份验证的Tornado监听的是8888端口，而非80端口的缘故，将Nginx取掉就好了，有待解决。

def get(self):                                                                                                                
	wh = wechatHandler.WechatHandler()
        
  	signature = self.get_argument('signature')
  	timestamp = self.get_argument('timestamp')
    nonce     = self.get_argument('nonce')
    echostr   = self.get_argument('echostr')                                                                                                                                        
                
    if wh.checksignature(signature, timestamp, nonce):
        self.write(echostr)
    else:
        self.write('fail')

def checksignature(self, signature, timestamp, nonce):
	args = []
    args.append('token')
    args.append(timestamp)
    args.append(nonce)
    args.sort()
    mysig = hashlib.sha1(''.join(args)).hexdigest()
    return mysig == signature

Ruby中的一些语法概念

2015-06-07T00:00:00+00:00

开始在luonet指导下搞ruby，之前稍微有过一些接触，语法各方面跟python差不多。ruby有rails，python有django，大同小异。主要是熟悉ruby语法之后对元编程以及ralis的熟悉。跟着http://learnrubythehardway.org/book/扫一遍cookbook。

1. 对.rb文件中ASCII字符出问题的处理

在.rb文件头加入# -*- coding: utf-8 -*-即可，这点与python一样，指定文件的编码格式。

2. 单行以及多行注释

单行注释使用#, 多行注释使用=begin =end组成的块，这点与python使用''' ''' 块不一样。

3. 自动进行运算

#{}会自动运算{}内的内容，并用运算结果替换#{}，比如：puts "greater? #{5 > -2}"，当在＃之前加入\则不会替换，原样输出。

4. 定义一个格式化的字符串

使用#{}也可以，但是可能多次需要以一个相同格式进行输出，定义一个formatter则显得更为直观。

formatter = "%{first} %{second} %{third} %{fourth}"
puts formatter % {first: 1, second: 2, third: 3, fourth: 4}
puts formatter % {first: true, second: false, third: true, fourth: false}
puts formatter % {first: formatter, second: formatter, third: formatter, fourth: formatter}

5. 获取输入

需要注意print不带’\n’，而puts自带’\n’

print "How old are you? "
age = gets.chomp   # 获取用户输入，直到'\n'出现
age = gets.chomp.to_i  # 将输入转成整数

6. 命令行输入参数

first, second, third = ARGV

puts first
puts second
puts third

Ruby中的文件操作

2015-06-07T00:00:00+00:00

ruby的相关文件操作。

close 关闭文件
read 读取整个文件内容
readline 读取文件的一行，通过移动文件指针实现
truncate 做字段截断
write(‘stuff’) 将字段写入文件

1. 文件读取

filename = ARGV.first
txt = open(filename)
puts txt.readline
puts "-----------"
puts txt.readline

2, 文件写入

filename = "test.txt"
txt = open(filename, 'w')
line = "line in test.txt"
txt.write(line)
txt.write("\n")
txt.close

Protobuf中对于repeated字段的操作

2015-06-05T00:00:00+00:00

protobuf中，一个message可以认为是一个类，在protoc编译之后，会生成其内部各成员的set、get方法。而对于一个class内的元素，无外乎是单个元素，或者集合元素。这篇文章总结C++以及python下对protobuf中集合元素的序列化及反序列化操作。

1. TaskInfo.proto

package taskInfo;                                                                                                                 

message AcquireTrain {
    required int32 num = 101;
}

message TrainTasks {
    required bool enough = 102;
    required int32 num   = 103;

    message TaskKey {
        required string key = 104;
    }

    repeated TaskKey keys = 105;
}

2. C++下的序列化与反序列化

2.1 测试代码

#include "TaskInfo.pb.h"                                                                                                          
#include <fstream>
#include <sstream>
#include <iostream>
#include <unistd.h>
#include <string>

using namespace std;

void ListMsg(const taskInfo::TrainTasks &tasks) 
{
    cout << tasks.enough() << endl;
    cout << tasks.num() << endl;  
    for (int i = 0; i < tasks.keys_size(); ++i) {
        const taskInfo::TrainTasks::TaskKey &tKeys = tasks.keys(i);
        std::cout << tKeys.key() << std::endl; 
    }
}

int main(void)
{
    taskInfo::TrainTasks tasks;
    tasks.set_enough(1); 
    tasks.set_num(6);
    
    int N = 6;
    for (int i = 0; i < N; ++i) {
        taskInfo::TrainTasks::TaskKey *keys = tasks.add_keys();  
        
        std::stringstream ss;
        std::string str;
        ss << i;
        ss >> str;
        std::string key = "A01.0.tif-" + str;
        keys -> set_key(key);
    }

    fstream output("./log", ios::out | ios::trunc | ios::binary);

    if (!tasks.SerializeToOstream(&output)) {
         cerr << "Failed to write msg." << endl;
         return -1;
    }
    output.close();
    
    taskInfo::TrainTasks tasks_get;
	fstream input("./log", ios::in | ios::binary);   
    if (!tasks_get.ParseFromIstream(&input)) {
         cerr << "Failed to parse address book." << endl;
         return -1;
    }
    input.close();
    ListMsg(tasks_get);
    
    return 0;
}

2.2 相应的Makefile

all: test                                                                                                                         

clean:
      rm -f test  *.o  log  

test: TaskInfo.pb.cc test.cpp
    g++  TaskInfo.pb.cc test.cpp -o test  -lprotobuf -lpthread

3. Python下的序列化与反序列化

#!/usr/bin/env python                                                                                                                                                                                                                                               
#coding=utf-8

import TaskInfo_pb2

tasks = TaskInfo_pb2.TrainTasks()
tasks.enough = 1
tasks.num    = 10
for i in xrange(10):
    task_key = tasks.keys.add()
    task_key.key = "A01.0.tif-" + str(i)

task_serial = tasks.SerializeToString()

#print task_serial
print '------------'

tasks_get = TaskInfo_pb2.TrainTasks()
tasks_get.ParseFromString(task_serial)
print tasks_get.enough

print "sample number: " + str(len(tasks_get.keys))   #check if valid

for i in xrange(10):
    print tasks_get.keys[i].key

Protobuf在C++、Python环境下的应用

2015-06-05T00:00:00+00:00

Protobuf官方支持将proto文件编译成C++, Python, PHP的类，而利用一些开源类库，可以对ruby、php等常见的脚本语言进行支持。项目中需要使用Protobuf的地方，主要在于C++与C++之间的接口，以及Python与C++之间的接口。下面分别针对C++以及Python下的Protobuf，实现序列化及反序列化。

1. user.proto

package user;                                                                                      
message Person {
    required string name = 1;
    required int32 id = 2;
    optional string email = 3;
}

可以认为user是namaspace，而Person是这个命名空间之内的类。使用protoc -I ./ - - cpp_out ./cpp user.proto即可编译出C++所需要的user.pb.cc以及user.pb.h，其中-I指定proto所在的目录，cpp_out指定生成的类所在路径。

2. C++下的序列化与反序列化

2.1 测试代码

#include "user.pb.h"                                                                                                                                                                    
#include <fstream>
#include <iostream>
//#include <unistd.h>

using namespace std;

void ListMsg(const user::Person & user)
{
    cout << user.name() << endl;
    cout << user.id() << endl;
    cout << user.email() << endl;
}

int main(void)
{   
    user::Person user1;
    user1.set_name("Mushsen");
    user1.set_id(8008);
    user1.set_email("mushsen@163.com");
    fstream output("./log", ios::out | ios::trunc | ios::binary);

    if (!user1.SerializeToOstream(&output)) {
         cerr << "Failed to write msg." << endl;
         return -1;
    }
    output.close();
    //slppe(1);

    user::Person user2;
    fstream input("./log", ios::in | ios::binary);
    if (!user2.ParseFromIstream(&input)) {
         cerr << "Failed to parse address book." << endl;
         return -1;
    }
    input.close();
    ListMsg(user2);
    return 0; 
}

注意input, output输入输出文件流一定要关闭，要不在读取的时候，由于并未刷新，将读不到数据，required字段没有值，报错。

2.2 相应的Makefile

all: user                                                                                                                                                                               

clean:
      rm -f user  *.o  log  

user: user.pb.cc user.cpp
    g++  user.pb.cc user.cpp -o user  `pkg-config --cflags --libs protobuf`

3. Python下的序列化与反序列化

使用protoc -I ./ - -python_out ./py user.ptoto即可编译出python所需要的user_pb2.py文件，在需要使用的地方import即可。

#!/usr/bin/env python                                                                                                                                                                   
#coding=utf-8

import user_pb2

person1 = user_pb2.Person()
person1.id = 7007
person1.name = "Mushsen"
person1.email = "mushsen@gmail.com"
person_serial = person1.SerializeToString()

print person_serial
print '------------'

person2 = user_pb2.Person()
person2.ParseFromString(person_serial)
print person2.id
print person2.name
print person2.email

Protobuf实现程序的配置文件管理II

2015-06-05T00:00:00+00:00

protobuf配置文件中多层嵌套，或者多组参数的情况。

1. config.proto

package config;                                                                                                                   

message student
{
    required string name = 1;
    required int32  age  = 2;
    optional string addr = 3;
}

message classes
{
    required string name    = 1;
    repeated student member = 2;
}

2. 最终存储/读取的config.cfg

name: "Communication 2004"                                                                                                        
member {
  name: "flyan338"
  age: 26
  addr: "china"
}
member {
  name: "likeliu"
  age: 25
  addr: "china"
}
member {
  name: "gaoy"
  age: 24
  addr: "American"
}

3. C++对pb配置文件的存取

#include "config.pb.h"
#include <stdlib.h>  
#include <stdio.h>  
#include <errno.h>
#include <string.h>  
#include <iostream>  
#include <fcntl.h>  
#include <fstream>  
#include <cstdio>  
#include <google/protobuf/text_format.h>                                                                                          
#include <google/protobuf/io/zero_copy_stream_impl.h>

using namespace std;

void save_config(string &file_name, string &contect)
{
    ofstream fout;
    fout.open(file_name.c_str(), ios::out| ios_base::ate);

    if (!fout.is_open()) {
        fprintf(stderr, "open config.cfg fail\n");
        exit(-1);
    }

    fout << contect <<endl;
    fout.flush();
    fout.close();                                                                                                                 
}

void load_config(string &file_name, config::classes &cs)
{
    int fd = open("config.cfg", O_RDONLY);

    if (fd < 0) {
        printf("open config.cfg failure:%s \n",strerror(errno));
        exit(-1);
    }

    google::protobuf::io::FileInputStream fileInput(fd);
    fileInput.SetCloseOnDelete(true);
    google::protobuf::TextFormat::Parse(&fileInput, &cs);  
}

int main(void)
{
    config::classes cs;
    cs.set_name("Communication 2004");
    
    config::student* t = cs.add_member();
    
    t->set_name("flyan338");
    t->set_age(26);
    t->set_addr("china");
    
    t = cs.add_member();
    t->set_name("likeliu");
    t->set_age(25);
    t->set_addr("china");
 
    t = cs.add_member();
    t->set_name("gaoy");
    t->set_age(24);
    t->set_addr("American"); 
    
    // protobuf to string
    string contect;
    google::protobuf::TextFormat::PrintToString(cs, &contect);
    
    string file_name = "config.cfg";
    save_config(file_name, contect);    

    cout << "\n---------Save config done.-----------\n" << endl;

    config::classes cs2;
    load_config(file_name, cs2);

    for (int i = 0; i < cs2.member_size(); ++i) {
        cout << "name: " << cs2.member(i).name() << " | ";
        cout << "age: " << cs2.member(i).age() << " | ";
        cout << "addr: " << cs2.member(i).addr() << endl;
    }

    cout << "\n---------Load config done.-----------\n" << endl;
    return 0;
}

Protobuf实现程序的配置文件管理I

2015-06-05T00:00:00+00:00

程序中一般需要load一些参数列表，直接以一种自己约定的格式写在txt文件中，可读性不高且程序的通用性不强，换一个程序员，就没辙了；而xml这种方式一直是一种老旧且蛋疼的方法。使用protobuf通过rpc协议进行网络传输很爽，虽然这次无奈蛋疼地拿pb来作为http传输的包。通过pb来管理程序的配置文件，也是一个很好的思路，操作比较方便。

为了提高网络传输的效率，pb序列化之后的数据为二进制存储，基本不可读。不过protobuf具有类似google::protobuf::TextFormat的接口，可以支持文本输出，如此，可以将pb作为一个简单的配置管理库。

1. config.proto

package config;                                                                                                                   

message Configure
{
    required string host = 1;
    required uint32 port = 2;
}

2. 最终存储/读取的config.cfg

host: "127.0.0.1"                                                                                                                 
port: 8080

3. C++对pb配置文件的存取

#include "config.pb.h"                                                                                                            
#include <stdlib.h>  
#include <stdio.h>  
#include <errno.h>
#include <string.h>  
#include <iostream>  
#include <fcntl.h>  
#include <fstream>  
#include <cstdio>  
#include <google/protobuf/text_format.h>  
#include <google/protobuf/io/zero_copy_stream_impl.h>

using namespace std;

void save_config(string &file_name, string &contect)
{
    ofstream fout;
    fout.open(file_name.c_str(), ios::out| ios_base::ate);

    if (!fout.is_open()) {
        fprintf(stderr, "open config.cfg fail\n");
        exit(-1);
    }

    fout << contect <<endl;
    fout.flush();
	fout.close(); 
}

void load_config(string &file_name, config::Configure &config)
{
    int fd = open("config.cfg", O_RDONLY);

    if (fd < 0) {
        printf("open config.cfg failure:%s \n",strerror(errno));
        exit(-1);
    }

    google::protobuf::io::FileInputStream fileInput(fd);
    fileInput.SetCloseOnDelete(true);
    google::protobuf::TextFormat::Parse(&fileInput, &config);  
}

int main(void)
{
    config::Configure config;
    config.set_host("127.0.0.1");
    config.set_port(8080);

    string contect;
    google::protobuf::TextFormat::PrintToString(config, &contect);
    
    string file_name = "config.cfg";
    save_config(file_name, contect);    

    cout << "\n---------Save config done.-----------\n" << endl;

    config::Configure config2;
    load_config(file_name, config2);

    cout << "host: " << config2.host() << endl;
    cout << "port: " << config2.port() << endl;

    cout << "\n---------Load config done.-----------\n" << endl;
    return 0;
}

Protobuf在Ubuntu14.04下的安装

2015-06-04T00:00:00+00:00

最近项目需要使用protobuf做序列化与反序列化的工作，一般来说，在CS模式的架构中，经常使用protobuf作为进程间通信的工具，相对于使用rest传递json串的方式来说，protobuf可以基于tcp传输，组包上具有得天独厚的优势，效率很高。而protoc编译器，便于在跨语言的进程之间使用。

但是在项目中，仅仅使用protobuf作为序列化与反序列化的方式，仍然使用http进行发送，显得有点微微的蛋疼。在ubuntu的安装出了不少问题，以此记录。

1. protobuf源码安装

1.1 不支持https

从https://github.com/google/protobuf下载protobuf的源码，按照README中的说明，使用./autogen.sh去生成configure文件，autogen脚本的执行依赖于openssl，即是一种https的请求，而默认安装的curl，是未开启ssl支持的，从curl -V即可看到支持的请求类型。

从http://curl.haxx.se/下载libcurl的最新版，在configure阶段，加入对ssl的支持。从 http://www.openssl.org/下载openssl的源码，编译安装，在curl目录中，通过 sudo ./configure --with-ssl --with-libssl-prefix=/usr/local/ssl开启ssl支持。之后make安装。

1.2 ./autogen.sh: 4: autoreconf: not found错误，

通过安装automake工具解决：sudo apt-get install autoconf automake libtool，正常的make安装protobuf即可。默认安装的是C++的package，包括了protoc编译器，若要继续安装python package，则进入python目录，依次执行python setup.py build，python setup.py install

1.3 protoc: error while loading shared libraries

protobuf的默认安装路径是/usr/local/lib，而/usr/local/lib 不在Ubuntu体系默认的 LD_LIBRARY_PATH 里，所以就找不到该lib，可以通过创建文件/etc/ld.so.conf.d/libprotobuf.conf 包含内容/usr/local/lib ，输入命令sudo ldconfig更新缓存解决。

2. protobuf通信框架

一般protobuf结合tcp通信协议发挥其轻量的特性，在大规模网站架构中，使用较多，有效提高网络传输效率。百度开源的通信协议包，sofa-pbrpc，https://github.com/BaiduPS/sofa-pbrpc/wiki，做个记录。

二叉树从根到叶子是否存在和为给定值的路径

2015-05-28T00:00:00+00:00

给一颗二叉树和一个整数，判断该二叉树是否有一条从根到叶子的路径，路径上的和为给定的和。通过BFS、DFS都可以做，按照题目性质，DFS应该是更合适的解法。

1 BFS：

class Solution {
public:
    bool hasPathSum(TreeNode* root, int sum) {
        if (root == NULL)
            return false;
        
        stack<pair<TreeNode *, int> > st;
        st.push(pair<TreeNode *, int>(root, root->val));
        
        int curSum = 0;
        while (!st.empty()) {
            TreeNode *cur = st.top().first;
            curSum = st.top().second;
            st.pop();
            //注意题目要求到叶子节点，如果是从根到任意节点，这里做变化即可
            if (cur -> left == NULL && cur -> right == NULL && curSum == sum)  
                return true;
            
            if (cur -> left) {
                st.push(pair<TreeNode *, int>(cur -> left, curSum+cur->left->val));
            }
            if (cur -> right) {
                st.push(pair<TreeNode *, int>(cur -> right, curSum+cur->right->val));
            }
        }
        return false;
    }
};

2 递归DFS：

class Solution {
public:
    bool hasPathSum(TreeNode* root, int sum) {
        if (root == NULL)
            return false;
        
        if (root -> left == NULL && root -> right == NULL)
            return root -> val == sum;
        
        return hasPathSum(root -> left, sum - root->val) || hasPathSum(root -> right, sum - root->val);
    }
};

3 后根遍历DFS：

class Solution {
public:
    bool hasPathSum(TreeNode* root, int sum) {
        stack<TreeNode *> st;
        TreeNode *cur = root;
        TreeNode *pre = NULL;
        
        int curSum = 0;
        while (cur || !st.empty()) {
            while (cur != NULL) {
                st.push(cur);
                curSum += cur -> val;
                cur = cur -> left;
            }
            
            cur = st.top();
            if (cur -> left == NULL && cur -> right == NULL && curSum == sum)
                return true;
            
            if (cur -> right != NULL && cur -> right != pre) {
                cur = cur -> right;
            }
            else {
                pre = cur;
                st.pop();
                curSum -= cur -> val;
                cur = NULL;  
                // 这里需要注意，会进入这里的，则cur的子节点都已经处理过，而st.top()的子节点已经入栈
            }
        }
        return false;
    }
};

二叉树的最大深度

2015-05-27T00:00:00+00:00

求二叉树的最大深度，比较简单的一个题目，使用DFS、BFS都可以，关键是空间复杂度的优化。

1 递归DFS，使用logn：

class Solution {
public:
    void depth(TreeNode *root, int level, int &maxL) {
        maxL = max(level, maxL);
        
        if (root -> left)
            depth(root -> left, level+1, maxL);
        
        if (root -> right)
            depth(root -> right, level+1, maxL);
    }

    int maxDepth(TreeNode* root) {
        if (root == NULL)
            return 0;
        
        int maxL = 0;
        depth(root, 1, maxL);
    
        return maxL;
    }
};

2 非递归DFS，使用2n的空间：

class Solution {
public:
    int maxDepth(TreeNode* root) {
        if (root == NULL)
            return 0;
            
        stack<pair<TreeNode *, int> > st;
        st.push(pair<TreeNode *, int>(root, 1));
        int maxL = 0;
        while (!st.empty()) {
            TreeNode *cur = st.top().first;
            int cur_level = st.top().second;
            st.pop();
            maxL = max(cur_level, maxL);
            
            if (cur -> left)
                st.push(pair<TreeNode *, int>(cur -> left, cur_level+1));
            if (cur -> right)
                st.push(pair<TreeNode *, int>(cur -> right, cur_level+1));
        }
        return maxL;
    }
};

3 非递归DFS，使用n的空间：

class Solution {
public:
    int maxDepth(TreeNode* root) {
        if (root == NULL)
            return 0;
            
        queue<TreeNode *> q;
        q.push(root);
        int res = 0;
        while (!q.empty()) {
            res ++;
            for (int i = 0, n = q.size(); i < n; ++i) {
                TreeNode *cur = q.front();
                q.pop();
                if (cur -> left)
                    q.push(cur -> left);
                if (cur -> right)
                    q.push(cur -> right);
            }
        }
        return res;
    }
};

Edison开发版连接

2015-05-25T00:00:00+00:00

之前稍微玩过一下puDuino，即俗称的超树莓派，拥有丰富的IO资源，基于Arduino开源平台。使用的是国产的处理器，使用ARM的授权IP，主频大概1GHz，内存1GB，运行一个改良版的Ubuntu系统，用户体验非常好。最近拿了一个Intel去年针对智能硬件领域推出的处理器Edison，其其包括Mini breakout board版本（只有一个SD卡大小），以及针对Arduino平台进行了定制，即Arduino expansion board版本（见下图），开发资源与Arduino的一套东西类似。

1.Edison Arduino expansion board连接

1.1 设备连接

如果是新买的产品，首先需要将Intel Edison board与Arduino expansion board连接，即将Edison对应的CPU模块针脚插到expansion board的相应位置上。这样的设计，便于更换CPU。电源为7v～15V的DC电源，我拿的是一个9V的电源，在board上的电源接口为正常的的DC接口，而puDuino则直接是 micro-USB接口做电源。

与Laptop的连接：

将DC连到电源，board上的绿色指示灯会呈常亮状态
将两个micro-USB与Laptop的USB进行连接
将USB与micro-USB中间的microswitch移到micro-USB一侧

通过Terminal连接Edison

Edison通过USB与Laptop连接（为什么需要连接两个USB？当只连接一个USB时，找不到设备），由于Unix系统对串口设备免驱动，因此当使用windows系统时，还需要安装相应的驱动程序，具体可以参照https://software.intel.com/en-us/installing-drivers-for-intel-edison-board-with-windows
ls /dev/tty.usbserial-* 可以看到我们的Edison设备

1.2 MAC OS X/Ubuntu与Edison连接

使用screen工具与设备连接，使用screen连接，运行程序时可以方便地查看程序的输出结果。screen -L /dev/tty.usbserial-A402ISYE 115200 –L，Enter之后会出现黑屏，连续单击两次Enter键，即可进入Login界面，直接输入root，即可登录成功。需要说明的是，Edison一类的硬件开发版，需要直接操作底层的GPIO等资源，因此一般需要直接食用root登录。
Ubuntu 通过screen连接Edison，sudo screen /dev/ttyUSB0 115200

2.通过WiFi连接Edison

输入以下命令，进行WiFi配置，configure_edison --wifi，如果配置失败，则需要刷新固件；Edison会开始扫描可用的WiFi网络，并列出；选择序号、输入密码，即可以进行连接；成功的状态返回如下：

连接网络成功后，可以通过在同一网络的Laptop中ping该Edison的ip，或者在浏览器中，输入192.168.2.3，访问该Edison；若连接存在问题；则可以通过在Edison中通过以下命令进行网络重置。

ifconfig usb0 down
ifconfig wlan0 down
ifconfig wlan0 up

3. 存在的问题

每次断开之后，都需要configure_edison --wifi重新连接wifi，pcDuino有网口，因此不存在这个问题。screen连接，意外断开之后，会存在一些类似拖屏的行为。直接使用ssh连接应该会比较好。

Edison开发版上Linux系统基础软件安装

2015-05-25T00:00:00+00:00

Edison上安装的是一个定制的Linux系统，Yocto。相对于pcDuino平台改良版的Ubuntu，刚上手陌生了不少。而受限于处理器的性能，程序编译运行速度也比pcDuino的体验差。对于非操作IO方面的开发，在本地构建一个Edison的开发环境，在本地开发比较好，涉及到IO或者程序运行的时候，再scp到Yocto上即可。试着在系统上装了几个软件，没有了apt-get，加上处理器性能较低，从源码安装，装软件还是略微麻烦。

vim 安装：从http://www.vim.org/sources.php下载源码包，解压后直接通过make安装即可。
git 安装：可以通过’opkg’命令安装软件，opkg install git即可以安装git。
在Intel官网，介绍了两种IDE的安装，Intel XDK loT Edition, Arduino IDE, Eclipse。之前一直以为是要将IDE安装在Edison上面，其实不然。由于开发版资源性能有限，可以将IDE安装在本地，程序编译好之后，下载到开发版上运行。对于pcDuino，也是一样的机制。在这一块，之前的使用有点问题。

ubuntu内核安装卸载

2015-05-16T00:00:00+00:00

ubuntu下新内核的安装，冗余内核的卸载步骤。

1.内核编译安装

make mrproper 清理内核源码中多次编译产生的残渣
make menuconfig 打开图像界面，配置内核
make -j8 开8个线程，编译内核
make modules_install
make install 安装内核

cp arch/x86/boot/bzImage /boot/
cp System.map /boot/     将编译生成的文件拷贝到/boot/目录下 
sudo mkinitramfs 3.18.5 -o /boot/initrd.img-3.18.5 建立镜像文件
sudo update-initramfs -c -k 3.18.5     
sudo update-grub2     更新修改系统引导配置
cd /boot/grub
vim grub可以查看引导程序(boot loader)的配置文件；

2.内核卸载清理

dpkg —-get-selections | grep linux 列出系统安装的内核，带image的项
sudo apt-get remove linux-image-内核版本
sudo apt-get remove linux-headers-内核版本    自动删除内核文件，释放磁盘空间

先序/中序，中序/后序遍历序列构建二叉树

2015-05-12T00:00:00+00:00

二叉树的构建，前序以及后序遍历序列，都可以定位root节点，当遍历序列没有重复节点的情况下，以root节点为间隔，可以在中序遍历序列中作划分，递归调用，即可构建二叉树。

1 先序/中序遍历序列构建二叉树：

//从preorder顺序取下节点node作为root，则inorder中以node分界，左边构成left，右边构成right，
 //递归调用求解即可
 
class Solution {
public:
    TreeNode *create(vector<int> &preorder, vector<int> &inorder, int ps, int pe, int is, int ie) {
        if (ps > pe)
            return NULL;
        
        int gap = is;
        TreeNode *node = new TreeNode(preorder[ps]);
        for (int i = is; i <= ie; ++i) {
            if (inorder[i] == node->val) {
                gap = i;    
                break;
            }
        }
        node -> left  = create(preorder, inorder, ps+1, ps+gap-is, is, gap-1);
        node -> right = create(preorder, inorder, pe-ie+gap+1, pe, gap+1, ie);   //下标这里容易出错
        return node;
    }

    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        return create(preorder, inorder, 0, preorder.size()-1, 0, inorder.size()-1);
    }
};

2 中序/后序遍历序列构建二叉树：

//与105相比，只是划分的方式不太一样
 
class Solution {
public:
    TreeNode *create(vector<int>& inorder, vector<int>& postorder, int is, int ie, int ps, int pe) {
        if (ps > pe)
            return NULL;
        
        TreeNode *node = new TreeNode(postorder[pe]);
        int gap = is;
        for (int i = is; i <= ie; ++i) {
            if (inorder[i] == node -> val) {
                gap = i;    
                break;
            }
        }
        node -> left  = create(inorder, postorder, is, gap-1, ps, ps+gap-is-1);
        node -> right = create(inorder, postorder, gap+1, ie, ps+gap-is, pe-1);
        return node;
    }

    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        return create(inorder, postorder, 0, inorder.size()-1, 0, postorder.size()-1);
    }
};

从一个有序链表构建二叉检索树

2015-05-11T00:00:00+00:00

由有序链表构建二叉检索树。很长时间没有接触树的题目，没有什么做题的感觉。题目应该从二叉检索树的特点入手，即一颗树，或者为空，或者其左子树的值都小于根节点，右子树的值都不小于其根节点，且左右子树都为二叉检索树。可想而知，若中序遍历一颗二叉检索树，则可以得到一个有序序列，即题目要求是根据加了约束的中序遍历序列，构建二叉树（并不是任意一颗树，都可以只通过中序遍历序列构建）。

由于树是一种递归的结构，因此通过递归来解决树的问题，是一个天然的思路。可以通过快慢指针先找到中间元素，以中间元素为root，将序列划分，前半部分构建左子树，右半部分构建右子树。

1.1 链表结构：

struct ListNode {
	int val;
	ListNode *next;
	ListNode(int x): val(x), next(NULL) {}
};

1.2 树的结构

struct TreeNode {
	int val;
	TreeNode *left;
	TreeNode *right;
	TreeNode(int x): val(x), left(NULL), right(NULL) {}
};

1.3 有序链表到二叉检索树的构建

class Solution {
public:
    TreeNode* sortedListToBST(ListNode* head) {
        if (head == NULL)
            return NULL;
        if (head -> next == NULL)
            return new TreeNode(head -> val);
            
        ListNode *slow = head;
        ListNode *fast = head;
        ListNode *prev;
        while (fast != NULL && fast -> next != NULL) {
            prev = slow;
            slow = slow -> next;
            fast = fast -> next -> next;
        }
        prev -> next = NULL;
        
        TreeNode *root  = new TreeNode(slow -> val);
        TreeNode *left  = sortedListToBST(head);
        TreeNode *right = sortedListToBST(slow -> next);
        root -> left  = left;        
        root -> right = right;
        return root;
    }
};

递归/非递归实现二叉树的前序、中序、后序遍历

2015-05-11T00:00:00+00:00

前序、中序、后序遍历，二叉树常见的几种深度优先遍历算法。本文中依次实现其递归与非递归解法。对于递归解法来说，三种遍历方式的区别，仅仅在于在什么时候，读取当前节点的值。而非递归解法，前序与中序相似，后序遍历稍显麻烦。

1. 前序遍历

1.1 递归解法：

class Solution {
public:
    void travesal(TreeNode *root, vector<int > &ret) {
        if (root == NULL)
            return;
            
        ret.push_back(root -> val);
        
        if (root -> left)
            travesal(root -> left, ret);
            
        if (root -> right)
            travesal(root -> right, ret);
    }

    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> ret;
        if (root == NULL)
            return ret;
        travesal(root, ret);
        return ret;
    }
};

1.2 非递归解法：

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> ret;
        stack<TreeNode *> st;
        if (root != NULL)
            st.push(root);
        
        TreeNode *cur;
        while (!st.empty()) {
            cur = st.top();
            st.pop();
            ret.push_back(cur -> val);
            if (cur -> right != NULL)
                st.push(cur -> right);
            if (cur -> left != NULL)
                st.push(cur -> left);
        }
        return ret;
    }
};

2 中序遍历

2.1 递归解法：

class Solution {
public:
    void travesal(TreeNode *root, vector<int> &ret) {
        if (root == NULL)
            return;
            
        if (root -> left)
            travesal(root -> left, ret);
        
        ret.push_back(root -> val);
        
        if (root -> right)
            travesal(root -> right, ret);
    }

    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> ret;
        if (root == NULL)
            return ret;
        travesal(root, ret);
        return ret;
    }
};

2.2 非递归解法：

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> ret;
        stack<TreeNode *> st;
        
        if (root == NULL)
            return ret;
        
        TreeNode *cur = root;
        while (!st.empty() || cur != NULL) {
            if (cur != NULL) {
                st.push(cur);
                cur = cur -> left;
            }
            else {
                cur = st.top();
                ret.push_back(cur -> val);
                st.pop();
                cur = cur -> right;
            }
        }
        return ret;
    }
};

3 后序遍历

3.1 递归解法：

class Solution {
public:
    void travesal(TreeNode *root, vector<int> &ret) {
        if (root == NULL)
            return;
            
        if (root -> left)
            travesal(root -> left, ret);
            
        if (root -> right)
            travesal(root -> right, ret);
            
        ret.push_back(root -> val);
    }
    
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> ret;
        if (root == NULL)
            return ret;
        travesal(root, ret);
        return ret;
    }
};

3.2 非递归解法：

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> ret;
        stack<TreeNode *> st;
        
        if (root != NULL)
            st.push(root);
            
        TreeNode *cur;
        while (!st.empty()) {
            cur = st.top();
            st.pop();
            ret.insert(ret.begin(), cur -> val);
            if (cur -> left)
                st.push(cur -> left);
            if (cur -> right)
                st.push(cur -> right);
        }
        return ret;
    }
};

使用Python封装MySQL的CRUD操作API

2015-05-08T00:00:00+00:00

Python可以通过mysqldb模块进行mysql操作，整个RDS这一块的代码架构组织，设想是封装一个CRUD的类，对于不同的表操作，分别进行实例化。这样看来，似乎可以在一定程度上减少sql语句的冗余，代码组织更具层次性。

本文实现项目中RDS操作最底层的CRUD封装。首先通过sudo apt-get install python-mysqldb安装mysqldb模块。需要注意的时候，Python代码中如果存在中文注释，需要在#! /usr/bin/python下添加# -*- coding: UTF-8 -*-，否则会因为编码问题报错。以下即为具体的CRUD底层接口实现：

1. 数据库建立连接

def build_connect(self):
    conn = MySQLdb.connect(host = self.host, user = self.user, passwd = self.passwd, port = self.port)
    conn.select_db(self.db)                                                                                                                                                         
    cursor = conn.cursor(
    return (conn, cursor)

2. 数据库释放连接

def free_connect(self, conn, cursor):
    conn.commit()
    cursor.close()
    conn.close()

3. 查询操作

def rdsSelectData(self, cond):
    """
    params: cond-data filter condition.
    """
    try:
        (conn, cursor) = self.build_connect()
            
        query  = 'select * from ' + self.table + ' where ' + cond
        count  = cursor.execute(query)
        result = cursor.fetchall()
            
        self.free_connect(conn, cursor)            
        return result
        
    except MySQLdb.Error, e:
        print 'MySQL Error %d: %s' % (e.args[0], e.args[1])

4. 插入操作

def rdsInsertData(self, fmt, values):
    """
    params: values-string with format and data.
    """
    try:
        (conn, cursor) = self.build_connect()
            
        query  = 'insert into ' + self.table + ' values' + fmt
        cursor.execute(query, values)
       
        self.free_connect(conn, cursor)            
        
    except MySQLdb.Error, e:
        print 'MySQL Error %d: %s' % (e.args[0], e.args[1])

5. 更新操作

def rdsUpdateData(self, cols, values, cond):
    """
    params: cols-list, columns to update; values-list, uodate values; cond-data filter condition.
    """
    try:
        (conn, cursor) = self.build_connect()
            
        query  = 'update ' + self.table + ' set '
        for i in xrange(len(values)):
            col_val = str(cols[i]) + '=' + '"' + str(values[i]) + '",'    
            query += col_val
            
        query =  query[:-1] + ' ' + cond
        cursor.execute(query)
        
        self.free_connect(conn, cursor)            
        
    except MySQLdb.Error, e:
        print 'MySQL Error %d: %s' % (e.args[0], e.args[1])

6. 删除操作

def rdsDeleteData(self, cond):
    """
    params: cond-data filter condition.
    """
    try:
        (conn, cursor) = self.build_connect()
            
        query = 'delete from ' + self.table + '  where ' + cond
        cursor.execute(query)
        
        self.free_connect(conn, cursor)            

    except MySQLdb.Error, e:
        print 'MySQL Error %d: %s' % (e.args[0], e.args[1])

mysql基本操作

2015-05-08T00:00:00+00:00

项目涉及的环境的搭建，包括Nginx的基本配置，基本OK了，目前的方案，与S3的交互，都不使用Backend这边的Python模块去做，而交给Client以及Trainer/Predictor那边的C++模块，相当于在算法模块外面再包一层C++的接口，处理与Server的rest交互，以及与S3的交互。这几天先把与MySQL交互的Python接口封装好。

很长一段时间没有做backend方面的工作了，不少东西都稍微有点生疏，很多基本的MySQL操作，居然都忘了。好在去年这个时候，在阿里云上，写过不少的SQL操作，拾起来倒挺快。

1. MySQL基本操作

mysql -h ip -u user -p    //使用mysql cli连接远程MySQL数据库
show databases;    //列出server上所有的mysql数据库
use mysql;    //选择一个数据库
show tables;    //列出数据库中所有的数据表
create database abc;    //创建数据库
drop database abc;    //删除数据库
CREATE TABLE birth (name VARCHAR(20), sex CHAR(1), birth DATE, birthaddr VARCHAR(20));    //创建一个数据表 
describe birth;    //显示数据表的结构
insert into birth values (′mushsen′,′f′,′1990-10-19′,′china′);    //往数据表插入一条记录
select * from birth;    //查询表中所有的记录
delete from birth;    //删除表中所有的记录
update birth set birthaddr = "usa" where name = "mushsen";    //修改表中的字段

2. 通过txt文件插入数据库

通过文本文件插入数据库，当大批量数据时，可以先将需要插入的记录，批量写到txt文件中，每行包含一条记录，用tab分开，以通过一个简单的C脚本，将数据fprintf到一个文件中，并且按照create table时列出的列次序给出。

birth.txt 文件内容：

mushsen m 1990-10-19 china 　 
vera f 1990-05-12 china 
tom m 1980-09-02 usa

使用如下命令将birth.txt的内容装载到birth表中：

load data local infile "birth.txt" into table birth;

当load data local infile报错，是本地mysql客户端的问题，在登录的时候，需要加入如下选项：

mysql -h ip -u user --local-infile=1 -p

3. 数据库中文支持

可以在创建数据库以及数据表时，指定字符编码实现，如下：

CREATE DATABASE `test`
CHARACTER SET 'utf8'
COLLATE 'utf8_general_ci';

CREATE TABLE `database_user` (
`ID` varchar(40) NOT NULL default '',
`UserID` varchar(40) NOT NULL default '',
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

phpmyadmin管理aws上mysql

2015-05-07T00:00:00+00:00

通过对phpmyadmin的配置，进行远程数据库的管理，主要包括，AWS EC2上面的本地数据库，以及AWS上RDS实例上的MySQL，本质上，其实是一样的，都是对远程数据库的管理。

1. MySQL忘记root账户的解决办法

打开mysql的配置文件，`/etc/mysql/my.cnf`，在[mysqld]字段下加入一行`skip-grant-tables`
重启mysql服务，`sudo service mysql restart`
`mysql`空密码进入命令行管理
`use mysql`选择数据库
`update user set password=PASSWORD("new_pass") where user='root';`更改root账户的密码
`quit`退出
在配置文件中将`skip-grant-tables`注释掉
重启mysql服务，即更改了root密码

2. 配置phpmyadmin连接远程EC2上面的本地数据库

对于phpmyadmin/libraries/config.default.php，做如下修改：

$cfg['PmaAbsoluteUri'] = 'ec2_public_ip/phpmyadmin'
$cfg['Servers'][$i]['host'] = 'ec2_public_ip'
$cfg['Servers'][$i]['user'] = 'root'; 
$cfg['Servers'][$i]['password'] = 'your passwd';

3. 配置phpmyadmin连接AWS RDS实例上面的MySQL

phpmyadmin的配置默认只管理本地的mysql，因此登录界面也没有server的选择功能，可以通过配置phpmyadmin/config.inc.php，配置phpmyadmin可以管理多个Server上的数据库在配置文件中添加如下代码。需要注意的是，加几个这样的代码块，就可以同时管理多少个Server上的Mysql数据库。

$i++;
/* Authentication type */
$cfg['Servers'][$i]['auth_type'] = 'cookie';
/* Server parameters */
/* RDS对应的Endpoint*/
$cfg['Servers'][$i]['host'] = 'xxxx.xxxxxxxxxxxx.ap-northeast-1.rds.amazonaws.com';
$cfg['Servers'][$i]['connect_type'] = 'tcp';
$cfg['Servers'][$i]['compress'] = false;
$cfg['Servers'][$i]['AllowNoPassword'] = false;

nginx配置对php的支持，安装phpmyadmin

2015-05-07T00:00:00+00:00

Nginx默认不支持php解释器，虽然Backend动态语言不使用php，但是比较常用的数据库图形化管理工具phpmyadmin，为php所写，要使用的话，必须配置nginx对php的支持。这一点上，通过FastCGI进行支持。昨天下午配置的时候，遇到各种问题，终于搞定。网上的博客大都年代比较久远，复制粘贴真是没有好下场，记录一下一些要点。

1. Nginx源码安装路径

网上关于配置Nginx对php支持的博客，Nginx大都使用apt-get安装，但我始终感觉apt-get安装的目录组织，操作起来有点麻烦。而通过源码安装，Nginx所有相关的东西，都在/usr/local/nginx目录下，操作显得较为方便。

nginx.conf中配置了root路径，即默认Nginx加载html文件的路径，默认是nginx/html，这一点，影响到下面对php支持的配置项，很多直接复制粘贴别人的配置，不顾自己的环境，肯定成功不了。

2. 安装php-cgi等工具

sudo apt-get install php5-fpm php5-cli php5-cgi mysql-server php5-mysql

3. 安装spawn-fcgi

通过spawn-fcgi，管理FastCgi，它原属于lighttpd，但 9.10 后，spawn-fcgi被分离出来单独成包：

sudo apt-get install spawn-fcgi

4. nginx.conf相关配置

配置nginx.conf，相当于nginx收到关于php请求时，将其转发给后端的php解释器进行处理，cgi的一种典型实现。fastcgi_param 为默认的Web目录，前面默认设置为html，与配置文件中的root设置要对应。最后一个include的文件，位于conf/路径下

index index.php index.html index.htm;

location ~ \.php$ { 
	fastcgi_pass 127.0.0.1:9000; 
	fastcgi_index index.php; 
	fastcgi_param SCRIPT_FILENAME /usr/local/nginx/html$fastcgi_script_name; 
	include fastcgi_params; 
}

5. 需要启动的服务

首先重启nginx，然后启动fastcgi php。当出现error时，可能是nginx转发了请求，但是后端php解释器没有启动，查看一下9000端口的情况netstat –ant | grep 9000。具体可以查看error.log中的相应记录。

spawn-fcgi -a 127.0.0.1 -p 9000 -C 10 -u www-data -f /usr/bin/php-cgi

6. 安装phpmyadmin

首先从http://sourceforge.net/projects/phpmyadmin/下载phpmyadmin的最新版本，解压后，拷贝到/usr/local/nginx/html/中，权限设置成755，则可以通过ip/phpmyadmin进行访问图形化管理界面。

AWS上S3基本操作

2015-05-04T00:00:00+00:00

AWS提供了一套自己的SDK，对于使用Python作为主要Backend语言来说，需要通过boto的接口，来进行S3的操作。操作主要涉及到S3的连接、bucket的建立以及删除，数据的存储、读取、删除操作。

1.基本头文件

import time
import math
import os
import boto
from boto.s3.key import Key                                                                                                       
from boto.s3.connection import Location
from filechunkio import FileChunkIO

2.Bucket的建立与删除

以当前时间戳为key，避免bucket重复，建立之后，插入一个简单的字符串键值对，之后读取。

def create_del_bucket():
    s3 = boto.connect_s3()
    bucket = s3.create_bucket('mhs-demo-%s' % int(time.time()))
    key = bucket.new_key('mhs')
    key.set_contents_from_string("Hello World!")
    time.sleep(2)
    print key.get_contents_as_string()
    key.delete()
    bucket.delete()

3.判断一个Bucket是否存在

def is_bucket_exists(conn):
    bucket = 'mhs_img_bucket'
    valid  = conn.lookup(bucket)
    if valid is None:
        print "No such bucket."
    else:                                                                                                                         
        print bucket + " exists."

4.上传/下载一张图片，测试速度

def up_down_img():
    conn = boto.connect_s3()
    bucket = conn.create_bucket('mhs-%s' % int(time.time()))
    k = Key(bucket)
    k.key = 'mhs0323'
    
    img_path = 'IMG_0541.JPG'
    img_size = os.stat(img_path).st_size 
    print "img size: " + str(img_size)

    print "start uploading img..."
    start_up = int(time.time())
    k.set_contents_from_filename('IMG_0541.JPG')
    end_up = int(time.time())
    up_time = end_up - start_up
    print "upload time: "  + str(up_time)
    print "upload speed: " + str(img_size * 1.0 / (1024 * up_time))

    print "start downloading img..."
    start_down = int(time.time())
    k.get_contents_to_filename('s3_0541.jpeg')
    end_down = int(time.time())
    down_time = end_down - start_down
    print "download time: " + str(down_time)
    print "download speed: " + str(img_size * 1.0 / (1024 * down_time))
    
    k.delete()
    bucket.delete()

将Nginx环境从本地迁移到AWS错误以及解决方法

2015-05-04T00:00:00+00:00

下午将本地的Nginx反向代理到Tornado，以及调用FastCGI接口的整个环境迁移到AWS上面，出现了一些问题，下面将问题以及解决方法做一个备忘。

1.pcre make WARNING

Error: 安装 pcre WARNING导致报错 ‘aclocal-1.14’ is missing on your system
Solution: 通过touch *解决

2.pcre make错误

Error: make: *** No rule to make target `build', needed by `default'.  Stop.
Solution: 需要安装openssl以及libssl-dev

3.启动Nginx的错误

Error: nginx: [emerg] bind() to 0.0.0.0:80 failed (98: Address already in use)
Solution: 通过lsof -i :80查看80端口被占用的情况，可以发现aws上面虚拟机默认安装了apache，
并占用了80端口通过 sudo apt-get remove apache*完全卸载

4.AWS 公网IP问题

Error: 启动nginx后，将nginx配置文件中的server_name改成instance的ip（ifconfig获取），
在本地浏览器打开该ip，无法打开页面
Solution: 实际上ifconfig看到的不是公网ip，通过AWS的控制台中的`Running Instance`查看
Public IP可以查看到公网IP，在浏览器输入，即可打开nginx的欢迎页面。很奇怪，ping不通

5.AWS root权限问题

Error: 安装supervisord，将conf文件生成到/etc下时，一直没有权限，sudo也不行
Solution: 实际上，为了安全性考虑，ec2的root账户默认是关闭的，可以通过如下方式开启。
`sudo passwd root`设置root账户密码；
`sudo passwd --unlock root`启用root账户登录然后即可以通过`su root`进行切换

6.spawn-fcgi cmake 报错

Error: spawn-fcgi从本地scp到aws之后，cmake的时候，报错
Solution: CMakeCache的问题，没去理会，直接scp了一个干净的工程上去，解决

7.spawn-fcgi 绑定端口报错

Error: spawn-fcgi: child exited with: 127
Solution: 缺少libfcgi.so.0引起，但却没有提示缺少，运行时报错。
通过ln -s /usr/local/lib/libfcgi.so.0 /usr/lib/建立软链接即可

SSH登录AWS上的EC2以及SCP操作

2015-05-04T00:00:00+00:00

3月底的时候，当时有做一个基于aws的高性能Web Server项目的意向。就开始对aws S3以及EC2进行了一定的调研，并做了一些测试。后来项目后延，这个事情暂时搁置。5月中旬左右将会正式开展，想了一下，得把以前一些有用的东西重拾一下，稍微搭建一个小系统，尽量缩短正式开始时候的工期。

1.AWS相关服务

亚马逊的云服务，应该是目前提供的云服务最完备、接口最好用的地方。但是在国内，可能会涉及到被墙的问题，但是如果核心链路是国外到国内的下行链路，即这一条通道对在线率的要求高，而上行通道在线率可以有一定的妥协，在这一点上来看，问题倒不是太大。比较简单的一个场景，当上行链路被墙，下行链路通畅，数据仍然可以从aws上的Server打到client，可以通过client做一定的本地存储，将由于上行链路被墙产生的数据阻塞，在链路恢复时，同步到Server即可，在一定程度上规避被墙的问题。在这个问题上，不管链路暂时是否通畅，VPN应该都是必不可少的工具，行云是一个不错的选择。

主要需要使用的服务包括AWS的EC2，即弹性计算云服务，每一个实例为一个虚拟机，定制好自己的系统、配置之后，可以完全像操作本地的虚拟机一样去操作。对于EC2多存放的机房，可以自己选择，对于Client主要在国内的应用场景来说，东京或者新加坡，是比较好的选择，也可以通过VPN所设定的位置，进行相应的实例位置选择。

S3为AWS主要的存储服务，提供类似键值对的存储，S3的存储位置不能选择。而对于S3上数据的操作，可以通过AWS提供的SDK进行处理，对于使用Python作为主要的backend语言的业务场景来说，AWS提供了boto的SDK，而由于很多业务场景，需要在Server上面使用Tornado等框架，Github上不少人对此进行了整合，比如botocore、botornado是被提到比较多的两个repo。

2.EC2相关

需要说明的是，AWS提供了一年的免费试用，注册账号，绑定一张信用卡即可。虽然免费提供的EC2很弱，使用起来略卡，但人家免费，似乎并不能多要求什么。提供的操作系统包括Amazon Linux、Red Hat、SUSE Linux、Ubuntu、Windows。惯用Ubuntu，故选择的也是Ubuntu 14.04的64bit Server版本。AWS提供的免费版本配置如下，实际生产环境中，可以选择更好的配置：

EC2提供了AMI的接入机制，大概就是，尽量不使用root账号进行登录，提供了一定的权限管理手段，对于不同的用户，根据其具体权限、可接触的资源，提供不同的AMI证书，这点上来说，倒是跟本地的用户管理，是一个思路。需要注意的是，实例在使用的过程中，可以不宕机进行包括内存、存储等一系列的动态扩展，都可以通过AWS的Web操作界面进行。实例新建之后，可以下载登录需要的证书文件，为一个pem文件。这也是AWS跟一般的本地ssh操作不一样的地方，需要在参数中带上证书，才能进行登录验证，而不需要使用用户名、密码。

目前我使用的是AWS账户的证书进行访问，实际上，更好的做法是，使用AWS Identity and Access Management (IAM)创建IAM用户，再将该用户添加到具有管理权限的IAM组或授予此用户管理权限。

3.SSH登录以及SCP操作

之前直接食用AWS的账户证书进行EC2的访问，ssh以及scp脚本如下：

ssh -i mushsen.pem ubuntu@ec2-54-199-189-171.ap-northeast-1.compute.amazonaws.com

scp -i mushsen.pem -r "$1"  ubuntu@ec2-54-199-189-171.ap-northeast-1.compute.amazonaws.com:/home/ubuntu/

Ubuntu 14.04下进程管理工具supervisor安装

2015-05-01T00:00:00+00:00

supervisor的存在，主要是为了Nginx可以优雅的重启。作为一个进程管理工具，通过Supervisor启动其他进程，则其他进程都为其子进程。实现对特定的进程的守护（则其他进程不能设置为守护进程），在进程被挂起时，自动重启进程。

1.Supervisor安装

可以安装在任何Unix系统，Ubuntu下可以通过easy_install supervisor进行安装。然后切换到root权限，通过echo_supervisord_conf > /etc/supervisord.conf创建配置文件，可以在其中更改所需要的配置。修改配置，守护nginx进程，在/etc/supervisord.conf中添加以下信息：

[program:nginx]    
command=/usr/local/nginx/sbin/nginx    ;要执行的命令，即启动需要守护的进程
priority=1                             ;优先级
numprocs=1                             ;启动的进程数目
autostart=true                         ;supervisor启动的时候是否随着同时启动
autorestart=true                       ;当supervisor程序crash的时候，这个进程会自动重启（很重要）

2.Supervisor守护Nginx测试

指定配置文件，启动supervisord: sudo supervisord -c /etc/supervisord.conf，则根据配置文件的设置，nginx会被同时启动。
通过sudo supervisorctl可以进入supervidor的命令行工具（可以代替接下来提到的Web界面进行管理，控制守护程序的start/restart/stop），或者查看其守护的进程的状态。
查看守护进程状态: ps -le | grep supervisord

查看Nginx进程状态: ps -le | grep nginx

杀掉nginx进程: killall nginx

结果发现，nginx被重启，且pid被切换

3. 通过Web界面管理进程以及查看进程状态

通过配置文件的修改，supervisor通过web管理进程以及查看进程状态。如下所示：

[inet_http_server]         ; inet (TCP) server disabled by default
port=127.0.0.1:9001        ; (ip_address:port specifier, *:port for all iface)
username=admin             ; (default is no username (open server))
password=123               ; (default is no password (open server))

其中port的设置表示允许任何ip进行访问，也可以指定单个ip可以访问。保存配置之后，supervisorctl reload重启，通过配置文件中配置的127.0.0.1:9001，输入用户名密码，即可访问。

可以将tornado的python业务处理程序也加入supervisord的守护进程中（参考nginx的方法，修改配置文件），则该业务处理程序也随着supervisord儿而启动，直接通过localhost可以访问对应的helloworld程序。如下图可以发现，supervisord的守护进程队列，包含了nginx一级tornado的进程。

4. supervidor开机自启动

sudo supervisorctl stop <name>可以停止一个进程，但是该进程还会重新启动；
要停止supervisord，直接ps查找到其对应的pid，kill -9 pid即可，其中-9的意思是，传递给进程的信号量为9，即强制，尽快终止进程；因为supervisord是以守护进程形式启动，所以将其kill之后，nginx依然顺利运行；当将supervisord设置成非守护进程，将其kill后，则nginx也停止运行；
注意启动supervisord的时候一定要使用root权限，因为该进程的启动会带动nginx进程的启动，而nginx进程有监听80端口的操作，必须root权限，否则supervisord守护的进程将无法启动；
对于Ubuntu系统来说，参考http://blog.csdn.net/shanliangliuxing/article/details/15499891的方法，新建文件/etc/init.d/supervisord中，并将文章末尾的脚本复制进去，执行以下命令，即将supervisord设置成了开机自启动；

sudo chmod +x /etc/init.d/supervisord
sudo update-rc.d supervisord defaults
sudo service supervisord start

/etc/init.d/supervisord文件内容：

#! /bin/sh
### BEGIN INIT INFO
# Provides:          supervisord
# Required-Start:    $remote_fs
# Required-Stop:     $remote_fs
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Short-Description: Example initscript
# Description:       This file should be used to construct scripts to be
#                    placed in /etc/init.d.
### END INIT INFO
 
# Author: Dan MacKinlay <danielm@phm.gov.au>
# Based on instructions by Bertrand Mathieu
# http://zebert.blogspot.com/2009/05/installing-django-solr-varnish-and.html
 
# Do NOT "set -e"
 
# PATH should only include /usr/* if it runs after the mountnfs.sh script
PATH=/sbin:/usr/sbin:/bin:/usr/bin
DESC="Description of the service"
NAME=supervisord
DAEMON=/usr/local/bin/supervisord
DAEMON_ARGS=""
PIDFILE=/tmp/$NAME.pid
SCRIPTNAME=/etc/init.d/$NAME
 
# Exit if the package is not installed
[ -x "$DAEMON" ] || exit 0
 
# Read configuration variable file if it is present
[ -r /etc/default/$NAME ] && . /etc/default/$NAME
 
# Load the VERBOSE setting and other rcS variables
. /lib/init/vars.sh
 
# Define LSB log_* functions.
# Depend on lsb-base (>= 3.0-6) to ensure that this file is present.
. /lib/lsb/init-functions
 
#
# Function that starts the daemon/service
#
do_start()
{
	# Return
	#   0 if daemon has been started
	#   1 if daemon was already running
	#   2 if daemon could not be started
	start-stop-daemon --start --quiet --pidfile $PIDFILE --exec $DAEMON --test > /dev/null \
		|| return 1
	start-stop-daemon --start --quiet --pidfile $PIDFILE --exec $DAEMON -- \
		$DAEMON_ARGS \
		|| return 2
	# Add code here, if necessary, that waits for the process to be ready
	# to handle requests from services started subsequently which depend
	# on this one.  As a last resort, sleep for some time.
}
 
#
# Function that stops the daemon/service
#
do_stop()
{
	# Return
	#   0 if daemon has been stopped
	#   1 if daemon was already stopped
	#   2 if daemon could not be stopped
	#   other if a failure occurred
	start-stop-daemon --stop --quiet --retry=TERM/30/KILL/5 --pidfile $PIDFILE --name $NAME
	RETVAL="$?"
	[ "$RETVAL" = 2 ] && return 2
	# Wait for children to finish too if this is a daemon that forks
	# and if the daemon is only ever run from this initscript.
	# If the above conditions are not satisfied then add some other code
	# that waits for the process to drop all resources that could be
	# needed by services started subsequently.  A last resort is to
	# sleep for some time.
	start-stop-daemon --stop --quiet --oknodo --retry=0/30/KILL/5 --exec $DAEMON
	[ "$?" = 2 ] && return 2
	# Many daemons don't delete their pidfiles when they exit.
	rm -f $PIDFILE
	return "$RETVAL"
}
 
#
# Function that sends a SIGHUP to the daemon/service
#
do_reload() {
	#
	# If the daemon can reload its configuration without
	# restarting (for example, when it is sent a SIGHUP),
	# then implement that here.
	#
	start-stop-daemon --stop --signal 1 --quiet --pidfile $PIDFILE --name $NAME
	return 0
}
 
case "$1" in
  start)
	[ "$VERBOSE" != no ] && log_daemon_msg "Starting $DESC" "$NAME"
	do_start
	case "$?" in
		0|1) [ "$VERBOSE" != no ] && log_end_msg 0 ;;
		2) [ "$VERBOSE" != no ] && log_end_msg 1 ;;
	esac
	;;
  stop)
	[ "$VERBOSE" != no ] && log_daemon_msg "Stopping $DESC" "$NAME"
	do_stop
	case "$?" in
		0|1) [ "$VERBOSE" != no ] && log_end_msg 0 ;;
		2) [ "$VERBOSE" != no ] && log_end_msg 1 ;;
	esac
	;;
  #reload|force-reload)
	#
	# If do_reload() is not implemented then leave this commented out
	# and leave 'force-reload' as an alias for 'restart'.
	#
	#log_daemon_msg "Reloading $DESC" "$NAME"
	#do_reload
	#log_end_msg $?
	#;;
  restart|force-reload)
	#
	# If the "reload" option is implemented then remove the
	# 'force-reload' alias
	#
	log_daemon_msg "Restarting $DESC" "$NAME"
	do_stop
	case "$?" in
	  0|1)
		do_start
		case "$?" in
			0) log_end_msg 0 ;;
			1) log_end_msg 1 ;; # Old process is still running
			*) log_end_msg 1 ;; # Failed to start
		esac
		;;
	  *)
	  	# Failed to stop
		log_end_msg 1
		;;
	esac
	;;
  *)
	#echo "Usage: $SCRIPTNAME {start|stop|restart|reload|force-reload}" >&2
	echo "Usage: $SCRIPTNAME {start|stop|restart|force-reload}" >&2
	exit 3
	;;
esac

Shell中的各种查找

2015-05-01T00:00:00+00:00

关于Shell中的各种查找命令，find、locate、whereis、which，不可谓不多，做个总结，方便查阅。

1. find

当知道文件的大概文件名时，查找一个或者若干个想要的文件。

find -name filename: 在当前目录/子目录下查找filename
find / -name filename: 从root根路径开始，在所有子目录中查找filename，效率比较低，文件目录树的遍历
find -name file*: 在当前目录/子目录下查找文件名以file开头的文件
find -name ‘*’ -size +1000k: 查找任何大于1000k的文件
find / -type f -mmin -10: 在系统中查找过去十分钟内编辑过的文件
find PCIe_src/ -type f -name "*.c" | xargs grep "edma_common.vh": 在PCIe_src/目录下的c文件中，查找字符串edma_common.vh

2. locate

find -name的另一种写法，但是比后者快很多。其不搜索具体目录，而是搜索一个数据库/var/lib/locatedb，数据库含有本地所有文件的信息，Linux系统自动创建这个数据库，并且每天更新一次，所以locate查找不到最近变更的文件，可以在使用之前，通过updatedb去手动更新数据库。

locate "*.png": 列出系统中所有的png文件后缀的文件
locate ~/m: 列出主目录下所有以m开头的文件

3. whereis

只能用于程序名的搜索，而且只能搜索二进制文件（b文件）、man说明文件（参数-m）和源代码文件（参数-s）

4. which

which的作用是，在PATH变量指定的路径中，搜索某个系统命令的位置，并且返回第一个搜索结果；即使用which可以查看某个系统命令是否存在，以及执行的位置。

which supervisord返回 /usr/local/bin/supervisord

5. type

type区分某个命令到底是shell自带还是shell外部的独立二进制文件提供。

type supervisord返回 /usr/local/bin/supervisord
type cd返回cd is a shell builtin

Ubuntu14.04下搭建配置nginx与Tornado反向代理

2015-04-30T00:00:00+00:00

上一节已经在Ubuntu 14.04上部署了Nginx服务器，Nginx是一个高效的Web服务器及代理服务器，Tornado是一个基于epoll的异步非阻塞的Web开发框架，通常使用Nginx做为Web服务器时，都会以FastCGI模式，而我们从开发、调试、运维的角度考虑，使用了反向代理的模式，Tornado作为主要的业务服务器，同时Nginx可以通过FastCGI做一些特殊业务和负载均衡的处理。而supervisor是一个守护进程软件，可以把Linux上众多的守护进程集中在supervisor进行统一管理。

1 Tornado简介及部署

Tornado为facebook的一个开源项目，当初为了friendfeed而搭建，目前这个项目已经下线。和现有的主流Web服务器框架有着明显区别，是非阻塞的服务器，得力于其非阻塞的方式以及epoll的运用，Tornado每秒可以处理数以千计的连接。

首先在http://www.tornadoweb.org/en/stable/index.html下载最新版本的tornado，通过以下方式安装，

tar xvzf tornado-4.1.tar.gz
cd tornado-2.0
python setup.py build
sudo python setup.py install

为了使用Tornado的所有功能，需要安装PycURL以及simplejson，Ubuntu下可以通过 sudo apt-get install python-pycurl安装.

tornado安装目录下有一个demo目录，里面有一些应用的示例demo，包括一个类S3的基于本地文件的文件存储服务器。我们进入helloworld目录下，python helloworld.py运行，即可通过浏览器中localhost:8888进行访问（我们设定的监听端口为8888）。事实上，无论py文件放在哪里，将其运行后，都可以正常访问，这也是Tornado不同于Apache的地方，不必有一个固定的/var/www/目录存放代码。

2 Nginx与Tornado连接，配置反向代理环境

一般的情况下，不管是VPS还是其他的基于Linux的服务器，必须搭建一个Web Server监听80端口(http默认端口)，而Tornado服务进程监听在808*内部端口（可以启动多个进程）。由于Nginx是一个轻量、快速、安全的Server，一般选择Nginx作为反向代理，监听80端口并转发请求到后端的其他业务处理Server，比如Tornado。当将图片等一些静态资源缓存在前端的Nginx，可以节约内存以及CPU资源。

为什么Tornado需要Nginx做一层反向代理？大概是这样的。Tornado为单线程的Web服务器，一个Req如果阻塞了IO，进程挂起，无法接受新的Req；可以通过多进程在一定程度上改善IO被阻塞的情况，但是多进程本来就极其消耗资源。而一般会阻塞IO大文件，大多数都是静态文件，所以有了在前面挂一层Nginx来缓存静态文件的思路，原始初衷是为了避免Tornado产生IO阻塞。

实现Tornado的反向代理，主要通过Nginx的配置文件选项完成，下面针对配置了一个worker的Nginx反向代理，对相应的配置文件进行说明。关于/logs/nginx.pid文件，在Nginx实例启动时，会将相应进程的pid在该文件进行记录，所以reload重启时，直接读取该文件中的进程pid，进行重启。因此killall之后，没法重启。

基本配置代码如下，启动一个Tornado的应用，其监听8888端口，重启Nginx，监听80端口，则可以通过127.0.0.1访问Nginx，反向代理到后端的Tornado服务器。

worker_processes  1; # 开启的worker进程数目                                                                        

# 全局错误日志以及PID文件
error_log  logs/error.log;
pid        logs/nginx.pid;

events {
    worker_connections  1024;  #单个worker process进程允许的最大连接数目
    use epoll;  #多路复用IO的一种方式，可以大大提高Nginx性能
}

http {
    # Enumerate all the Tornado servers here 
    upstream helloworld {
        server 127.0.0.1:8888; #多个server的时候，即实现负载均衡，可以配置相应的权值。
    }

    server {
        listen 80;
 
        location ^~ /static/ {
            root /var/www;
            if ($query_string) {
                expires max;
            }
        }
        location = /favicon.ico {
            rewrite (.*) /static/favicon.ico;
        }
        location = /robots.txt {
            rewrite (.*) /static/robots.txt;
        }
 
        location / {
            proxy_pass_header Server;
            proxy_set_header Host $http_host;
            proxy_redirect off;  #关闭重定向
            proxy_set_header X-Real-IP $remote_addr;  #转发ip等http头信息
            proxy_set_header X-Scheme $scheme;
            # 配置反向代理到的后端server，可以使用http://127.0.0.1:8888
            proxy_pass http://helloworld;      #需要与前面匹配
        }
    }
}

Reorder List

2015-04-29T00:00:00+00:00

改变一个链表的顺序，从L0->L1->L2...->Ln变成L0->Ln->L1->Ln-1...,in-place并且不能改变节点的值。比较经典的链表相关题目。涉及到链表的切分、反转以及拼接。

//第一想法，将链表全部反转，得一个新链表，再将两个链表拼起来，取前一半。但不是in-place
//这个思路是对的，不能新增加节点，可以将链表拆成两个，将后者进行反转，再将两个链表拼接
//不能改变元素的值，限制了不能使用stack存储，只能纯链表操作

 
class Solution {
public:

    ListNode *splitList(ListNode *head) {
        ListNode *fast = head;
        ListNode *slow = head;
        ListNode *prev = head;
        
        while (fast != NULL && fast -> next != NULL) {
            prev = slow;
            fast = fast -> next -> next;
            slow = slow -> next;
        }
        prev -> next = NULL;
        return slow;
    }
    
    ListNode *reverse(ListNode *head) {
        if (head == NULL || head -> next == NULL)
            return head;
        
        ListNode *prev  = NULL;
        ListNode *pCur  = head;
        ListNode *pNext = NULL;
        
        while (pCur != NULL) {
            pNext = pCur -> next;
            pCur -> next = prev;
            prev = pCur;
            pCur = pNext;
        }
        return prev;
    }

    void reorderList(ListNode *head) {
        if (head == NULL || head -> next == NULL)
            return;
        
        ListNode *p1 = head;
        ListNode *p2 = splitList(head);
        p2 = reverse(p2);
        
        ListNode *next1 = p1;
        ListNode *next2 = p2;
        ListNode *prev  = p1;
        while (p1 != NULL && p2 != NULL) {
            next1 = p1 -> next;
            next2 = p2 -> next;
            p1 -> next = p2;
            p2 -> next = next1;
            prev = p2;
            p1 = next1;
            p2 = next2;
        }
        
        while (p2 != NULL) {
            prev -> next = p2;
            prev = prev -> next;
            p2 = p2 -> next;
        }
    }
};

Ubuntu14.04下安装Nginx

2015-04-28T00:00:00+00:00

aws上面开的Instance为Ubuntu 14.04，下面记录在ubuntu 14.04上搭建一个Nginx服务器，通过浏览器localhost可以访问的过程

1.1 PCRE依赖库安装

nginx rewrite依赖PCRE包，需要先编译安装PCRE库，一个perl语言的兼容正则表达式第三方库。可以通过ftp://ftp.csx.cam.ac.uk/pub/software/programming/pcre/下载pcre-8.35.tar.gz, 然后安装，pcre安装之后的动态库文件位于/usr/local/lib中。

./configure
make
sudo make install

1.2 Nginx源码安装

从http://nginx.org/download/下载nginx-1.8.0.tar.gz，然后通过make方式安装，若未安装pcre依赖库，会报错，可以通过先安装pcre库或者禁用rewrite功能解决，推荐前者。安装成功后，Nginx的目录为/usr/local/nginx.Nginx主要的配置文件为conf下的nginx.conf，启动文件为sbin下的nginx。

启动nginx并访问localhost验证安装成功，结果报错如下：./nginx: error while loading shared libraries: libpcre.so.1: cannot open shared object file: Error 40。通过ldd $(which /usr/local/nginx/sbin/nginx)查看该可执行文件依赖的库文件，可以发现，其他的动态库文件so都在lib下找到，而libpcre.so.1未找到，事实上该动态库在第一步安装了PCRE依赖库之后，存在于/usr/local/lib中，通过ln -s /usr/local/lib/libpcre.so.1 /lib建立软链接，即可正常启动Nginx

1.3 Nginx的启动、停止、重启

启动，直接./运行sbin/nginx即可
重启，sudo ./nginx -s reload
停止，通过ps -ef | grep nginx查询nginx的主进程号可以发现一共有两个进程，一个master，一个worker（由于配置文件中设置的process为1，因此一个worker）.通过sudo kill -QUIT pid即可停止Nginx.`当在nginx.conf中配置process的个数之后，相应的worker数目会增多，而master为1个不会有变化。
改变配置之后，通过./nginx -t测试一下配置是否有问题，没有问题再./nginx -s reload重启服务器。
将nginx.conf中server_name改成nginx部署机器所在ip，既可以实现外网访问

Ubuntu14.04下搭建配置nginx与FastCGI环境

2015-04-28T00:00:00+00:00

Nginx不支持外部程序的调用或者解析，包括php程序、python程序都不行，因此业务处理模块的调用，必须通过FastCGI接口来调用。FastCGI在Linux下是socket，为了调用CGI程序，还需要一个FastCGI的wrapper（启动另一个程序的程序），绑定在某个固定的socket。

1 Nginx与FastCGI调用

FastCGI程序(fast common gateway interface) - 常驻型CGI程序，它是语言无关的、可伸缩架构的CGI开放扩展，其主要行为是将CGI解释器进程保持在内存中并因此获得较高的性能。nginx不能直接执行外部的cgi程序，需要使用FastCGI进程管理程序，才能调用FastCGI程序，比如lighttpd中的spawn-fastcgi。

当Nginx将CGI请求发送给这个socket的时候，通过FastCGI接口，wrapper接收到请求，然后派生出一个新的线程，这个线程调用解释器或者外部程序处理脚本并读取返回数据；接着，wrapper再将返回的数据通过FastCGI接口，沿着固定的socket传递给Nginx；最后，Nginx将返回的数据发送给客户端。这就是Nginx+FastCGI的整个运作过程，如下图所示：

2. FastCGI环境部署与测试

2.1 spawn_fastcgi的安装、部署与配置

从https://github.com/lighttpd/spawn-fcgi下载spawn-fcgi的安装包；
解压后cmake . make make install进行安装；
将可执行文件spawn-fcgi移动到nginx/sbin中

2.2 fastcgi库的安装

下载http://www.fastcgi.com/dist/fcgi.tar.gz之后解压
./configure make sudo make install
在/usr/local/nginx下新建cgibin文件夹，cgi的可执行文件放在该目录下

2.3 FastCGI的一个demo

#include <fcgi_stdio.h>
#include <stdlib.h>
#include <unistd.h>                                                                                                                                                                     

int main() { 
    int count = 0;
    while (FCGI_Accept() >= 0) { 
        printf("Content-type: text/html\r\n"
                "\r\n"
                ""
                "FastCGI Hello!"
                "Request number %d running on host%s "
                "Process ID: %d\n", ++count, getenv("SERVER_NAME"), getpid());
    } 
    return 0;
}

通过g++ cgidemo.cc -o cgidemo -lfcgi进行编译；
将cgidemo移到上一步新建的cgibin目录下;
若提示缺少动态库libfcgi.so.0，建立一个软链接：ln -s /usr/local/lib/libfcgi.so.0 /usr/lib/，执行idconfig更新；

2.4 启动spawn-fcgi管理进程，绑定server，配置nginx转发请求

/usr/local/nginx/sbin/spawn-fcgi -a 127.0.0.1 -p 8088 -f /usr/local/nginx/cgibin/cgidemo启动spawn-fcgi进程，绑定server ip和端口（不要与nginx监听端口重合）；
查看一下8088端口是否已成功：netstat -na | grep 8088 * 更改nginx.conf配置文件，让nginx转发请求

在http节点的子节点-"server节"点中下添加配置
    location ~ \.cgi$ {
        fastcgi_pass 127.0.0.1:8088;
        fastcgi_index index.cgi;
        fastcgi_param SCRIPT_FILENAME fcgi$fastcgi_script_name;
        include fastcgi_params;
    }

sudo killall nginx 停止nginx的所有进程
sudo ./nginx重新启动，http://localhost/cgidemo.cgi即可访问刚才编写的cgidemo程序

基于数组与链表的归并排序算法实现

2015-04-27T00:00:00+00:00

这两天在写链表相关的题目，不少数组操作，将数据结构换成链表之后，都会比较难以处理，主要是单向链表，没有了反向的指针，其实数组，可以将其与双向链表对应上。早上在写一个链表归并排序的题目，一直runtime error，很是头疼。故将数组、链表的归并排序递归以及非递归实现，做一个整理。

我们都知道，归并排序是典型的时间复杂度为O(nlogn)的算法，而且算法时间复杂度很稳定，无论是平均复杂度还是最差时间复杂度，都是O(nlogn)，而虽然C++模版封装的很多排序算法都机遇快速排序，但是快速排序其实是不稳定的算法，一则元素的相对位置，在排序前后是不确定的（针对相同元素，划分元素随机选择的情况），而且元素基本有序的情况下，快速排序的时间复杂度会逼近O(n^2).

由于归并排序涉及循环的切分待排序数组，直到每组剩下一个/两个元素，因此递归实现是很直接的思路，但是涉及到logn层的递归，因此递归栈需要浪费O(logn)的stack空间，而非递归实现，就不存在这个问题，只需要浪费O(1)的空间。其中递归为自顶向下的方式，而非递归循环实现为自底向上的方式。

1. 数组的归并排序

1.1 基于数组的递归实现：

void mergeArray(int num[], int start, int mid, int end, int tmp[]) {
    int i = start, j = mid+1;
    int k = 0;
    while (i <= mid && j <= end) {
        tmp[k++] = (num[i] < num[j]) ? num[i++] : num[j++];
    }
    
    while (i <= mid) {
        tmp[k++] = num[i++];
    }
    
    while (j <= end) {
        tmp[k++] = num[j++];
    }
    for (int i = 0; i < k; ++i) {
        num[start+i] = tmp[i];
    }
}

void mergeSort(int num[], int start, int end, int tmp[]) {
    if (start < end) {
        int mid = (start + end) >> 1;
        mergeSort(num, start, mid, tmp);
        mergeSort(num, mid+1, end, tmp);
        mergeArray(num, start, mid, end, tmp);
    }
}

1.2 基于数组的非递归循环实现：

int merge2(int num[], int lo, int hi, int step, int tmp[], int start)
{
    int i = lo, j = hi;
    int k = 0;
    while (i < lo+step && j < hi+step) {
        tmp[start+(k++)] = (num[i] < num[j]) ? num[i++] : num[j++];
    }
    
    while (i < lo+step) {
        tmp[start+(k++)] = num[i++];
    }
    
    while (j < hi+step) {
        tmp[start+(k++)] = num[j++];
    }
    
    for (int i = 0; i < k; ++i) {
        num[start+i] = tmp[start+i];
    }
    return  start+k;
}

void mergeSort2(int num[], int n, int tmp[]) {
    int cur, lo, hi;
    for (int step = 1; step < n; step <<= 1) {
        int start = 0;   //  注意这里
        cur = 0;
        while (cur < n) {
            lo = cur;
            hi = cur + step;
            cur = hi + step;
            start = merge2(num, lo, hi, step, tmp, start);
        }
    }
}

2. 链表的归并排序

2.1 基于链表的递归实现：

//使用快速或者归并排序，主要问题是不能有反向指针。但是未必需要反向指针，归并排序的思想即先分割成
 //最小粒度，即一个或者两个一组，再逐渐增大粒度进行排序。
 
class Solution {
public:
    ListNode *merge(ListNode *h1, ListNode *h2) {
        if (h1 == NULL)
            return h2;
        if (h2 == NULL)
            return h1;
            
        if (h1 -> val < h2 -> val) {
            h1 -> next = merge(h1 -> next, h2);
            return h1;   
        }
        else { 
            h2 -> next = merge(h1, h2 -> next);
            return h2;
        }
    }

    ListNode* sortList(ListNode* head) {
        if (head == NULL || head -> next == NULL)
            return head;
            
        ListNode *p1  = head;
        ListNode *p2  = head;
        ListNode *pre = head;
        
        while (p2 != NULL && p2 -> next != NULL) {
            pre = p1;
            p1  = p1 -> next;
            p2  = p2 -> next -> next;
        }
        pre -> next = NULL;
        
        ListNode *h1 = sortList(head);
        ListNode *h2 = sortList(p1);
        
        return merge(h1, h2);
    }
};

2.2 基于链表的非递归循环实现：

class Solution {
public:
    ListNode *merge(ListNode *h1, ListNode *h2, ListNode *tail) {
        while (h1 && h2) {
            if (h1 -> val < h2 -> val) {
                tail -> next = h1;
                tail = tail -> next;
                h1 = h1 -> next;
            }
            else {
                tail -> next = h2;
                tail = tail -> next;
                h2 = h2 -> next;
            }
        }
        tail -> next = (h1 == NULL) ? h2 : h1;
        while (tail -> next != NULL)
            tail = tail -> next;
        return tail;
    }
    
    ListNode *split(ListNode *head, int step) {
        for (int i = 1; i < step && head; ++i) {
            head = head -> next;
        }
        if (head == NULL)
            return NULL;
            
        ListNode *p2 = head -> next;
        head -> next = NULL;
        return p2;
    }

    ListNode* sortList(ListNode* head) {
        if (head == NULL || head -> next == NULL)
            return head;
         
        int len = 0;
        ListNode *cur = head;
        while (cur) {
            len ++;
            cur = cur -> next;
        }
        
        ListNode *lo;
        ListNode *hi;
        ListNode *preHead = new ListNode(-1);
        preHead -> next = head;
        ListNode *tail = preHead;
        
        for (int step = 1; step < len; step <<= 1) {
            cur = preHead -> next;
            tail = preHead;
            while (cur) {
                lo   = cur;
                hi   = split(cur, step);  //返回的是第二段
                cur  = split(hi, step);    //此时将第二段从原链表上取下来
                tail = merge(lo, hi, tail);
            }    
        }
        return preHead -> next;
    }
};

Reverse Nodes in k-Group

2015-04-26T00:00:00+00:00

给一个链表，每次反转k个节点，如果节点数不是k的倍数，最后剩下的节点不需要反转，只能操作节点，不能改变节点的值，使用常数空间。

跟昨天做的Reverse Linked List II是一样的思路，即对于每k个节点，看成一组[m, n]，Reverse Linked List II只需要反转一组子链表，而这一题需要反转多组。

需要注意的是，coding的时候，链表的题目，经常出不小心导致runtime error，主要是以下几个原因：

对于指针为NULL了，未做判断，还往下求next
比如这一题中的n--, --n，有的时候不注意，直接拿k去自减，自减后无法归位，导致下面一个while循环并不执行。

class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        if (head == NULL || head -> next == NULL || k <= 1)
            return head;
            
        ListNode *preHead = new ListNode(-1);
        preHead -> next = head;
        
        ListNode *prev = preHead;
        ListNode *pCur = head;
        ListNode *p;
        
        int count = 0; 
        while (head != NULL) {
            head = head -> next;
            count ++;
        }
        
        int cycle = count / k;
        int n;
        for (int i = 0; i < cycle; ++i) {
            pCur = prev -> next;
            n = k;
            while (--n) {
                p = pCur -> next;
                pCur -> next = p -> next;
                p -> next = prev -> next;
                prev -> next = p;
            }
            
            //注意前面已经将k减到了0，此处不能使用k--
            n = k;
            while (n--)
                prev = prev -> next;
        }
        return preHead -> next;
    }
};

Reverse Linked List II

2015-04-25T00:00:00+00:00

即给定一个链表，以及两个位置m，n，将从第m个节点到第n个节点的链表进行反转。要求最好是只扫描一次链表，以及in-place去做。比如，对于1->2->3->4->5->NULL, m = 2 and n = 4，反转后返回1->4->3->2->5->NULL。

开始想到的方法是，使用一个栈，从m到n，将节点的值入栈，然后再扫一遍链表，从m到n，再将值依次出栈，更改节点元素值即可。如此，有两个不好的地方，首先，多开辟了存储空间，最坏情况下，需要浪费O(n)的存储空间；再者，需要遍历两次。

比较好的方法，应该是，使用prev节点定位m节点之前的位置，定位后不动，pCur节点定位m节点，p节点为m下一个节点；逐渐将p节点拆下来，插入prev和pCur之间即可。为了考虑m位于head节点的情况，在前面自己加一个0节点；需要拆的节点为n-m个。

1. 使用stack实现

class Solution {
public:
    ListNode* reverseBetween(ListNode* head, int m, int n) {
        if (head == NULL || (m < 0 && n < 0))
            return head;
        
        stack<int> st;
        
        ListNode *ptr = head;
        int count = 1;
        while (ptr != NULL) {
            if (count >= m && count <= n)
                st.push(ptr->val);
            else if (count > n)
                break;
            ptr = ptr -> next;
            count ++;
        }
        
        ptr = head;
        count = 1;
        while (ptr != NULL) {
            if (count >= m && count <= n && !st.empty()) {
                ptr -> val = st.top();
                st.pop();
            }
            else if (count > n)
                break;
            ptr = ptr -> next;
            count ++;
        }
        return head;
    }
};

1. 一个one-pass的解法

class Solution {
public:
    ListNode* reverseBetween(ListNode* head, int m, int n) {
        if (head == NULL || (m < 0 && n < 0))
            return head;
        
        ListNode *preHead = new ListNode(0);
        preHead -> next = head;
        n -= m;  //要拆下重组的节点数目

        ListNode *prev = preHead;
        while (--m)
            prev = prev -> next;   //可以加上对NULL的判断，保证m的合法
            
        ListNode *pCur = prev -> next;
        while (n--) {
            ListNode *p = pCur -> next;
            pCur -> next = p -> next;  //拆下p
            p -> next = prev -> next;
            prev -> next = p;  //插入p
        }
        return preHead -> next;
    }
};

Largest Rectangle in Histogram/Maximal Rectangle

2015-04-23T00:00:00+00:00

Leetcode中求面积的两个相对比较难的题目，其中Largest Rectangle in Histogram给定n个元素的数组，每个元素为柱子的高度，宽度均为1，计算柱子组成的矩形的最大面积；Maximal Rectangle给一个二维数组，元素为0/1，找出包含1的最大的方形区域。

对于第一道题，穷举的时间复杂度为O(n^2)，可以通过减枝满足AC的要求；也可以使用栈来优化算法，达到O(n)的时间复杂度。很多需要进行时间复杂度优化的问题都可以通过栈或者是哈希表加以解决；而对于后者，开始想到了纪录一个矩形块的左右边界的方法，但没有具体想明白，可以通过逐层对每个元素，纪录左右边界以及有效高度的方法，类似DP。

1. Largest Rectangle in Histogram

1.1 Solution1

依次以每个柱子为右边界，穷举左边界，更新最大值，为O(n^2)，可以通过减枝，降低复杂度，即对于每个height[k-1] <= height[k]以height[k]为右边界得到的结果肯定大，可以掠过，即只考虑height[k－1] > height[k]的k-1.

class Solution {
public:
    int largestRectangleArea(vector<int>& height) {
        int n = height.size();
        if (n == 0)
            return 0;
        if (n == 1)
            return height[0];
            
        int maxArea = height[n-1];
        for (int i = n-1; i >= 0; --i) {
            if (i != n-1 && height[i] <= height[i+1])
                continue;
            int area = height[i];
            int minH = height[i];
            for (int j = i; j >= 0; --j) {
                minH = min(minH, height[j]);
                area = max(area, minH*(i-j+1));
                maxArea = max(area, maxArea);
            }
        }
        return maxArea;
    }
};

1.2 Solution2

当序列递增时，入栈，直到遇到一个递减的元素，逐渐出栈，同时计算面积，直到遇到比当前元素小的栈内元素，将当前元素入栈。由于计算面积的条件是当前元素比栈顶元素小，那么涉及到一个问题，以最后一个元素为边界的面积怎么计算？可以在输入的height数组中添加一个0，确保最后一个元素可以弹出计算但是该方法，对于完全递减的数组，时间复杂度仍然为O(n^2);

class Solution {
public:
    int largestRectangleArea(vector<int>& height) {
        int ret = 0;
        height.push_back(0);
        
        stack<int> st;
        
        for (int i = 0; i < height.size(); ) {
            if (st.empty() || height[i] > height[st.top()]) {
                st.push(i++);
            }
            else {
                int tmp = st.top();
                st.pop();
                ret = max(ret, height[tmp] * (st.empty() ? i : i - (st.top()+1)));
            }
        }
        return ret;
    }
};

2. Maximal Rectangle

转化成dp问题，逐行扫描，纪录每个元素对应的最大矩形块的left、right边界以及height值，逐点更新macRect的值。

class Solution {
public:
    int maximalRectangle(vector<vector<char> > &matrix) {
        if (matrix.empty())
            return 0;
        const int m = matrix.size();
        const int n = matrix[0].size();
        
        int lo[n], hi[n], height[n];
        fill_n(lo, n, 0);
        fill_n(hi, n, n);
        fill_n(height, n, 0);
        
        int maxArea = 0;
        for (int i = 0; i < m; ++i) {
            int curLo = 0, curHi = n;
            for (int j = 0; j < n; ++j) {
                if (matrix[i][j] == '1')
                    height[j] ++;
                else
                    height[j] = 0;
            }
            for (int j = 0; j < n; ++j) {
                lo[j] = (matrix[i][j] == '1') ? max(lo[j], curLo) : 0;
                curLo = (matrix[i][j] == '1') ? curLo : j+1;
            }
            for (int j = n-1; j >= 0; --j) {
                hi[j] = (matrix[i][j] == '1') ? min(hi[j], curHi) : n;
                curHi = (matrix[i][j] == '1') ? curHi : j;
            }
            for (int j = 0; j < n; ++j) {
                if (matrix[i][j] == '1')
                    maxArea = max(maxArea, height[j]*(hi[j]-lo[j]));
            }
        }
        return maxArea;
    }
};

链表表示的大数加法

2015-04-23T00:00:00+00:00

来自企鹅的题目，大数加法，两个单向链表，未知长度，不能将链表翻转、不能使用数组，不能修改链表，需要O(n)的时间复杂度。

大数加法的变种，一般都以数组/链表的形式出现。主要是进位的处理。对这一题来说，比较麻烦的就是，数据的高位在链表头位置，而链表只能通过头指针进行遍历。不能使用一个stack，先遍历链表，将各个节点入栈，然后依次出栈并相加。不能使用数组，即限制了这种方法的使用。

题目的难点主要在于两个节点和为9时候的处理。我们知道，两个一位整数相加，考虑上一位的进位，向前的进位也只能是0或者1两种情况，考虑类似34567+65433的case，后面往前的进位，会影响每一位的结果。因此需要着重考虑的就是某一对应位的两个节点和为9的情况，很可能需要再做特殊处理。可以记录第一个为9的节点，当在后面发现有进位，则从该节点开始，再往后调整各位的情况，直到发生进位的节点。

1. ListNode结构体

struct ListNode {
	int val;
  	ListNode *next;
  	ListNode(int x): val(x), next(NULL) {}
};

2. 新建链表

ListNode *buildListNode(int vals[], int n) {
  	ListNode *head  = new ListNode(vals[0]);
  	ListNode *ptr   = head;
  	for (int i = 1; i < n; ++i) {
    	ListNode *node = new ListNode(vals[i]);
    	ptr -> next = node;
    	ptr = ptr -> next;
  	}
  	return head;
}

3. 链表表示的大数相加，head节点为高位

ListNode *BigNumberAdd(ListNode *head1, ListNode *head2) {
    if (head1 == NULL) return head2;
    if (head2 == NULL) return head1;
   
    int len1 = 0, len2 = 0;
    ListNode *lNum = head1, *sNum = head2;
    
    while (lNum != NULL) {
        len1 ++;
        lNum = lNum -> next;
    }
    while (sNum != NULL) {
        len2 ++;
        sNum = sNum -> next;
    }

    int delta = abs(len1 - len2);

    lNum = (len1 > len2) ? head1 : head2;
    sNum = (len1 > len2) ? head2 : head1;
    
    ListNode *head = new ListNode(lNum->val);
    ListNode *ptr  = head;
    lNum = lNum -> next;
    
    while (delta > 1) {
        ListNode *node = new ListNode(lNum->val);
        ptr -> next = node;
        ptr = ptr -> next;
        lNum = lNum -> next;
        delta --;
    }

	ListNode *ninePrev;
    ListNode *prev;
    bool flag = false;
    int locSum;                                                                                                                   
    int carry;
    
    while (lNum != NULL) {
        locSum = lNum->val + sNum->val;
        ListNode *sumNode = new ListNode(locSum);
        prev = ptr;
        ptr->next = sumNode;
        ptr = ptr->next;

        if (locSum == 9 && !flag) {
            ninePrev = prev;
            flag = true;
        }
        else if (locSum < 9) {
            flag = false;
            ninePrev = NULL;
        }
        else if (locSum > 9) {
            if (ninePrev != NULL) {
                ninePrev->val += 1;
                ninePrev = ninePrev->next;
                while (ninePrev != ptr) {
                     ninePrev->val = 0;
                     ninePrev = ninePrev->next;
                }
                ninePrev = NULL;
                flag = false;
            }
            else {
                carry = locSum / 10;
                prev->val += carry;
            }
            locSum = locSum % 10;
            ptr->val = locSum;
        }
        lNum = lNum->next;
        sNum = sNum->next;
    }
    return head;
}

Mac风扇狂转

2015-04-22T00:00:00+00:00

这两天温度上来，所里真是苦不堪言，本来就很闷的环境，没有空调，跟蒸笼一样。从苏州回来后，这两天Mac air的风扇狂转，还怀疑是在炎热的环境中罢工了，想想真不至于。昨晚在15楼，搞到晚上10点，就受制于风扇的嗡嗡声音，草草回宿舍，晚上在宿舍开着电脑更新软件，却并未见异响，诡异。

早上早早到所里，刷了几个算法题之后，风扇又开始转了，无奈只能Apple官网预约了一下，打电话找找技术支持，虽然吧，大多数情况下，并不能解决什么问题，但总归是靠谱的，按理说不应该存在硬件问题，Apple的品控，还是应该相信的，而且并不存在摔或者磕碰。

接连打了两次电话，浪费了快两个小时之后，以下所得。

在关机之后，option + command + shift + power 可以重置电源管理，这个操作需要按住15s，不会有任何反应，15s后松开，让系统自动启动即可。很多情况下，系统用久了之后，电源管理出现问题，可以将相关设置进行软复位。
在关机之后，option+command+p+r 清理系统缓存，平时经常不关机，Mac在关机操作时，有一些缓存仍然是没法清理的，应该定期手动清理一下，会听到系统开机时候Duang的响声，5声之后，松开，正常开机即可。
power键之后，shift 进入安全模式。开始进行了前两部之后，都没有效果。又另外打了个电话，怀疑是某个傻逼了的进程，在疯狂的给CPU发请求，导致CPU的负荷增大，自动调节风扇的声音。思来想去，可能会造成这个原因的，还就只可能是前段时间装了下迅雷，可能有一些守护进程，一直在后台run着，但又没查找，这种软件还是不能用。
power键之后，command+option+r可以按步骤进行系统重装，一定要保证wifi网络连接通畅。在进入安全模式之后，的确没有了风扇狂转的情况，由于安全模式下，基本上，任何非系统进程都没有打开，极其可能是某个软件导致的。想了下重装下系统，颇为麻烦与浪费时间，就想着要不费点劲把进程清理一下，要重装也得等一个稍微空一点的时间。
Mac开机启动程序存放的位置：/Library/LaunchDaemons/, /Library/LaunchAgents/, ~/Library/LaunchAgents/. Mac下的一些程序安装的时候，会生成一个或者多个plist文件，执行开机自启动。这些文件大多位于这些路径下，可以通过launchctl unload com.razer.rzupdater.plist取消相应项目的开机自启动。对于一些比较显式的应用，则可以通过System Preferences/User & Groups/Loin items进行相应的添加与删除。
另外，不管是实体店还是官网买的Mac，全球联保都是一样的，北京有4个维修点，离海淀比较近的在朝阳，实在不行，真是硬件有问题，只能找个时间，官网预约，过去检测一下了。 *
事实上，今天终于找到了问题，果然是软件问题，使用Mou打开大的文件时，不一会儿功夫，CPU占用率就达到了200%，而且页面的CSS渲染也做不完。应该就是CPU对CSS的渲染不堪重负，导致了负载过高。目前将在Mou上纪录的刷题纪录迁移到了一个比较不错的在线MarkDown编辑器上面。

Subsets I/II

2015-04-22T00:00:00+00:00

给定一个vector容器存放的整形数组，返回所有的子集，要求子集中的元素为非递减排列；其中I中的元素没有重复，II中可能存在重复元素。

开始看到题目，第一感觉就是dfs，但是似乎这一题，又不算标准的dfs。当数组中没有重复元素时，对于长度为n的数组，子集有2^n个，即对于每个元素，都可以选择加入或者不加入。则可以先将数组排序，再依次将每个元素加入已生成的子集中。

1. subset

在没有重复元素时，可以考虑，先将空数组加入结果集合ret，再将S数组中的元素依次加入ret中已有的子集中。为了保证每个子集内部元素的有序，先通过sort函数对传入的数组排序。

1.1 Solution1

class Solution { 
public:
    vector<vector<int> > subsets(vector<int> &S) {
        sort(S.begin(), S.end());
        vector<vector<int> > ret;
        vector<vector<int> > :: iterator it;
        vector<int> empty;
        ret.push_back(empty);
        
        for (int i = 0; i < S.size(); ++i) {
            //注意，内存循环不能使用ret，否则ret一直在增大，将会死循环
            vector<vector<int> > append = ret;
            for (it = append.begin(); it != append.end(); ++it) {
                it->push_back(S[i]);
                ret.push_back(*it);
            }
        }
        return ret;
    }
};

1.2 Solution2 递归DFS

关于dfs，关键的理解就是，在取得了若干个元素的基础上，先尽可能将能取的元素取进来，然后逐渐从后往前移除，每移除一个元素，则跳过该位置，从该位置之后的一个位置，再往后取，直到取尽。

class Solution { 
public:
    void helper(vector<int> &S, vector<vector<int> > &ret, vector<int> &tmp, int startIdx) {
        ret.push_back(tmp);
        
        for (int i = startIdx; i < S.size(); ++i) {
            tmp.push_back(S[i]);
            helper(S, ret, tmp, i+1);
            tmp.pop_back();
        }
    }

    vector<vector<int> > subsets(vector<int> &S) {
        sort(S.begin(), S.end());
        vector<vector<int> > ret;
        vector<int> tmp;
        helper(S, ret, tmp, 0);
        return ret;
    }
};

2. subset II

在数组中元素存在重复时，仍然按照没有重复元素时候的处理方法。有两个思路可以借鉴。

可以在排序后，将重复出现的元素串看成一个元素，对于其他元素，可以有加入/不加入两种选择，而对于这类特殊元素，可以有加入0个、1个，直到多个的选择;
当出现重复元素时，为了避免生成的结果集合有重复，能插入的，只是在上一次生成的子集。

2.1 Solution1

public:
    vector<vector<int> > subsetsWithDup(vector<int> &S) {
        sort(S.begin(), S.end());
        vector<vector<int> > ret;
        vector<int> empty;
        ret.push_back(empty);
        
        int count = 1;
        
        for (int i = 0; i < S.size();) {
            vector<vector<int> > append = ret;
            while (i+count < S.size() && S[i] == S[i+count]) {
                count ++;
            }
            
            for (int j = 0; j < append.size(); ++j) {
                for (int k = 0; k < count; ++k) {
                    append[j].push_back(S[i]);
                    ret.push_back(append[j]);
                }
            }
            i += count;
            count = 1;
        }
       return ret;
    }
};

2.2 Solution2

class Solution {
//可以通过记录上一次ret的size，与这一次的size，即可获取新加入的subset块，关键是在什么地方更新size值
public:
    vector<vector<int> > subsetsWithDup(vector<int> &S) {
        sort(S.begin(), S.end());
        vector<vector<int> > ret;
        vector<int> empty;
        ret.push_back(empty);
        
        int startIdx;
        int size = 0;
        for (int i = 0; i < S.size(); ++i) {
            vector<vector<int> > append = ret;
            startIdx = (i != 0 && S[i] == S[i-1]) ? size : 0;
            size = append.size();
            for (int j = startIdx; j < size; ++j) {
                append[j].push_back(S[i]);
                ret.push_back(append[j]);
            }
        }
        return ret;
    }
};

2.3 Solution3 递归DFS

稍微有点麻烦的是，比如对于[1, 2, 2]，[2, 2]子集的生成。在dfs生成子集合的过程中，大致思想是，当需要add的索引位置为重复元素，这是第一次出现，加入；当后面再出现，则跳过，即i>startIdx

class Solution {
public:
    void helper(vector<int> &S, vector<vector<int> > &ret, vector<int> &tmp, int startIdx) {
        ret.push_back(tmp);
        
        for (int i = startIdx; i < S.size(); ++i) {
            if (i > startIdx && S[i] == S[i-1]) 
                continue;
            tmp.push_back(S[i]);
            helper(S, ret, tmp, i+1);
            tmp.pop_back();
        }
    }

    vector<vector<int> > subsetsWithDup(vector<int> &S) {
        sort(S.begin(), S.end());
        vector<vector<int> > ret;
        vector<int> tmp;
        helper(S, ret, tmp, 0);
        
        return ret;
    }
};

Find Peak Element

2015-04-21T00:00:00+00:00

按照题意，peak number即在一个数组中，比前后元素都大的数字。对于nums[-1], nums[n]，都认为值为无穷小。题目要求的时间复杂度为O(logn)，毫无疑问需要使用二分查找，解题有一个小trick，即对mid元素做判断是否为peak number，若否，往那边跳的问题。

我们可以想象，当nums[mid] < nums[mid-1]时，即存在一个递减，只要前面存在一个递增，则找到一个peak number；当不存在，即一直递减，则因为nums[-1] 为负无穷，无论无何，我们都可以找到一个递增的位置，也就是可以找到一个peak number。而对于nums[mid] < nums[mid+1]时，一样的考虑。有一点需要注意的是，我们考虑数组为两个元素的情况，则mid为0，当需要往后跳转时，mid必须+1，否则会陷入死循环；

tips: 非递归解法while循环中，必须使用else if，不能直接if，因为可能存在多个peck number。否则会报错，很奇怪。

1. 递归解法

class Solution { 
public:
    bool checkValid(vector<int> &nums, int idx) {
        if (idx == 0)
            return nums[idx] > nums[idx+1];
        else if (idx == nums.size()-1)
            return nums[idx] > nums[nums.size()-2];
        else
            return (nums[idx] > nums[idx-1] && nums[idx] > nums[idx+1]);
    }

    int binarySearch(vector<int> &nums, int lo, int hi) {
        int mid = (lo+hi) >> 1;
        if (checkValid(nums, mid))
            return mid;
        else if (mid != 0 && nums[mid] < nums[mid-1])
            return binarySearch(nums, lo, mid-1);
        else if (mid != nums.size()-1 && nums[mid] < nums[mid+1])
            return binarySearch(nums, mid+1, hi);
    }
    
    int findPeakElement(vector<int>& nums) {
        int lo = 0, hi = nums.size()-1;
        if (hi <= 0)
            return 0;
            
        return binarySearch(nums, lo, hi);
    }
};

2. 非递归解法

class Solution {
public:
    bool checkValid(vector<int> &nums, int idx) {
        if (idx == 0)
            return nums[idx] > nums[idx+1];
        else if (idx == nums.size()-1)
            return nums[idx] > nums[nums.size()-2];
        else
            return (nums[idx] > nums[idx-1] && nums[idx] > nums[idx+1]);
    }
    
    int findPeakElement(vector<int>& nums) {
        int lo = 0, hi = nums.size()-1;
        if (hi <= 0)
            return 0;
        
        while (lo <= hi) {
            int mid = (lo+hi) >> 1;
            if (checkValid(nums, mid))
                return mid;
            
            else if (mid != 0 && nums[mid] < nums[mid-1])
                hi = mid - 1;
            else if (mid != nums.size()-1 && nums[mid] < nums[mid+1])
                lo = mid + 1;
        }
    }
};

Search in Rotated Sorted Array I/II

2015-04-20T00:00:00+00:00

给定一个有序数组，以某一个支点做旋转；给定一个target，找出该数组中是否存在该target.其中I数组没有重复元素，若存在，则返回元素索引，反之，返回-1。II数组中存在重复元素，存在返回True，否则返回False。

这一题O(n)的写法，几行代码就写出来了，但是显然题目是要考察二分查找，O(n)的解法没什么意义。二分查找，时间复杂度为O(logn)，其中第二题中，存在重复元素的情况下，主要可能存在A[lo] == A[mid]同时A[mid] == A[hi]的情况，这点是需要特别注意的地方，可以通过逐步收缩right/left的位置将这个影响因素排除。

1. Search in Rotated Sorted Array I

1.1 递归解法

class Solution {
public:
    int binarySearch(int A[], int target, int lo, int hi) {
        int mid = (hi+lo) >> 1;
        if (A[mid] == target)
            return mid;
        if (hi-lo <= 1 && A[hi] != target && A[lo] != target)
            return -1;
            
        else if (A[mid] < A[hi]) {
            if (A[mid] < target && A[hi] >= target)
                return binarySearch(A, target, mid+1, hi);
            else
                return binarySearch(A, target, lo, mid-1);
        }
        else {
            if (A[mid] > target && A[lo] <= target)
                return binarySearch(A, target, lo, mid-1);
            else
                return binarySearch(A, target, mid+1, hi);
        }
    }

    int search(int A[], int n, int target) {
        int lo = 0, hi = n-1;
        return binarySearch(A, target, lo, hi);
    }
};

1.2 非递归解法

class Solution {
public:
    int search(int A[], int n, int target) {
        int lo = 0, hi = n-1;
        while (lo < hi) {
            int mid = (hi+lo) >> 1;
            if (A[mid] == target)
                return mid;
            
            else if (A[mid] < A[hi]) {
                if (A[mid] < target && A[hi] >= target)
                    lo = mid+1;
                else
                    hi = mid-1;
            }
            else {
                if (A[mid] > target && A[lo] <= target)
                    hi = mid-1;
                else
                    lo = mid+1;
            }
            
        }
        return (A[lo] == target) ? lo : -1;
    }
};

1. Search in Rotated Sorted Array II

2.1 递归解法

class Solution {
//关键点就是，比较的时候，先选定mid与两端进行比较，在mid与hi相等时候，可以通过hi--排除掉重复元素.
public:
    bool binarySearch(int A[], int target, int lo, int hi) {
        int mid = (lo+hi) >> 1;
        if (A[mid] == target)
            return true;
        if (hi-lo <= 1 && A[hi] != target && A[lo] != target)
            return false;
            
        if (A[mid] < A[hi]) {
            if (A[mid] < target && target <= A[hi])
                return binarySearch(A, target, mid+1, hi);
            else
                return binarySearch(A, target, lo, mid-1);
        }
        else if (A[mid] > A[hi]) {
            if (A[mid] > target && A[lo] <= target)
                return binarySearch(A, target, lo, mid-1);
            else
                return binarySearch(A, target, mid+1, hi);
        }
        else
            return binarySearch(A, target, lo, hi-1);
    }

    bool search(int A[], int n, int target) {
        int lo = 0, hi = n-1;
        return binarySearch(A, target, lo, hi);
    }
};

2.2 非递归解法

class Solution {
//关键点就是，比较的时候，先选定mid与两端进行比较，在mid与hi相等时候，可以通过hi--排除掉重复元素.
public:
    bool search(int A[], int n, int target) {
        int lo = 0, hi = n-1;
        while (lo < hi) {
            int mid = (lo+hi) >> 1;
            if (A[mid] == target)
                return true;
            else if (A[mid] < A[hi]) {
                if (target > A[mid] && target <= A[hi])
                    lo = mid+1;
                else
                    hi = mid-1;
            }
            else if (A[mid] > A[hi]) {
                if (target < A[mid] && target >= A[lo])
                    hi = mid-1;
                else
                    lo = mid+1;
            }
            else
                hi --;
        }
        return A[lo] == target;
    }
};

Maximum Subarray

2015-04-20T00:00:00+00:00

给定一个数组，找出其中和最大的子串长度。比如对于[−2,1,−3,4,−1,2,1,−5,4]，和最大的连续子串为[4,−1,2,1]，即最大的和为6.

比较简单的一个题目，但是开始做的时候，没考虑好，陷入了一个死胡同，一直纠结设定一个cur指针，如何调整cur指针的位置。事实上，遍历一遍是肯定的，在遍历的过程中，纪录tSum的值，更新mSum的值。比较关键的一点就是，当前元素的值比tSum的值大时，直接tSum=nums[i]，相当于更新了cur指针的位置。

//时间、空间复杂度都是O(n)

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int mSum = INT_MIN, tSum = 0;
        for (int i = 0; i < nums.size(); ++i) {
            tSum += nums[i];
            if (nums[i] > tSum)
                tSum = nums[i];
            mSum = tSum > mSum ? tSum : mSum;
        }
        return mSum;
    }
};

Majority Element

2015-04-20T00:00:00+00:00

Leetcode中的题目，似乎之前刷的时候没有这道题，大意就是一个给定长度为n的数组，找出其中出现次数大于n/2的元素，数组非空且一定存在这样的元素。

看到题目，第一想法就是使用map，则遍历一遍数组，以元素为key，出现次数为value。如此，时间、空间复杂度都为O(n)。哈希表存在一个弊端，当数组增大时，会浪费很大的空间。先使用unordered_map给AC了，过程中发现Leetcode不支持hash_map，之前一直没留意map、unordered_map、hash_map的区别。事实上，STL中map/set都是基于红黑树实现，所以find的时间复杂度都为logn，而这一题遍历过程中，需要判断一个key是否存在，为了实现线性时间复杂度，find必须在O(1)内完成，因此使用map时，首选unordered_map，unordered_map的唯一弊端就是其元素存放是乱序的，对这一题，不存在影响。

印象中这一题，是利用n/2 这个特性，存在空间复杂度为O(1)的解法的。翻了一下Discuss，有一个很好的解法，先将major初始设置为num[0]，遍历一遍，当num[i]与major一致，则将count++，否则，count–，当count为0，则更新major的值。

1. 利用hash表实现

//时间、空间复杂度都是O(n)

class Solution {
public:
    int majorityElement(vector<int> &num) {
        int len = num.size();
        unordered_map<int, int> mp;
        
        int maj = num[0];
        for (int i = 0; i < len; ++i) {
            if (mp.find(num[i]) != mp.end()) {
                mp[num[i]] ++;
                if (mp[num[i]] > len/2)    //注意奇数的情况下，若写成>=，则会出错。
                    return num[i];
            }
            else
                mp[num[i]] = 1;
        }
        return maj;
    }
};

2. 一种空间复杂度为O(1)的解法

//一个时间复杂度O(n)，空间复杂度O(1)的方法

class Solution {
public:
    int majorityElement(vector<int> &num) {
        int count = 1;
        int major = num[0];
        for (int i = 1; i < num.size(); ++i) {
            if (num[i] == major)
                count ++;
            else
                count --;
            if (count == 0) {
                major = num[i];
                count = 1;
            }
        }
        return major;
    }
};

Find Minimum in Rotated Sorted Array I/II

2015-04-20T00:00:00+00:00

一个有序数组，以某一个点为轴，进行旋转，找出数组中最小的元素，其中I中数组没有重复元素，II中数组存在重复元素。

由于这是一个递增的数组，以数组中某一个点为轴进行旋转，则旋转的位置，会产生一个递减。因此最直观的方法，遍历一遍数组，找出递减的位置，即找到了最小值，时间复杂度为O(n)。而这一题很明显的，是典型的二分查找应用，O(n)的算法没什么意义。使用二分查找，可以达到O(logn)的时间复杂度，通过递归或者非递归实现。

1. Find Minimum in Rotated Sorted Array I

1.1 递归实现

//时间复杂度O(logn)，递归解法

class Solution {
public:
    int binarySearch(vector<int> &nums, int lo, int hi) {
        if (hi-lo <= 1)
            return (nums[lo] < nums[hi]) ? nums[lo] : nums[hi];
        
        int mid = (lo+hi) >> 1;
        if (nums[mid] < nums[hi])
            return binarySearch(nums, lo, mid);
        else if (nums[mid] > nums[hi])
            return binarySearch(nums, mid+1, hi);
    }

    int findMin(vector<int>& nums) {
        return binarySearch(nums, 0, nums.size()-1);
    }
};

1.2 非递归实现

//时间复杂度O(logn)，非递归解法

class Solution {
public:
    int findMin(vector<int>& nums) {
        int lo = 0, hi = nums.size()-1;
        while (lo < hi) {
            if (hi-lo <= 1)
                return (nums[lo] < nums[hi]) ? nums[lo] : nums[hi];
            
            int mid = (lo+hi) >> 1;
            if (nums[mid] < nums[hi])
                hi = mid;
            else if (nums[mid] > nums[hi])
                lo = mid+1;
        }
        return nums[lo];
    }
};

2. Find Minimum in Rotated Sorted Array II

2.1 递归实现

//时间复杂度O(logn)，递归解法

class Solution {
public:
    int binarySearch(vector<int> &nums, int lo, int hi) {
        //判断最小值的时刻，一定是将区间收缩到了1或者2个元素
        if (hi-lo <= 1)
            return (nums[lo] < nums[hi]) ? nums[lo] : nums[hi];
        
        int mid = (lo+hi) >> 1;
        if (nums[mid] > nums[hi])
            return binarySearch(nums, mid+1, hi);
        else if (nums[mid] < nums[hi])
            return binarySearch(nums, lo, mid);
        else
            return binarySearch(nums, lo, hi-1);
    }

    int findMin(vector<int>& nums) {
        return binarySearch(nums, 0, nums.size()-1);
    }
};

2.2 非递归实现

//时间复杂度O(logn)，非递归解法

class Solution {
public:
    int findMin(vector<int>& nums) {
        int lo = 0, hi = nums.size()-1;
        while (lo < hi) {
            if (hi-lo <= 1)
                return (nums[lo] < nums[hi]) ? nums[lo] : nums[hi];
            
            int mid = (lo+hi) >> 1;
            if (nums[mid] < nums[hi])
                hi = mid;
            else if (nums[mid] > nums[hi])
                lo = mid+1;
            else 
                hi --;
        }
        return nums[lo];
    }
};

STL中的map、unordered_map、hash_map

2015-04-20T00:00:00+00:00

在之前使用STL时，经常混淆的几个数据结构，特别是做Leetcode的题目时，对于使用哪一个map，一直没有太明确的概念，事实上，三个容器，有着比较大的区别.

1. map

内部数据的组织，基于红黑树实现，红黑树具有自动排序的功能，因此map内部所有的数据，在任何时候，都是有序的。

2. hash_map

基于哈希表，数据插入和查找的时间复杂度很低，几乎是常数时间，而代价是消耗比较多的内存。底层实现上，使用一个下标范围比较大的数组来存储元素，形成很多的桶，利用hash函数对key进行映射到不同区域进行保存。

插入操作：得到key -> 通过hash函数得到hash值 -> 得到桶号(hash值对桶数求模) -> 存放key和value在桶内
取值过程：得到key -> 通过hash函数得到hash值 -> 得到桶号(hash值对桶数求模) -> 比较桶内元素与key是否相等 -> 取出相等纪录的value
当每个桶内只有一个元素时，查找时只进行一次比较，当很多桶都没有值时，查询更快。
用户可以指定自己的hash函数与比较函数。

3. unordered_map

C++ 11标准中加入了unordered系列的容器。unordered_map记录元素的hash值，根据hash值判断元素是否相同。map相当于java中的TreeMap，unordered_map相当于HashMap。无论从查找、插入上来说，unordered_map的效率都优于hash_map，更优于map；而空间复杂度方面，hash_map最低，unordered_map次之，map最大。

对于STL里的map容器，count方法与find方法，都可以用来判断一个key是否出现，count统计的是key出现的次数，因此只能为0/1，而find基于迭代器实现，以mp.end()判断是否找到要求的key。

为什么要折腾nginx

2015-04-15T00:00:00+00:00

现在很多涉及到大规模、高并发访问的Server，基本都是使用nginx作为反向代理服务器，进行网络请求的接收、分发以及缓存。特地问了下百度在线广告的师兄，它们的backend server也是使用的nginx。随着这一两年做的东西逐渐增多，也逐渐找到自己的兴趣，并不是Data Mining抑或Machine Learning，而在于与App相关的一些backend Server的开发，即涉及一些网络优化以及高并发的处理。

下个月需要做一个Server相关的项目，而也一直有意华商韬略的Server进行优化而还没行动。计划接下来的时间，先在台式机搭一个nginx的反向代理Server环境，将华商韬略的数据库进行部署，将数据处理的Server由Apache换成Tornado，并在Server做一些数据的Cache，提高CRUD的效率。之后将环境分别迁移到aws以及阿里云。一来，为下面的项目做好准备，二来，继续翻新华商韬略的iOS客户端。涉及大规模方面的问题，有必要发信问问老罗。

1. 反向代理(Reverse Proxy):

使用代理服务器接受Internet的连接请求，将请求转发给内部网络的服务器，并将从内部服务器得到的结果返回给Internet上请求连接的客户端。因此对于Client看起来，反向代理服务器就是其能够看到的Server。使用反向代理的好处很多。

反向代理与正向代理的区别，主要相对于Client来说，如果Nginx就是其目的服务器，而不是Nginx隐藏的数据服务器，则Nginx是反向代理；如果对于Client来说，Nginx并不是目的服务器，只是作为一个转发请求的桥梁，而其为正向代理。对于正向代理服务器，Client需要进行相应的设置，即知道代理服务器的IP以及端口；而对于反向代理服务器，该服务器即是其目标服务器，不需要进行相应的设置。

反向代理服务器可以搭成集群，用户访问不同的资源服务器B时，让不同代理服务器Z(x)去应答不同用户，发送给不同用户不同的资源。因为不同的Z(x)可以做不同的Cache，而并不需要每次都像B发请求，特别是一些静态数据，如果这些反向代理服务器可以和用户x来自同一网络，则x对B的访问，就能得到高质量的速度，这也是CDN的核心技术。

隔绝了内部真正进行数据处理的服务器，任何来自Internet的请求都必须经过反向代理，保障了安全性；
可以在反向代理服务器上缓存真实Web服务器的某些静态资源，减轻真实Web服务器的负载压力，而将静态资源与动态资源分开存储的方式，也有利于数据的分批返回，优化前端的页面加载，不至于在等待数据库返回的时候，前端出现长时间的空白；
可以使用RP充当负载均衡服务器，分发请求，平衡集群中各个服务器的压力；
相比于Apache/IIS，Nginx的运行速度更快、系统资源消耗更低，，处理并发请求的能力也更强；

1.1 Nginx核心特点

跨平台，可以在大多数Unix like OS编译运行
配置简单
非阻塞、高并发连接：使用最新的epoll模型，数据复制时，磁盘I/O第一阶段非阻塞，能支撑5万左右的并发连接，实际生产环境中2~3万并发连接数
事件驱动：通信机制使用epoll模型，支持更大的并发连接
Master/Worker结构
处理大并发的请求内存消耗小，3万并发连接，开启10个Nginx进程，消耗150M内存作用
内置健康检查功能，后台Web服务器宕机不影响前端访问
支持GZIP压缩，可以添加浏览器本地缓存的Header头
稳定性高，这也是反向代理普遍的特点

1.2 异步非阻塞的良好机制

一个Web请求：建立连接 -> 接收数据 -> 发送数据，系统底层看来，都是数据的读写；
阻塞调用：读写事件没有准备好时，只能等待，即请求会被耽搁；
非阻塞：读写事件没有准备好，事件马上返回，请求定时检查事件是否准备好，即轮询。在时间间隔，可以进行其他的处理，但这样会带来很大的请求事件切换开销；
异步非阻塞：可以同时监控多个事件，阻塞调用，设置超时时间。对于epoll模型来说，事件没有准备好，放入epoll队列，事件准备好了，才去处理。epoll队列的存在，提供了处理高并发的能力。线程只有一个，能够同时处理的请求也只有一个，只是可以通过在请求间不断的切换，即循环处理多个准备好的事件，实现了并发；
Nginx异步非阻塞与多线程方式相比的优势，不需要创建线程，每个请求占用内存小，不存在上下文切换。事实上，上下文切换的时间代价，还是很大的。而对于IIS服务器来说，会为每个请求创建一个工作线程，线程带来的内存占用非常大，上下文切换的CPU开销很大，自然产生性能瓶颈。而Nginx的轻量级，也就体现在单线程基于epoll队列的异步非阻塞机制。

1.3 Nginx进程模型

一个master进程，生成一个或者多个worker进程，将原来串行的逻辑并行化，并将逻辑拆分成很多独立模块并行执行，Master组件主要进行逻辑拆分，将每个独立部分下发到多个Worker，同时维护Worker队列，Worker主要进行逻辑计算，并将结果返回Master

iOS中View的生命周期

2015-04-14T00:00:00+00:00

现在写应用时，习惯完全通过代码进行布局，不使用nib文件，则
initWithNibName/awakeFromNib/initWithCoder这一系列方法，都可以完全忽略。基本上需要关注的涉及视图生命周期的是下面这些函数：
loadView/viewDidLoad/viewDidUnload/ viewWillAppear/viewDidAppear/viewWillDisappear/viewDidDisappear
而一直对它们的执行顺序，能否覆写，了解得并不明确。

1. 各个函数的执行顺序及功能:

1.1 函数执行顺序

init -> viewDidLoad -> viewWillAppear -> viewDidAppear -> viewWillDisappear -> viewDidDisappear

1.2 函数功能

init－初始化程序
viewDidLoad－加载视图
viewWillAppear－UIViewController对象的视图即将加入窗口时调用
viewDidApper－UIViewController对象的视图已经加入到窗口时调用
viewWillDisappear－UIViewController对象的视图即将消失、被覆盖或是隐藏时调用
viewDidDisappear－UIViewController对象的视图已经消失、被覆盖或是隐藏时调用
viewVillUnload－当内存过低时，需要释放一些不需要使用的视图时，即将释放时调用
viewDidUnload－当内存过低，释放一些不需要的视图时调用。

2. 各函数使用注意事项

原来一直把View的创建、数据的初始化，都放在ViewDidLoad中，实际上，View的创建，应该放在loadView函数中，而数据初始化，放在ViewDidLoad中。

2.1 loadView

loadView在控制器的view为nil的时候被调用。此方法用于以编程的方式创建view的时候用到。
loadView是使用代码生成视图的时候，当视图第一次载入的时候调用的方法。loadView方法可能在运行应用程序的某个时刻，被内存管理控制器调用，如果设备内存不足的时候， view控制器会收到didReceiveMemoryWarning的消息。默认的实现是检查当前控制器的view是否在使用。如果它的view不在当前正在使用的viewhierarchy里面，且你的控制器实现了loadView方法，那么这个view将被release。

2.2 ViewDidLoad

不论是从xib中加载视图，还是从loadview生成视图，都会被调用。进行View的配置，以及一些数据的初始化，http请求等。
viewdidload是当程序第一次加载view时调用，以后都不会用到，而viewDidAppear是每当切换到view时就调用。
假设不使用xib文件对视图布局，那么loadView方法必须设置屏幕，并对任何子视图布局。每当继承一个具体的子类，例如UITableViewController或UITabBarController时，务必调用[super loadView]或者实现viewDidLoad。这样一来，在进行定制之前，父类可以对屏幕进行适当的设置。当代码基于具体的子类时，苹果的文档和示例代码鼓励使用viewDidLoad。

2.3 viewDidUnload

收到内存警告，同时该视图并不在当前界面显示时候会被调用，此时该controller的view已经被释放并赋值为nil。
接下来应该把实例变量的子视图、其他的实例变量、http请求释放掉。因为当该为空后会重复之前的流程直到把view创建，若不将自己额外添加的子视图、各种类实例变量释放，这里便会重新再次创建，导致内存泄露了。
由于controller通常保存着view以及相关object的引用，所以你必须使用这个函数来放弃这些对象的所有权以便内存回收。但不要释放那些难以重建的数据。

iOS中清理缓存的实现

2015-04-14T00:00:00+00:00

App开发中，经常涉及到清理Cache的功能，特别对于新闻展示类的App，为了提高页面加载速度，大量的数据，需要在本地缓存，当缓存没有一个比较规范的自动清理机制时，会造成程序占用空间越来越大的情况，实时给用户展示当前缓存数据的大小，让用户决定是否手动清理，是一个比较好的机制。最近也给华商韬略的iOS版本，加入了这一功能。

1. 新版华商韬略客户端设置页面:

2. iOS App中的目录结构及功能

2.1 iOS App目录结构

出于数据安全性的考虑，一个应用拥有自己独立的目录，用来写入应用的数据或者首选项参数。应用安装后，会有对应的home目录，home内的子目录功能如下：

AppName.app 存放应用程序自身
Documents/ 存放用户文档和应用数据文件
Library/ 应用程序规范的顶级目录，用于存放应用的文件，不宜存放用户数据文件，和Document一样会被itunes同步，但不包括Caches
/Library/Preferences/ 这里存放程序规范要求的首选项文件
Library/Cache/ 保存应用的持久化数据，用于应用升级或者应用关闭后的数据保存，不会被itunes同步，所以为了减少同步的时间，可以考虑将一些比较大的文件而又不需要备份的文件放到这个目录下
tmp/ 保持不需要持久化的应用数据，应用关闭户，数据被清除

可见，我们关于数据的操作来说，主要需要涉及的就是Documents/，以及Library/Cache/，之前一直对Cache目录的理解有点偏差，认为会被应用程序自动清理，其实不然。如果是在启动中需要使用的数据文件，可以放置在Library/Caches/下面，不建议放在Documents目录下，该目录下会备份，耗时。

2.2 获取应用的各个目录

//获取Cache路径
NSArray *paths = NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES);
NSString *path = [paths objectAtIndex:0];

//获取Documents路径
paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
path  = [paths objectAtIndex:0];

3. 清理Cache功能的实现

为了实现离线阅读，需要在本地Cache大量的数据文件，而这些数据文件一般放在Caches目录下，即通常所说的收藏的文章。而其他一些需要清理的Cache，也位于该大目录下面，则需要遍历Caches目录，同时忽略一些特定的文件夹，进行文件大小的统计，进而展现给用户当前Cache的大小。

3.1 遍历应用的某个目录并统计大小

- (float)checkTmpSize
{
    float totalSize = 0;
    NSString *path = [self getCachePath];
    NSDirectoryEnumerator *fileEnumerator = [[NSFileManager defaultManager] enumeratorAtPath: path];
    
    for (NSString *fileName in fileEnumerator) {
        NSString *filePath  = [path stringByAppendingPathComponent: fileName];
        NSDictionary *attrs = [[NSFileManager defaultManager] attributesOfItemAtPath: filePath error: nil];
        unsigned long long length = [attrs fileSize];
        
        if([[[fileName componentsSeparatedByString: @"/"] objectAtIndex: 0] isEqualToString: @"URLCACHE"])
            continue;
        
        totalSize += length / 1024.0 / 1024.0;
    }
    return  totalSize;
}

3.2 清理NSURLCache缓存的数据

开发中，一般基于NSURLCache来实现数据的Cache，NSURLCache会在Caches目录下，以Bundle Identifier为文件夹名建立Cache的存放路径。可以将该目录下的文件remove，实现清理Cache的功能。而如果使用了SDWebImageManager进行图片加载，也可以顺便使用其封装的清理memory/disk的方法，清理其缓存的数据。

- (void)clearCache
{
    SDWebImageManager *manager = [SDWebImageManager sharedManager];
    [manager.imageCache clearDisk];
    [manager.imageCache clearMemory];
    NSString *identifier = [[NSBundle mainBundle] bundleIdentifier];
    NSFileManager *fileManager = [NSFileManager defaultManager];
    NSString *base_path = [self getCachePath];
    NSString *path = [NSString stringWithFormat: @"%@/%@", base_path, identifier];
    [fileManager removeItemAtPath: path error: nil];
    
    tmpSize = [self checkTmpSize];
    [self.tableView reloadData];
}

iOS中通过UIView定义的导航栏实现滑动半透明效果

2015-04-13T00:00:00+00:00

iOS中，导航栏一般两种方式，或者使用系统自带的UINavagationBar，则导航栏会随着页面的push/pop有一个继承。或者不使用系统自带导航栏，自己定义一个UIView，绘制导航栏。最近在调整华商韬略的iOS客户端，在文章页面，想要实现导航栏的透明效果，而之前在人物列表页面，是实现了想要的透明效果的，即页面上滑到一定程度，设置透明效果，当下滑归位，去掉透明效果，如此相对容易，如下细说。而文章页面，整个是一个UIWebView，稍微麻烦一些。

系统自带导航栏是自带透明效果的，而UIView可以通过设定alpha参数调整透明度，但是透明度调整之后，一直不是想要的效果，即从导航栏需要能够看到底下UIWebView的文字。几经折腾，找到一个不算完美的方案。

1. 需要达到的导航栏效果

2. 整个页面是一个UITableView的情况

2.1 页面展示效果

2.2 透明效果解决方案

很多的新闻展示类的App，整个页面即为一个UITableView，而设置UIView的alpha，要达到需要的效果，UITableView需要与上面的导航栏banner有重叠，透明展示效果只在重叠处具有。因此UITableView需要从竖直偏移为y的地方进行布局，而这样显然不行，导航栏会挡住需要展示的内容。有几个方案，解决这个问题。

由于页面需要下拉刷新功能，因此可以将refreshHeaderView，加在UITableView的header上面；
不需要下拉刷新功能时，可以自定义一个header，附着在banner的下方；

//Init refresh header view
_refreshHeaderView = [[EGORefreshTableHeaderView alloc] initWithFrame:CGRectMake(0.0f, REFRESHHEIGHT, TSCREENW, REFRESHHEIGHT)];
_refreshHeaderView.delegate = self;
self.personTable.tableHeaderView = _refreshHeaderView;

2.3 UITableView滑动到一定程度时，实现透明效果

UITableView继承自UIScrollView，可以实现UIScrollViewDelegate中的两个方法，实现在这个控件在拖拽上滑的过程以及下滑归位之后需要实现的操作。

- (void)scrollViewWillBeginDragging:(UIScrollView *)scrollView
- (void)scrollViewDidEndDecelerating:(UIScrollView *)scrollView

- (void)scrollViewWillBeginDragging:(UIScrollView *)scrollView{
    if (self.personTable.contentOffset.y > 5) {
        //[self.listViewDelegate setBannerAlpha: YES];
        //self.bannerisAlpha = YES;
        [self.banner setAlpha: 0.5f];
    }
}

- (void)scrollViewDidEndDecelerating:(UIScrollView *)scrollView{
    if (self.personTable.contentOffset.y < 5) {
        //[self.listViewDelegate setBannerAlpha: NO];
        //self.bannerisAlpha = NO;
        [self.banner setAlpha: 0.5f];
    }
}

3. 整个页面是一个UIWebView的情况

在之前的一个版本中，实现的是，在列表页面，上滑时，导航栏半透明，而文章详细页面，上滑时，直接将导航栏往上推，实现整个页面有效显示的最大化，参照知乎日报是类似的实现。现在想把导航栏固定，实现半透明效果。

3.1 通过setFrame简单实现

整个页面，除了banner以及bottomView，整个是一个UIWebView，这个控件没有header的说法，而要实现透明效果，需要UIWebView与banner有一个重合。试了好几种方案，比如在页面上再扔一个UITableView/UIScrollView，再在上面布局，不起效果。只能暂时先实现一种比较丑陋的做法。在页面上滑倒需要实现banner透明的时候，将UIWebView的frame上移到与banner重合，上滑时看不出变化，但是下滑时，滑到最底部，需要将UIWebView的frame恢复，就有了一个比较突兀的下拉，考虑setFrame操作使用动画，解决这个问题。

- (void)scrollViewWillBeginDragging:(UIScrollView *)scrollView{
    if (self.articleDetailWebView.scrollView.contentOffset.y > 5) {
        [self.articleDetailWebView setFrame: CGRectMake(0, STATUS_BAR_HEIGHT, TSCREENW, TSCREENH-STATUS_BAR_HEIGHT)];
        [self.banner setAlpha: 0.5f];
    }
}

- (void)scrollViewDidEndDecelerating:(UIScrollView *)scrollView{
    if (self.articleDetailWebView.scrollView.contentOffset.y < 5) {
        [self.articleDetailWebView setFrame: CGRectMake(0, NAVIHEIGHT, TSCREENW, TSCREENH-NAVIHEIGHT)];
        [self.banner setAlpha: 0.9f];
    }
}

3.2 通过加入一点动画效果，使下拉最后的操作更平滑

直接通过setFrame改变UIWebView的位置时，最后归位时会有一点显得突兀，加入一点动画效果自动移动时，感觉稍微平滑了很多。

- (void)scrollViewWillBeginDragging:(UIScrollView *)scrollView{
    if (self.articleDetailWebView.scrollView.contentOffset.y > 5 && !isMoveUp) {
        [self moveUp: self.articleDetailWebView andAnimationDuration: 0.2f andLength: NAVIHEIGHT-STATUS_BAR_HEIGHT];
        isMoveUp   = YES;
        isMoveDown = NO;
        [self.banner setAlpha: BANNER_TRANS];
    }
}

- (void)scrollViewDidEndDecelerating:(UIScrollView *)scrollView{
    if (self.articleDetailWebView.scrollView.contentOffset.y < 5 && !isMoveDown) {
        [self moveDown: self.articleDetailWebView andAnimationDuration: 0.2f andLength: NAVIHEIGHT-STATUS_BAR_HEIGHT];
        isMoveDown = YES;
        isMoveUp   = NO;
        [self.banner setAlpha: BANNER_NORMAL];
    }
    //为防止UIWebView在原始位置时，进行下滑操作，产生错误的偏移，初始化时应该将isMoveUp设置为NO，
    //isMoveDown设置为YES，即限定了必须先有上移操作，才能下移。
}

通过self.articleDetailWebView.scrollView.bounces = NO;关闭滑动到顶部/底部的回弹效果，显得很自然。

3.3 Github的一个简单动画类库

https://github.com/kevincobain2000/UIViewAnimations-Demo这哥们写了个简单的动画展示的demo，实现十几种视图动画效果（UIView Animations），包括旋转、弹跳、淡入淡出、放大缩小、左右移动、上下移动等，可以用在所有页面控件中。不难，也留作备忘。

4. 通过scrollViewDidScroll监听的方法实现

还可以在下滑操作到UIScrollView的contentOffset.y一定程度时，通过setFrame去改变。即在用户快速下滑的时候，将整个UIWebView往下移动，在不易察觉的情况下回复位置。亲测这样的方法，也比较和谐。

- (void)scrollViewDidScroll:( UIScrollView *)scrollView
{
    if (self.articleDetailWebView.scrollView.contentOffset.y < 100 && !isMoveDown) {
        [self.articleDetailWebView setFrame: CGRectMake(0, NAVIHEIGHT, TSCREENW, TSCREENH)];
        isMoveDown = YES;
        isMoveUp   = NO;
        [self.banner setAlpha: BANNER_NORMAL];
    }
}

iOS中获取UIWebView中加载页面的元素

2015-04-13T00:00:00+00:00

iOS中，一般使用UIWebView加载来自后台的文章页面，而在涉及分享功能时，经常需要从加载的页面中获取图片或者通用的说，某一个javascript element的值，即涉及到iOS与javascript的交互，项目中用到了几个方法，记录。

1. 获取打开页面的URL

NSString *url = [_articleDetailWebView stringByEvaluatingJavaScriptFromString: 
@"document.location.href”];

2. 以id获取标签下的元素

NSString *shareTitle = [_articleDetailWebView stringByEvaluatingJavaScriptFromString:@"document.getElementById('url_read_article').innerText"];

获取到

<div class="url_read_article" id="url_read_article" style="display:none">
http: mrt.hsmrt.com/server/show_iphone.php?id=433
</div>

中的

http: mrt.hsmrt.com/server/show_iphone.php?id=433

3. 获取某一个tag下的src等属性

NSString *topImg = [_articleDetailWebView stringByEvaluatingJavaScriptFromString: @"document.getElementsByTagName('img')[0].src"];

获取到

`<img class="top_img" src="http://mrt.hsmrt.com/app/pics/433/index_sma_img.jpeg">`

中img标签中的src属性的值，即

http://mrt.hsmrt.com/app/pics/433/index_sma_img.jpeg；

由于getElementsByTagName返回的是一个元素列表，故需要根据具体的html页面布局取相应的值，或者通过getElementById/getElementByClass进行一些限定。

Scramble String

2015-04-09T00:00:00+00:00

据说是以前gg的一道面试题，字符串有很多二叉表示法，我们选择一个非叶子节点，将其左右孩子互换，即做了一次Scramble。判断两个字串是否符合。这个操作的重点是找了一个非叶子节点，将左右互换，即有一个点的分割，再互换。将字符串进行二叉表示，即有一个递归分解的过程，可以使用递归。

两个字符串相同的必备条件是含有相同的字符集，简单做法是排序后，判断是否相同，可以有效剪枝，大大减少递归次数。但是递归的时间复杂度为多项式级别。一般对于递归，都可以使用记忆化搜索的方法转化为非递归的实现。本题，DP是比较好的办法。

字符串长度为1时，两个字符必须完全相同；
字符串长度为2时，s1=”ab”, s2=”ab”或者”ba”才行；
任意长度字符串时，将s1分解成a1，b1，s2分解成a2，b2，必须((a1~b1)&&(a2~b2))或者((a1~b2)&&(a2~b1))
DP可以大大减少重复计算，使用一个三维数组，纪录dp[i][j][k]为s1[i, i+k-1]与s2[j, j+k-1]是否符合条件。

1. 递归做法，仅仅理清思路

bool isScramble(string s1, string s2)
{   
    if (s1.size() != s2.size())
        return false;
    
    if (s1.size() == 1)
        return s1 == s2;
    
    string st1 = s1, st2 = s2;
    sort(st1.begin(), st1.end());
    sort(st2.begin(), st2.end());
        
    int len = s1.size();
    for (int i = 0; i < len; ++i) {
        if (st1[i] != st2[i])
            return false;
    }   
          
    bool ret = false;                                                                                                             
    for (int i = 1; i < len && !ret; ++i) {
        string s11 = s1.substr(0, i);
        string s12 = s1.substr(i, len-i);
        string s21 = s2.substr(0, i);
        string s22 = s2.substr(i, len-1);

        ret = isScramble(s11, s21) && isScramble(s12, s22);
        
        if (!ret) {
            s21 = s2.substr(len-i, i);
            s22 = s2.substr(0, len-i);
            ret = isScramble(s11, s21) && isScramble(s12, s22);
        }
    }
    return ret;
}

2. DP解法

class Solution {
public:
    bool isScramble(string s1, string s2) {
        if (s1.size() != s2.size())
            return false;

        int len = s1.size();
            
        bool dp[len][len][len];
        memset(dp, false, sizeof(bool)*len*len*len);
        
        for (int k = 1; k <= len; ++k) {   
        	 //k==len的情况没注意
            for (int i = 0; i <= len-k; ++i) {   
            	//两层循环的结束条件没注意，由于是从i, j开始往后数k个，所以必须减去k
                for (int j = 0; j <= len-k; ++j) {
                    if (k == 1) {
                        dp[i][j][k] = (s1[i] == s2[j]);
                    }
                    else {
                        for (int l = 1; l < k; ++l) {
                            if ((dp[i][j][l] && dp[i+l][j+l][k-l]) || 
                            (dp[i][j+k-l][l] && dp[i+l][j][k-l])) {
                                dp[i][j][k] = true;
                                break;
                            }
                        }    
                    }
                }
            }
        }
        return dp[0][0][len];
    }    
};

青蛙跳台阶问题

2015-04-08T00:00:00+00:00

一只青蛙一次可以跳上 1 级台阶，也可以跳上2 级。求该青蛙跳上一个n 级的台阶总共有多少种跳法。
一只青蛙一次可以跳上1级台阶，也可以跳上2 级……它也可以跳上n 级，此时该青蛙跳上一个n级的台阶总共有多少种跳法？

1. 常规跳台阶

第一个问题，是一个dp问题，即第n级台阶，可以且仅可以由第n-1或者第n-2级台阶到达。则可以写出状态转移方程:

n = 1, dp[n] = 1
n = 2, dp[n] = 2
n >= 3, dp[n] = dp[n-1] + dp[n-2]

实际上，规律类似于婓波那契数列，如果补充一个dp[0] = 1的话，为一个标准的奜波那契数列；可以使用递归做法；dp相当于是递归的改进版本，即存储了中间结果，避免了重复的运算。

非递归解法

class Solution {
public:
  int jumpFloor(int number) {
    int dp[number+1];
        memset(dp, 0, sizeof(int)*(number+1));
        dp[1] = 1;
        dp[2] = 2;
        for (int i = 3; i <= number; ++i) {
            dp[i] = dp[i-1] + dp[i-2];
        }
        return dp[number];
  }
};

递归解法

class Solution {
public:
	int jumpFloor(int number) {
        if (number == 1)
            return 1;
        else if (number == 2)
            return 2;
        else
            return jumpFloor(number-1) + jumpFloor(number-2);
		
	}
};

2. 变态跳台阶

复现跳的过程，找数学规律

n = 1时，Fib(1) = 1
n = 2时，Fib(2) = Fib(1) + Fib(0) = 2
n = 3时，Fib(3) = Fib(0) + Fib(1) + Fib(2) = 4
Fib(n) = Fib(n-1)+Fib(n-2)+Fib(n-3)+…+Fib(n-n) = Fib(0)+Fib(1)+Fib(2)+…+Fib(n-1)
Fib(n-1) = Fib(0)+Fib(1)+Fib(2)+…+Fib(n-2)
两式相减得 Fib(n)-Fib(n-1) ＝ Fib(n-1)

class Solution {
public:
  int jumpFloorII(int number) {
    int dp[number+1];
        memset(dp, 0, sizeof(number+1));
        dp[1] = 1;
        dp[2] = 2;
         
        for (int i = 3; i <= number; ++i) {
            dp[i] = 2 * dp[i-1];
        }
        return dp[number];
  }
};

C字符串相关库函数的实现

2015-04-08T00:00:00+00:00

笔试面试中经常出现让实现基础的字符数组操作相关的函数，这些函数的实现，简单，却很多陷阱，考察思维的严谨以及基础知识的扎实。越来越感受到，很多编程的小细节，能够很好地反应一个程序员的水平以及修养。甚至是从代码风格，小到一个空格是否需要，括号的组织，好吧，我是强迫症。

1. strlen函数

求一个char数组存储的字符串的长度，对于char *str[] ="abc";来说，长度为4，最后会加上一个’\0’，但是strlen会忽略’\0’的存在，即到该字符结束，以此，可以实现strlen；

当函数参数有指针时，记得进行有效性的检查。
assert断言的使用，需要引入头文件.

int strlen(const char *str)
{
	assert(str != NULL);
	int len = 0;
	while ( *(str++) != '\0') {
		len ++;
	}
	return len;
}

2. strcmp函数

比较两个C语言字符串的大小，；

当函数参数有指针时，记得进行有效性的检查。
assert断言的使用，需要引入头文件.

int strcmp(const char *dst, const char *src)
{
	assert(NULL != dst && NULL != src);
	while ( *dst && *src && ( *dst == *src)) {
		dst ++;
		src ++;
	}
	return *dst - *src;
}

3. strcat函数

连接两个字符串，对于dst串，利用’\0’找到末尾，再将src拼接上来即可；

char *strcat(char *dst, const char *src)
{
	assert(dst != NULL && src != NULL);
	char *addr = dst;
	while ( *adr != '\0') {
		addr ++;
	}
	while (( *addr++ = *src++) != '\0');
	return dst;
}

4. strcat函数

连接两个字符串，对于dst串，利用’\0’找到末尾，再将src拼接上来即可；

char *strcat(char *dst, const char *src)
{
	assert(dst != NULL && src != NULL);
	char *addr = dst;
	while ( *adr != '\0') {
		addr ++;
	}
	while (( *addr++ = *src++) != '\0');
	return dst;
}

5. strcpy函数

字符串全拷贝；

char *strcpy(char *dst, const char *src)
{
	assert(dst != NULL && src != NULL);
	char *addr = dst;
	while (( *dst++ = *src++) != '\0');
	return addr;
}

6. strncpy函数

字符串拷贝，可以指定拷贝的长度；

char *strncpy(char *dst, const char *src, int n)
{
	assert(dst != NULL && src != NULL);
	char *addr = dst;
	while (n-- > 0 && *src != '\0')
		*dst ++ = *src ++;
	return addr;
}

7. memcpy函数

内存拷贝，需要考虑内存有重叠的情况，据此决定从前往后复制或者从后往前复制；

void *memcpy(void *dst, const void *src, unsigned int count)
{
	assert(dst != NULL && src != NULL);
	void *addr = dst;
	if (dst < src || (char *)dst >= (char *)src+count) {
		while (count --) {
			*(char *)dst = *(char *)src;
			dst = (char *)dst+1;
			src = (char *)src+1;
		}
	}
	else {
		dst = (char *)dst + count - 1;
		src = (char *)src + count - 1;
		while (count --) {
			*(char *)dst = *(char *)src;
			dst = (char *)dst - 1;
			src = (char *)src - 1;
		}
	}
	return addr;
}

iOS中本地持久化存储

2015-04-06T00:00:00+00:00

App中有一些数据需要在本地持久化存储，主要是涉及一些App个人私有的配置信息，比如当前版本号、需要离线浏览的文章、当前选择的是白天/夜间浏览模式、登陆数据等。而为了最大化页面加载，也有不少信息需要在本地就行存储。iOS中本地存储主要是三种方式，数据库(SQLite)、NSUserDefaults、plist文件。原来开发中，一直喜欢自己新建plist文件进行存储，使用key-value的格式，类似自己建xml格式的文档。如此好处仅仅是开发的时候可视化比较好，但是这样需要显示创建、读取文件，很麻烦。而NSUserDefaults才则不需要考虑这些东西，像读取字符串一样直接读取、存储，自动进行key-value存储，并将数据进行序列化，读取方便、占用空间小，相当于一个小型的key-value数据库。

1. [NSUserDefaults standardUserDefaults]

用来记录需要永久存储的数据，不需要读写文件，而是保留到NSDictionary字典里，由系统保存到文件里。系统会自动将字典进行序列化，即二进制格式保存到该应用下的/Library/Preferences下的一个plist文件中。如果程序意外退出，数据不会被系统写入该文件，即数据的同步，系统有一个同步的时间点。为了确保数据写入，可以在每次设置需要写入的数据时，使用[[NSUserDefaults standardUserDefaults] synchronize］命令直接同步到文件里，来避免数据的丢失。

1.1 iOS中获取应用的Documents路径：

[[[NSFileManager defaultManager] URLsForDirectory:NSDocumentDirectory inDomains:NSUserDomainMask] lastObject]

1.2 NSUserDefaults判断key是否存在：

NSUserDefaults *userDefaults = [NSUserDefaults standardUserDefaults];
if ([userDefaults objectForKey: @"msg"] == nil) {
}

1.3 NSUserDefaults数据存储：

NSUserDefaults *userDefaults = [NSUserDefaults standardUserDefaults];
[userDefaults setInteger: myInteger forKey: @"myInteger"];  
[userDefaults setFloat:   myFloat   forKey: @"myFloat"];  
[userDefaults setDouble:  myDouble  forKey: @"myDouble"];  
      
[userDefaults setObject:  myString     forKey: @"myString"];  
[userDefaults setObject:  myDate       forKey: @"myDate"];  
[userDefaults setObject:  myArray      forKey: @"myArray"];  
[userDefaults setObject:  myDictionary forKey: @"myDictionary"];  

[[NSUserDefaults sharedUserDefaults] synchronize]; //直接将数据写入

1.4 NSUserDefaults数据读取:

NSUserDefaults *userDefaults = [NSUserDefaults standardUserDefaults];
NSInteger myInteger = [userDefaultes integerForKey: @"myInteger"]; 
float myFloat       = [userDefaultes floatForKey:   @"myFloat"];  
double myDouble     = [userDefaultes doubleForKey:  @"myDouble"];  
NSString *myString  = [userDefaultes stringForKey:  @"myString"];  
NSDate *myDate      = [userDefaultes valueForKey:   @"myDate"]; 
NSArray *myArray    = [userDefaultes arrayForKey:   @"myArray"];  
NSDictionary *myDictionary = [userDefaultes dictionaryForKey:@"myDictionary"];

1.5 列出NSUserDefaults中的全部数据:

NSDictionary* defaults = [[NSUserDefaults standardUserDefaults] dictionaryRepresentation];

iOS工程中添加pch文件

2015-04-05T00:00:00+00:00

最近在改版华商名人堂的iOS客户端，顺便把之前iOS开发中涉及到的一些东西整理一下。

将整个共工程都广泛使用的头文件包含在该文件下，编译器会自动将头文件添加到所有源文件，使用相应类时不需要import;可以把UIKit/UIKit.h, Foundation/Foundation.h等框架头文件, 以及包含NSLog开关的头文件放在该文件中。

1. pch文件的添加

iOS -> other -> PCH file创建pch文件；
修改配置文件，build setting -> Apple LLVM 6.0 - Language -> Precompile Prefix Header，对于debug和release，添加PCH file路径; 即Prefix Header 下Debug、Release中，添加“$(SRCROOT)/项目名称/pch文件名”，例如$(SRCROOT)/LotteryFile/Lottery-Prefix.pch

2. 使用自定义NSLog文件

可以自定义CLog文件，在任何源文件中使用CLog宏输出日志，预处理命令会自动判断当前的编译配置，如果是Debug，则输出，否则，不输出；

设置编译的是Debug还是Release版本：Run按钮右侧，点击工程名，Manage Schemes，Edit…，info页；
设置DEBUG开关是否为1: Build Settings -> Apple LLVM 6.0 - Preprocessing -> Preprocessing Marcos下设置；默认为1；
自定义的CLog文件如下：

# ifdef DEBUG
# define CLog(format, …) NSLog(format, ##__VA_ARGS__)
# else
# define CLog(format, ...)
# endif

Mac/Linux下rm实现回收站功能

2015-04-05T00:00:00+00:00

Unix下的rm命令为彻底删除，特别加上-rf选项后，很容易由于手抖造成无法挽回的错误。上几天写代码时，写了一早上，临吃饭时，想把.pyc给删了，手抖把.py给删了。虽然可以通过lost+found想办法找回，但相当费劲。为防患于未然，还是想办法把rm命令alias成移到回收站的功能。在github上找到一个朋友写的脚本，不错。

具体使用可以参照README.md即可。 https://github.com/LaiJingli/rmtrash

Python Multiprocessing多进程操作

2015-04-05T00:00:00+00:00

最近在写Python代码，程序主要就是涉及大文件的IO以及处理。当时在Mac上跑，自己即使的手动释放一下内存，还勉强可以跑，Mac的Swap比较大，虚拟内存用到16个G左右。而再移到台式机上面跑，8G的内存，不久就MemoryError了，怀疑是当时装系统时候设置的Swap太小的缘故。单进程/线程都不堪重负，更别说使用多进程来加速了。想到了邱大神在服务器上面开的100G内存的虚拟机，很久不用了，遂把代码扔上去，顺便稍微把代码用简单的多进程操作简单加了加速。

1. 并行处理同一个任务

python的一个标准库，提供了Pool对象，通过进程池对象来管理和创建多个进程的worker，并收集这些worker返回的结果。使用Process类创建多个进程对象，并用start方法启动该进程；而join操作，可以阻塞进程，即该进程执行返回之后，再往下执行。

from multiprocessing import Process

class MultiProcess(object):
	target = []
	args   = []
	
	def __init__(self, tar, arg):
		self.target = tar
		self.args   = arg

	def multi_processing(sekf):
		jobs = []
		process_num = len(self.target)
		for i in xrange(process_num):
			p = multiprocessing.Process(target = self.target[i], args = self.args[i])
			jobs.append(p)
			p.start()

在程序中，主要涉及到，对某一个大文件，读入内存后，需要反复的遍历矩阵，而多次的遍历操作之间并没有数据依赖，可以据此，将多个任务分配到不同CPU上，并行操作，大大降低了无谓的时间消耗。

2. 共同完成同一个任务

为了更快的速度对一个大文件进行处理，可以多进程分块读取、处理一个文件。这时候，需要涉及到锁的使用，即保证每一个操作，都是原子操作。

import urlparse
import datetime
import os
from multiprocessing import Process, Queue, Array, RLock

WORKERS = 4
BLOCKSIZE = 0
FILE_SIZE = 0
FILE_NAME = '../data/tianchi_mobile_recommend_train_user.csv'
 
def getFilesize(file):
    """
        获取要读取文件的大小
    """
    global FILE_SIZE
    fstream = open(file, 'r')
    fstream.seek(0, os.SEEK_END)
    FILE_SIZE = fstream.tell()                                                                                                    
    fstream.close()

def process_found(pid, array, file, rlock):
    global FILE_SIZE
    global JOB
    global PREFIX
    """
        进程处理
        Args:
            pid  : 进程编号
            array: 进程间共享队列，用于标记各进程所读的文件块结束位置
            file : 所读文件名称
        各个进程先从array中获取当前最大的值为起始位置startpossition
        结束的位置endpossition (startpossition+BLOCKSIZE) if (startpossition+BLOCKSIZE)<FILE_SIZE else FILE_SIZE
        if startpossition==FILE_SIZE则进程结束
        if startpossition==0则从0开始读取
        if startpossition!=0为防止行被block截断的情况，先读一行不处理，从下一行开始正式处理
        if 当前位置 <= endpossition 就readline
        否则越过边界，就从新查找array中的最大值
    """
    fstream = open(file, 'r')
     
	while True:
        rlock.acquire()
        print 'pid%s' % pid, ','.join([str(v) for v in array])
        startpossition = max(array)            
        endpossition = array[pid] = (startpossition+BLOCKSIZE) if (startpossition+BLOCKSIZE)<FILE_SIZE else FILE_SIZE
        rlock.release()
         
        if startpossition == FILE_SIZE:  #end of the file
            print 'pid%s end' %(pid)
            break
        elif startpossition != 0:
            fstream.seek(startpossition)
            fstream.readline()
        pos = ss = fstream.tell()
        ostream = open('../proc_data/tmp_pid' + str(pid) + '_jobs' + str(endpossition), 'w')
        while pos < endpossition:
            #处理line
            line = fstream.readline()                        
            ostream.write(line)
            pos = fstream.tell()
 
        print 'pid: %s, startposition: %s, endposition: %s, pos: %s' %(pid, ss, pos, pos)
        ostream.flush()
        ostream.close()
        ee = fstream.tell()        
 
    fstream.close()

def main():
    global FILE_SIZE
    print datetime.datetime.now().strftime("%Y/%d/%m %H:%M:%S") 
     
    file = FILE_NAME
    getFilesize(file)
    print FILE_SIZE
     
    rlock = RLock()
    array = Array('l', WORKERS, lock=rlock)
    threads = []
    for i in range(WORKERS):
        p = Process(target = process_found, args = [i, array, file, rlock])
        threads.append(p)
 
    for i in range(WORKERS):
        threads[i].start()
     
    for i in range(WORKERS):
        threads[i].join()
 
    print datetime.datetime.now().strftime("%Y/%d/%m %H:%M:%S") 
 
if __name__ == '__main__':
    main()

网上博客的代码，回头改成多进程分块读取一个文件，处理，再写入一块大内存的实现。由于是多进程分块处理，最好是不让多个进程竞争IO资源，则可以将每一块对应放到内存的一块地方，将这些内存块收集了，再输出文件。牺牲一些时间的情况下，尽可能减少进程切换带来的各种问题。

Git冲突以及pull时需要输入账户密码的解决办法

2015-04-01T00:00:00+00:00

多人维护一份代码时，经常会出现，两边同时更改一个文件，产生冲突问题，而本地的更改，又暂时不能commit，导致git pull的时候报error，大部分时候，我们需要暂存本地的修改，先stash，返回自己上一个commit，将最新代码git pull到本地，之后再stash pop，继续原来的工作。

1. git stash

git stash：保存未提交的更改，stash为一个栈
git stash list：列出本地git中stash的所有更改
git stash pop：将上一次stash的更改恢复

2. git pull/push避免输入账户密码

将部分工作环境移到台式机之后，出各种傻逼问题，比如vim的配置不同导致python的tab/空格问题，git需要输入密码的问题，还是一开始工作环境没有整体配置好导致。

设置记住密码（默认15分钟）：git config --global credential.helper cache
设置一个小时之后失效：git config credential.helper 'cache --timeout=3600'
长期存储密码：git config --global credential.helper store

Python中list的删除与清空

2015-03-31T00:00:00+00:00

今天在写阿里的代码，涉及到大量的数据load进内存处理的操作，由于Python的list/dict都是使用自动引用计数的机制进行内存释放；而操作中经常需要将文件读入一个list，处理后扔到另一个list，再转存。当不手动释放list占据的内存时，内存泄漏严重。

1. list的删除与清空

1.1 list的删除

class Test(object):
	li = [1, 2, 3, 4]
	def func(self):
		del li

if __name__ == '__main__':
	t = Test()
	t.func()

如上代码，会报错，AttributeError: 'Test' object attribute 'li' is read-only.由于del li是完全删除这一个list，在成员函数中没办法直接删除一个类的成员变量。

1.2 list的清空

class Test(object):
	li = [1, 2, 3, 4]
	def func(self):
		self.li[:] = []

if __name__ == '__main__':
	t = Test()
	t.func()

正确的清除一个list的方法，即list对象在内存中仍然存在，只是将里面的元素清空。

2. 当list作为参数传递

class Test(object):
	li = [1, 2, 3, 4]
	def func(self, tmp):
		tmp[:] = []

if __name__ == '__main__':
	t = Test()
	t.func(t.li)

如此，也能正确的清空成员变量li，可见，python函数参数传递为引用传递的方式。实际上，python的函数参数传递机制，相当于传值和传引用的一种综合。如果函数收到的是一个可变对象（比如字典或者列表）的引用，就能修改对象的原始值——相当于通过“传引用”来传递对象。如果函数收到的是一个不可变对象（比如数字、字符或者元组）的引用，就不能直接修改原始对象——相当于通过“传值’来传递对象。

C++类的大小，sizeof(class)

2015-03-30T00:00:00+00:00

面试题中经常遇到，定义一个类，或为空，或定义了几个内置类型的变量，或包含构造、析构函数、成员函数，问在32位/64位平台上，sizeof(class)的字节数。比较关键的几个考虑：

32位系统是4字节对齐，64位系统为8字节对齐；
空类，为了分配内存，字节数为1；
成员函数的字节数；
若包含虚函数，系统需要分配一个指向虚函数的指针vptr，32位系统，大小为4Byte

以下讨论，都是使用g++编译的情况，当使用gcc编译时，关于内存对齐，主要是两个原则：

结构体的大小等于结构体内最大成员大小的整数倍
结构体内的成员的首地址相对于结构体首地址的偏移量是其类型大小的整数倍，比如说double型成员相对于结构体的首地址的地址偏移量应该是8的倍数
为了满足规则1和2编译器会在结构体成员之后进行字节填充
以上规则仅限于windows

class A
{
	int a;
	short b;
	int c;
	char d;
};
//使用`gcc`编译时，按照以上规则，a占4个字节，b本应占2个字节，
//但由于c占4个字节，为了满足条件2，b多占用2个字节，为了满足条件1，
//d占用4个字节，一共16个字节。

class B
{
	double a;
	short b;
	int c;
	char d;
}
//在windows下，无论使用gcc、g++，结果都是24；而Linux/Mac下，任何编译器，都是20;
//使用`gcc`编译时，a占8个字节，b占2个字节，但由于c占4个字节，
//为了满足条件2，b多占用2个字节，即abc共占用8+4+4=16个字节,
//为了满足条件1，d将占用8个字节，一共24个字节。

1. 空类的大小

class A
{
};
//sizeof(A)为1

类的实例化，即在内存中分配一块地址，空类也会被实例化，因此编译器会为其隐含地添加一个Byte，空类实例化之后才能拥有独一无二的地址。

2. 一般非空类大小

class A
{
	int a;
	char *p;
};

在32位平台，sizeof(A)为8，int为4Byte，char指针亦为4Byte；若在class A里面再加一个char q，按照4字节对齐，即char q会占据4Byte，sizeof(A)为12；需要注意32位平台，sizeof(long)为4Byte，sizeof(long long)为8Byte；sizeof(void)为1，但是会报warning.

而对于64位平台，地址对齐跟编译器相关，比如对于class A里面添加一个long long c;则sizeof(A)值为24;所以对齐方式，编译器占据决定性的作用；

2.1 64位系统地址对齐的问题

存在编译器的编译优化问题，对于一个class，实例化以后，其分配的地址空间应该是连续的，对于8字节对齐的变量，比如double，char*，则按8字节对齐，对于int、char等，则按4字节对齐。

class A
{
public:
	A(void);
	virtual ~A(void);
private:
	char a;
	char b;
	double p;
	char *p;
};
//在32位平台，sizeof(A)为20，即4+4+8+4；而在64位系统，sizeof(A)为32；即
//8+4+8+8，凑够8的倍数，为32；

class A
{
public:
	A(void);
	virtual ~A(void);
private:
	char a;
	double p;
	char b;
	char *p;
};
//在32位平台，sizeof(A)为24，即4+4+8+4+4；而在64位系统，sizeof(A)为40；即8+8+8+8+8；

3. 有虚函数的类

class A
{
public:
	A(void);
	virtual ~A(void);
private:
	int a;
	char *p
};

在32位平台，sizeof(A)为12，有虚函数的时候，该类型会生成一个虚函数表，并在该类型的每一个实例中添加一个指向需函数表的指针，在32位系统分配的指针大小为4Byte.

4. 有虚函数类的继承

class B : public A
{
public:
	B(void);
	virtual ~B(void);
private:
	int b;
};

在32位平台，sizeof(B)为16，即子类的大小为基类成员变量大小加上子类的大小。对于普通继承，子类和基类共享虚函数指针。

5. 虚继承

class A
{
	int a;
}

class B : public virtual A
{
	int b;
	virtual void foo(){};
};

虚继承时，派生类会生成一个指向虚基类表的指针，如果还有虚函数，不增加额外指针大小空间。在32位平台上，类B大小为12Byte，由于virtual的存在，额外增加一个4Byte的指针大小。

C++中的多态与覆盖

2015-03-30T00:00:00+00:00

C++中的多态与覆盖一直是容易混淆的概念，多态即一个接口，多种方法，程序在执行时才决定调用的函数，OOP的核心概念，通过虚函数来实现，虚函数允许子类重新定义成员函数：而子类重新定义父类的做法称为覆盖；只有重写了虚函数才算多态；而重载则是允许有多个同名的函数，而这些函数的参数列表不同，允许参数个数不同，参数类型不同，或者两者都不同。编译器会根据这些函数的不同列表，将同名的函数的名称做修饰，从而生成一些不同名称的预处理函数，来实现同名函数调用时的重载问题。但这并没有体现多态性。

多态的目的即实现接口重用，不论传递过来的究竟是那个类的对象，函数都能够通过同一个接口调用到适应各自对象的实现方法。最常见的用法就是声明基类的指针，利用该指针指向任意一个子类对象，调用相应的虚函数，可以根据指向的子类的不同而实现不同的方法。如果没有使用虚函数的话，即没有利用C++多态性，则利用基类指针调用相应的函数的时候，将总被限制在基类函数本身，而无法调用到子类中被重写过的函数。因为没有多态性，函数调用的地址将是一定的，而固定的地址将始终调用到同一个函数，这就无法实现一个接口，多种方法的目的。

1. 一个面试题

#include<iostream>
using namespace std;

class A
{
public:
	void foo()
	{
		printf("1\n");
	}
	virtual void fun()
	{
		printf("2\n");
	}
};
class B : public A
{
public:
	void foo()
	{
		printf("3\n");
	}
	void fun()
	{
		printf("4\n");
	}
};
int main(void)
{
	A a;
	B b;
	A *p = &a;
	p->foo();
	p->fun();
	p = &b;
	p->foo();
	p->fun();
	return 0;
}

第一个p->foo()和p->fuu()，本身是基类指针，指向的又是基类对象，调用的都是基类本身的函数，输出结果就是1、2。
第二个输出结果就是1、4。p->foo()和p->fuu()是基类指针指向子类对象，正式体现多态的用法，p->foo()由于指针是个基类指针，指向是一个固定偏移量的函数，此时指向的就只能是基类的foo()函数的代码，因此输出的结果还是1。而p->fun()指针是基类指针，指向的fun是一个虚函数，由于每个虚函数都有一个虚函数列表，此时p调用fun()并不是直接调用函数，而是通过虚函数列表找到相应的函数的地址，根据指向的对象不同，函数地址也将不同，这里将找到对应的子类的fun()函数的地址，输出的结果会是子类的结果4。

2. 隐藏规则

隐藏即指派生类的函数屏蔽了与其同名的基类函数：

如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual 关键字，基类的函数将被隐藏（注意别与重载混淆）.
如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual 关键字。此时，基类的函数被隐藏.

3. 纯虚函数

纯虚函数是在基类中声明的虚函数，它在基类中没有定义，但要求任何派生类都要定义自己的实现方法。在基类中实现纯虚函数的方法是在函数原型后加“=0”： virtual void funtion()=0

引入原因：在很多情况下，基类本身生成对象是不合情理的，因此引入虚函数概念，则编译器要求在派生类中必须予以重写以实现多态性。同时含有纯虚拟函数的类称为抽象类，它不能生成对象。

多态性：编译时多态性 - 重载函数实现；运行时多态性 - 虚函数实现。

C++中的静态成员

2015-03-30T00:00:00+00:00

昨天舍友介绍了一个准备IT面试的网站，牛客网，一个面向程序员的“猿题库”，做了两套C++的选择题，得分不是太理想，基本只能拿到60%的分数。是得根据做过的题目，慢慢整理知识点。

1. 静态成员

静态成员的定义或声明需要加static修饰符，可以通过双冒号即<类名>::<静态成员名>使用
属于整个类的而不是某个对象，只存储一份供所有对象共用。使用静态成员变量实现多个对象之间的数据共享不会破坏隐藏的原则，保证了安全性还可以节省内存

2. 静态成员函数与非静态成员函数

2.1 不能通过类名调用类的非静态成员函数

class A
{
public:
	void init() {}
	static print() {}
};

void main()
{
	A::init();		//编译会出错
	A::print();
}

2.2 可以通过类的对象调用类的静态与非静态成员函数

void main()
{
	A a;
	a.init();		//编译会出错
	a.print();
}

2.3 类的非静态成员函数可以调用静态成员函数

class A
{
public:
	void init() {
		print();
	}
	static print() {
		cout << m << endl;
	}
private:
	int m;
};

void main()
{
	A a;
	a.print();
}

3. 静态成员变量

3.1 静态成员函数中不能使用类的非静态成员变量

class A
{
public:
	void init() {}
	static print() {
		cout << m << endl;
	}
private:
	int m;
};

void main()
{
	A a;
	a.print();
}
//会编译出错，静态成员函数属于整个类，类实例化对象之前就已经分配空间，
//而类的非静态成员必须在类实例化之后才有内存空间，相当于调用一个未声明的变量，出错。

3.2 使用类的静态成员变量必须先初始化再使用

class A
{
public:
	A() {m++;}
	~A() {m--;}
	static print() {
		cout << m << endl;
	}
private:
	static int m;
};

void main()
{
	A a;
	a.print();
}
//编译不报错，连接时报错，类的静态成员变量在使用前必须先初始化，而且不能在类内初始化，
//可以在main函数之前使用`int A::m = 0`进行初始化，且不能在类内部进行初始化。

Python读写大数据文件

2015-03-25T00:00:00+00:00

一般的数据挖掘比赛，原始数据都存储在csv文件里面。而python，由于其方便好用的机器学习框架scikit-lenran，被普遍采用。对比了一下Python将文件载入内存的几种方法，感觉直接使用csv.reader速度相对较慢。

1. csv.reader读取

之前一直import csv来进行csv文件的读写，但是数据量大的时候，载入内存的速度有点慢。但是类似readline，可以很方便的忽略头信息。当然写法非常不Pythonic

f = file(path, 'r')
reader = csv.reader(f)
reader.next()
for line in reader:
	process()

2. with…open读取文件

一种比较Pythonic的写法，with可以负责处理open和close文件，包括抛出内部异常等，而for line in f将文件对象f当作迭代对象，将自动处理IO缓冲和内存管理，读取大文件时效率更高，经测试，500MB左右的文件，载入内存的时间在25s左右。就是比较爽的是，为了忽略第一行的头信息，需要加个count做判断，虽然开销不大，但是很不爽。

with open(path, 'r') as f:
	for line in f:
		process()

3. fileinput处理

用到了Python的fileinput模块。

import fileinput
for line in fileinput.input([path]):
	process()

4. Python写文件

将文件内容载入内存，进行了一定的处理后，存储在list或者dict中，需要写回文件。

file_ptr = open(path, 'w')
for line in dataset:
	new_line = ','.join(line) + '\n'
	file_ptr.write(new_line)
file_ptr.close()

三道面试题

2015-03-25T00:00:00+00:00

1. 题目来源

今天问了下xiaobo面X公司的Data Mining内推实习生的算法题，说是三道，都挺简单，但是陷阱不少，没准备的话会跪。随手做了一下，树的深度有限遍历，需要写出递归与非递归版本；strcpy的实现；二维链表转成一维链表，这个二维链表是不是十字链表？这个需要具体和面试官确定，即是不是一个node4个指针，第i行最后一个node的right指针指向第i+1行的第一个node；除此之外，主要抓着项目问，以及一些Linux的基本操作，MapReduce的基础等，没有问机器学习的模型。

2. 树的深度优先遍历

最经典、最简单的树相关问题，可以有先序、中序、后序三种，中序稍微麻烦一点；对于非递归做法，只是使用stack来模拟递归的操作。

2.0 二叉树的结构定义

struct TreeNode {
	int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

2.1 递归版本

class Solution {
public:
    vector<int> preorderTraversal(TreeNode *root) {
        vector<int> ret;
        dfs(root, ret);
        return ret;
    }
    
    void dfs(TreeNode *root, vector<int> &ret) {
        if (root == NULL)
            return;
        ret.push_back(root -> val);
        dfs(root -> left, ret);
        dfs(root -> right, ret);
    }
};

2.2 非递归版本I

class Solution {
public:
    vector<int> preorderTraversal(TreeNode *root) {
        vector<int> ret;
        stack<TreeNode *> st;
        if (root == NULL)
            return ret;
            
        TreeNode *cur = root;
        st.push(cur);
        
        while (!st.empty()) {
            cur = st.top();
            ret.push_back(cur -> val);
            st.pop();
            if (cur -> right)
                st.push(cur -> right);
            if (cur -> left)
                st.push(cur -> left);
        }
        
        return ret;
    }
};

2.3 非递归版本II

class Solution {
public:
    vector<int> preorderTraversal(TreeNode *root) {
        vector<int> ret;
        stack<TreeNode *> st;
        if (root == NULL)
            return ret;
        TreeNode *cur = root;
        while (cur != NULL || !st.empty()) {
            while (cur) {
                ret.push_back(cur -> val);
                st.push(cur);
                cur = cur -> left;
            }
            cur = st.top() -> right;
            st.pop();
        }
        return ret;
    }
};

3. strcpy函数的具体实现

C语言中char数组相关的操作，例如strcpy、strlen等，经常在面试中出现，即实现这些最基本的函数，这样的题目，存在很多的陷阱，真正考察一个coder的基本功。看到题目，只想到了字符数组的复制，检查指针是否为空，但是却没有考虑到，这个函数是有返回值的，那么为什么要设置一个返回值呢？这是一个问题。下面查资料所得，应该把相关的基本函数的实现，整理一下。

strcpy函数的原型：char *strcpy(char *strDest, const char *strSrc);
既然已经可以把strSrc复制给strDest，为什么函数还需要返回值？为了实现链式表达式，例如int len = strlen(strDest, "hello");

char *strcpy(char *strDest, char *strSrc)
{
	assert((strDest != NULL) && (strSrc != NULL));
	char *addr = strDest;
	while ((*strDest++ = *strSrc++) != '\0')
		;
	return addr;
}

tips: * 如果不检查指针的有效性，说明答题者不注重代码的健壮性； * 如果检查指针有效性时使用((!strDest)||(!strSrc))或(!(strDest&&strSrc))，说明答题者对C语言中类型的隐式转换没有深刻认识。在本例中((!strDest)是将char *转换为bool即是类型隐式转换，这种功能虽然灵活，但更多的是导致出错概率增大和维护成本升高； * NULL == strDest常量写在表达式的左边，如果将表达式写错了，写成了赋值，则马上报错；反之，当漏写了一个=，变成了strDest = NULL，则检查不出错误来。

Python中执行shell命令

2015-03-24T00:00:00+00:00

早上在测试wget从EC2上面下载文件的速度，忘了在python中执行shell命令的方法，顺手查了查，做下备忘。

1. os.system()函数

该函数得不到shell命令的输出，即可以显示执行结果，但是无法获取执行结果，操作空间不大。

import os
os.system('ls')

2. popen()方法

该方法可以得到命令执行后的结果是一个字符串，要自行处理，可以获取更多信息

import os
st = os.poen("ls").read()
a = st.split("\n")
for b in a:
	print b

3. commands模块

可以方便地取得命令的输出，包括标准和错误输出和执行状态位

import commands
a, b = commands.getstatusoutput('ls')
#其中a是退出状态，b是输出结果

Vector与String数组的转换

2015-03-23T00:00:00+00:00

读入一组 string 类型的数据,并将它们存储在 vector 中。接着,把该 vector 对象复制给一个字符指针数组。为 vector 中的每个元素创建一个新的字符数组,并把该 vector 元素的数据复制到相应的字符数组中,最后把指向该数组的指针插入字符指针数组。

Vector与String数组的转换

#include <iostream>
#include <vector>
#include <string>
using namespace std;
int main() {
	vector<string> svec;
    string str;// 输入 vector 元素
	cout << "Enter strings:(Ctrl+Z to end)" << endl;
    while (cin >> str)
        svec.push_back(str); 
    
    // 创建字符指针数组
    char **parr = new char*[svec.size()];

    // 处理 vector 元素
    size_t ix = 0;
    for (vector<string>::iterator iter = svec.begin(); iter != svec.end(); ++iter, ++ix) {
        // 创建字符数组
        char *p = new char[(*iter).size()+1];
        // 复制 vector 元素的数据到字符数组
        strcpy(p, (*iter).c_str());
        // 将指向该字符数组的指针插入到字符指针数组
        parr[ix] = p;
    }

    // 释放各个字符数组
    for (ix =0; ix != svec.size(); ++ix)
        delete [] parr[ix];
    // 释放字符指针数组
    delete [] parr;
    
    return 0;
}

外层循环中不使用typedef定义的类型，遍历二维数组元素

#include <iostream>
using namespace std;
int main() {
    //3 个元素,每个元素是一个有4个 int 元素的数组
    int ia[3][4] = \{\{1, 2, 3, 4\}, \{5, 6, 7, 8\}, \{9, 10, 11, 12 \}\};

    int (*p)[4];
    for (p = ia; p != ia + 3; ++p)
        for (int *q = *p; q != *p + 4; ++q)
            cout << *q << endl;
            
    return 0;
}

C++中变量做数组维数

2015-03-23T00:00:00+00:00

记得C/C++语法规范中，不能使用变量定义数组维数，因为数组维数的确定，需要在编译阶段完成。要想在程序实行阶段确定数组维数，应该使用new/malloc去动态分配；但是试验了一下，由于g++对C99的支持，使得使用变量定义数组维数也是可行的(在Linux系统下)，但是如此方法，在VC下会报错，即这并不是符合C++语法规范的写法，在很大程度上会限制代码的平台兼容性，应该避免这种写法，以此备忘。

C++语法中关于变长数组的规范

无论使用变量，还是函数表达式定义数组的长度，都是非法的只能使用常量表达式进行定义，即以下写法都是非法的。但是当对buf_size的定义加上const修饰符，则是合法的定义。

unsigned buf_size = 1024;
int ia[buf_size];
int ia[get_size()];

但是可以通过指针来动态申请空间实现动数组长度的变量赋值，在栈中分配的内存，大小都是编译时就确定好的，如果想在运行时来动态计算使用内存的大小的话，就要用new这样的动态分配函数，来达到更高的灵活性。c++ 用new分配空间以后，不用的时候要记得delete释放内存，不然会有内存泄露问题。

int length = 10;
int * varArray;
varArray = new int[length];

C99规范对变长数组的支持

C99规范中增加了对变长数组的支持，即可以使用C++语法规范中非法的方法来定义变长的数组，如此，对于支持C99规范不太好的平台来说，比如VC，就有可能出现很多的问题，应该尽量使用变量定义数组长度的C99规范支持的写法，在C99规范中，使用cin输入的整数作为数组长度，也是可行的。看样子C99规范中是使用动态数组的方式，支持了变长数组的定义，如下写法，也并不会出现数组越界访问的错误。

int n = 10;
int a[n];
a[100] = 9;

一个比较奇葩的现象

证明了C++中，使用变量定义数组长度时，是使用动态数组实现，因此不存在数组访问越界的问题；而使用常量定义数组时，会出现数组访问越界。下面的代码，会产生数组越界的报错。

const int n = 10;
int a[n];
a[100] = 9;

string与int转换相关

2015-03-21T00:00:00+00:00

在做Leetcode的Compare Version Numbers；涉及到string子串的比较，而子串全为数字，当时直接拿string来比较，没考虑到两个子串长度不同的情况，即”01”与”1”，应该是相等的。C语言中，使用atoi可以将string转换成int，而atoi的参数为const char *nptr，故在C++中，不能直接对string进行操作，可以先通过c_str返回一个指向正规C字符串的指针，再通过atoi进行转换;

1. atoi的简单实现

根据atoi()函数的功能，将字符串转换成整型数；atoi()会扫描参数nptr字符串，跳过前面的空格字符，直到遇上数字或正负号才开始做转换，而再遇到非数字或字符串时（’\0’）才结束转化，并将结果返回（返回转换后的整型数）。

int my_atoi(char* pstr)
{
	int ret_int  = 0;
	int int_sign = 1;
	//有指针，记得判断是否为空，防止越界；
	if (pstr == NULL) {
		printf("Pointer is NULL.\n");
		return 0;
	}
	
	//跳过可能存在的空格；
	while (isspace(*pstr) == 0)
		pstr ++;
		
	//检测符号，并跳过；
	if (*pstr == '-')
		int_sign = -1;
	if (*pstr == '+' || *pstr == '-')
		pstr ++;
		
	//遍历数组，逐个转换成整数；
	while (*pstr >= '0' && *pstr <= '9') {
		ret_int += (10*ret_int + *pstr - '0');
		pstr ++;
	}
	ret_int = int_sign * ret_int;
	return ret_int;
}

2. string 转换成int

首先通过s.cstr()将string转成char指针指向的数组；
通过atoi()函数转成整数；
需要注意的是，atoi(s.c_str())的方法转换，当s中存在非数字字符时，到非数字字符位置，转换会提前结束；ex: s = “a12”, return 0; s = “12a”, return 12;

3. Leetcode Compare Version Numbers

比较两个version的大小，在151之后才添加的题目，SoulMachine的题解以及先前第一遍刷的时候都没见这个题目；version string中只包含数字和’.’，’.’隔开版本号的层次；ex: 0.1 < 1.1 < 1.2 < 13.37 < 13.37.1

遍历一遍，每次纪录string中当前层的大小，进行对比，直接判断返回。若完全相同，则在最后返回相等；需要注意的是，通过改变最外层while循环的结束条件，可以控制将所有的逻辑判断，都放在循环体内；一开始将循环结束条件设置为一个string到达了末尾，如此，在该循环之外，还需要判断，到底是哪个string到达了末尾，代码很脏；

class Solution {
public:
    int compareVersion(string version1, string version2) {
        int v1_len = version1.size();
        int v2_len = version2.size();
        int idx1 = 0, idx2 = 0;
        
        while (idx1 < v1_len || idx2 < v2_len) {
            long long a = 0, b = 0;
            
            while (idx1 < v1_len && version1[idx1] != '.')
                a += (a * 10 + version1[idx1++] - '0');
            ++idx1;
            
            while (idx2 < v2_len && version2[idx2] != '.')
                b += (b * 10 + version2[idx2++] - '0');
            ++idx2;
            
            if (a > b) return 1;
            if (a < b) return -1;
        }
        return 0;
    }
};

C++中各种内置数据类型的长度以及表示范围

2015-03-21T00:00:00+00:00

关于各种内置数据类型的size，一直以来都记得不是特别明确，这段时间都在写比较底层的OS直接操作硬件的C代码，倒也习惯了u8、u16、u32各种为满足操作系统平台移植性要求定义的数据类型;想起两年半以前在skyroam时候，看着GMate的系统代码，这是啥，这特么又是啥，那个迷茫的夏天。两年多的时间，收获了太多，不管是coding 上，还是其他。

有关int

int类型比较特殊，具体的字节数同机器字长和编译器有关。例如：在32为平台上（所谓32位平台是指通用寄存器的数据宽度是32）编写代码，int 类型分配4个字节，而在16位平台是则分配2个字节，那么在16位上编译出来的可执行文件，其中是为int分配2字节，而在32位平台上运行时，会按照4个字节来解析，显然会出错误的。而对于非int，目前为止，所有的类型分配的字节数都是兼容的，即不同平台对于同一个类型分配相同的字节数。在代码中尽量避免使用int类型，根据不同的需要可以用short,long,unsigned int 等代替。

数据类型名称	字节数	取值范围
int	*	由操作系统决定，即与操作系统的＂字长＂有关
unsigned int	*	由操作系统决定，即与操作系统的＂字长＂有关
__int8	1	–128 到 127
__int16	2	–32,768 到 32,767
__int32	4	–2,147,483,648 到 2,147,483,647
__int64	8	–9,223,372,036,854,775,808 到 9,223,372,036,854,775,807
bool	1	false 或 true
char	1	–128 到 127
unsigned char	1	0 到 255
short	2	–32,768 到 32,767
unsigned short	2	0 到 65,535
long	4	–2,147,483,648 到 2,147,483,647
long long	8	–9,223,372,036,854,775,808 到 9,223,372,036,854,775,807
unsigned long	4	0 到 4,294,967,295
enum	*	由操作系统决定，即与操作系统的＂字长＂有关
float	4	3.4E +/- 38 (7 digits)
double	8	1.7E +/- 308 (15 digits)
long double	8	1.7E +/- 308 (15 digits)

字符串统计

2015-03-18T00:00:00+00:00

1. 题目来源

来自X公司的实习生面试题，即给定一个string s ＝ “abcabcabcbcc”，return “3a4b5c”;

2. 思路

第一反应就是，ASCII字符一共只有256个，使用一个数组模拟map，扫一遍string，纪录每个字符出现的次数；则再次便利数组，将count不为0的字符与其count组成string返回即可；估计是最近刷string的条件反射；如此，不管string的长度是多少，算法的时间复杂度为O(n)，而空间复杂度为常熟，即256；
使用数组模拟map的话，最后需要将int往ASCII转，是否有方法？使用map，就没有这个困惑，但是不是有点杀猪用牛刀？ ***
按照王神的说法，这题是做数据压缩，压缩的意思就是，一样的字符，应该是连续的，不可能出现”abcabc”这样的情况；所以这一题的话，直接扫一遍字符串，并作统计、拼接字符串就ok;

2.1 使用map纪录字符出现的次数，字符串统计:

class Solution {
public:
   string stringCount(string s)
	{
    	map<char, int> mp;
    	map<char, int> :: iterator it;
    	for (int i = 0; i < s.size(); ++i) {                                                                                          
        	mp[s[i]] ++;
    	}

    	string ret;
    	for (it = mp.begin(); it != mp.end(); ++it) {
        	if (it -> second > 0) {
            	char count = it -> second + '0';
            	ret.push_back(count);
            	ret.push_back(it->first);
        	}
    	}
    	return ret;
	}
};

2.2 字符串压缩:

class Solution {
public:
    string stringCompress(string s)
	{           
    	string ret;
    
    	int count = 1;
    	for (int i = 1; i < s.size(); ++i) {
        	if (s[i] == s[i-1]) {
            	count ++;
            	if (i == s.size()-1) {
                	ret += (count + '0');                                                                                             
                	ret += s[i];
            	}
       		}
        	else {
            	ret += (count+ '0');
            	ret += s[i-1];
            	count = 1;
        	}
    	}
    	return ret;
	}
};

link list cycle

2015-03-18T00:00:00+00:00

1. 题目来源

今天宿舍哥们去面X公司的内推实习生，说二面时上来就两道算法题，30分钟写完。一道是Leetcode上的原题，即判断一个链表是否有环，若有环，找出环开始的位置；还有一道题目为字符串压缩，即给出”aaabbbbccccc”，return “3a4b5c”，两道题目都比较简单；；最近在按分类刷Leetcode，即将完成String的部分，特意把Linked List Cycle I/II找出出来，提前做一下，两道题在Leetcode上面AC率都比较高。

2. 思路

经典的快慢指针题目，有环，则相遇；无环，快指针最终会为NULL；
而找出环开始的位置，则需要画图，将距离在图上标注一下得出，快指针以慢指针两倍的速度往前走，当二者相遇，则将快指针放在相遇的节点，慢指针拉回原点，二者以相同速度，再相遇的位置，即为环开始的位置；

2.1 Linked List Cycle I:

class Solution {
public:
    bool hasCycle(ListNode *head) {
        ListNode *slow = head;
        ListNode *fast = head;
        while (fast != NULL && fast -> next != NULL) {
            fast = fast -> next -> next;
            slow = slow -> next;
            if (fast == slow)
                return true;
        }
        return false;
    }
};

2.2 Linked List Cycle II:

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode *fast  = head;
        ListNode *slow  = head;
        while (fast != NULL && fast -> next != NULL) {
            fast = fast -> next -> next;
            slow = slow -> next;
            if (fast == slow)
                break;
        }
        if (fast == NULL || fast -> next == NULL)
            return NULL;
        
        slow = head;
        while (slow != fast) {
            slow = slow -> next;
            fast = fast -> next;
        }
        return slow; 
    }
};

Git中基本操作

2015-03-18T00:00:00+00:00

前两天看王神面实习的简历，简历上面清晰地标出每个项目的tag似是一个很好的办法，既给面试官重点突出的感觉，也便于将面试中心集中，方便自己准备，而作为大型软件的开发，版本控制必不可少，将Git与SVN相关的东西做一个小总结。

1. Git vs SVN

之前做实验室iPU的项目时，主要使用Subversion进行代码管理，现在自己的项目，基本使用Git；在不需要建多个分支的情况下，看起来二者差别不大；但一个分布式管理，一个集中式，还是倾向于使用Git，更安全。

SVN分支代码只有一份，当需要开发新功能或者增加新版本或者修改一个复杂的Bug时，通常需要copy整份代码到本地一个目录，然后再手动添加到SVN上进行管理，比较麻烦；而Git可以建多个branches，分支独立，每次commit，只是对本地仓库的修改；
SVN的log在服务器上，而Git的log在本地，方便查阅；
Git可以无限在本地建分支，当我们在本地新建不同分支用于不同目的时，合并代码要比SVN上合并一堆工程copy更为方便；
在Git本地仓库根目录，只有一个.git文件，包含所有的管理信息，而SVN每个子目录都有.svn，修改文件冲突时麻烦；

2. 初始化一个新的代码仓库

经常使用的Git功能主要有以下几个：

初始化一个新的代码仓库，做一些适当配置；
开始或者停止跟踪某些文件；
暂存或者提交某些更新；
浏览项目的更新历史，查看某两次更新之间的差异；
如何从远程仓库pull数据下来，或者push数据到远程仓库；

获取相应命令的帮助信息
$ git help config 
  初始化一个新的代码仓库，会生成.git目录
$ git init	
  告诉Git开始对某些文件进行跟踪             
$ git add README
  提交一个版本	        
$ git commit -m "message."

3. 从现有仓库克隆

即将项目的Git仓库复制一份出来，Git 收取的是项目历史的所有数据（每一个文件的每一个版本），服务器上有的数据克隆之后本地也都有了。实际上，即便服务器的磁盘发生故障，用任何一个克隆出来的客户端都可以重建服务器上的仓库，回到当初克隆时的状态。$ git clone git://github.com/schacon/grit.git mygrit 克隆一个代码仓库，也可以不指定克隆下来存储代码仓库的文件夹名字。

4. 纪录每次更新到仓库

工作目录下面文件的两种状态：已跟踪或未跟踪。已跟踪的文件是指本来就被纳入版本控制管理的文件，在上次快照中有它们的记录，工作一段时间后，它们的状态可能是未更新，已修改或者已放入暂存区。而所有其他文件都属于未跟踪文件。它们既没有上次更新时的快照，也不在当前的暂存区域。

初次克隆某个仓库时，工作目录中的所有文件都属于已跟踪文件，且状态为未修改。在编辑过某些文件之后，Git 将这些文件标为已修改。我们逐步把这些修改过的文件放到暂存区域，直到最后一次性提交所有这些暂存起来的文件。

使用Git时的文件状态变化周期.

确定哪些文件处于什么状态
$ git status
  开始跟踪file文件；修改某个文件之后，需要执行该命令将文件放入暂存区；  
$ git add file 
  可以创建.gitignore文件，不跟踪某些文件，自动忽略以o/a为后缀的文件；；       
$ cat .gitignore        
  *.[oa]            
  *~
  查看尚未暂存的文件更新了哪些部分；
$ git diff  
  将所有已经跟踪过的文件暂存起来并一块提交；        
$ git commit -a	 
  删除一个文件之后，再从未跟踪文件清单中将其清除；  
$ rm file
$ git rm file 
  相当于执行了`mv, git rm, git add`三条操作；
$ git mv file1 file2 
  将改动提交到远程仓库；
$ git push	
  从远程仓库将最新代码拉到本地；		  
$ git pull

Git操作中切换本地账户

2015-03-18T00:00:00+00:00

前段时间由于项目需要，一直往oschina上面的私有空间提交代码，懒得新建账户，就将本地的Git账户切换成了oschina上面团队的公共账号。今天在整Blog，才发现当时把本地的global设置给改了。而oschina和github，用的是一套机制。提交代码到github时，显示的不是自己账户提交，很不爽。翻了下资料，把本地的git设置给改了回来，留个备忘。

1. git-config工具

Git提供了一个git config工具，专门用来配置或者读取相应的工作环境变量，这些环境变量，决定Git在各个环节的具体工作方式和行为，文档显示这些变量可以存储在三个地方：

/etc/gitconfig文件：系统中对所有用户普遍适用的配置，git config –system 选项，读写的即是这个文件，但在Mac OS X上，该目录未找到这个文件；
~/.gitconfig 文件：只适用于当前用户，git config –global 选项，读写的就是这个文件；
当前项目Git目录中的配置文件，即.git/config 文件，这里的配置仅针对当前项目有效。每一个级别的配置都会覆盖上层的相同配置，所以 .git/config 里的配置会覆盖 /etc/gitconfig 中的同名变量；

2. 用户信息

个人的用户名称和电子邮件地址。这两条配置很重要，每次 Git 提交时都会引用这两条信息，说明是谁提交了更新，所以会随更新内容一起被永久纳入历史记录，对我来说，当时就是把user.email改成了wubin91的email账号，导致了账号切换的问题；

$ git config --global user.name "Mushsen"
$ git config --global user.email xtcmhs@gmail.com

如果用了 –global 选项，那么更改的配置文件就是位于你用户主目录下的那个，以后你所有的项目都会默认使用这里配置的用户信息。如果要在某个特定的项目中使用其他名字或者电邮，只要去掉 –global 选项重新配置即可，新的设定保存在当前项目的 .git/config 文件里。

PCI Express基本概念

2014-11-28T00:00:00+00:00

1. PCIe设备BAR空间的初始化：

PCIe设备进行数据传输之前，系统软件使用DFS算法遍历并完成BAR0~BAR5寄存器初始化，即分配这些设备在PCI总线域的地址空间，之后，PCI设备可以使用PCI总线地址进行数据传递；BAR0~5寄存器保存的都是PCI设备的地址空间，x86处理器中，没有存储器域和PCI总线域地址空间的转换机制，两个域的地址相等，也是一种简单映射，地址隔离的概念仍然存在；假设在一个32位处理器中，其存储器域的0xF000-0000~0xF7FF-FFFF总共128M的物理地址空间与PCI总线的地址空间映射；当处理器访问这段存储器地址空间，HOST主桥认领这个存储器访问，并将其使用的物理地址空间转换为PCI总线地址空间，并与PCI总线地址空间0xF000-0000~0xF7FF-FFFF对应；

当PCI设备使用DMA机制访问存储器域地址空间，处理器同样需要将存储器域地址空间反向映射；假设一个处理器系统中，主存储器大小为2GB，其在存储器域的地址范围为0x0000-0000~0x7FFF-FFFF，而这段地址在PCI总线域中对应的“PCI总线地址空间”为0x8000-0000~0xFFFF-FFFF。则PCI设备进行DMA操作时，必须使用0x8000-0000~0xFFFF-FFFF这段PCI总线域的地址，HOST主桥才能认领这个PCI总线事务；PCI设备的BAR寄存器中，包含该设备使用的PCI总线域的地址范围，6个BAR寄存器，因此一个PCI设备最多可以使用6组32位的PCI总线地址空间，或者33组64位的PCI总线地址空间；这些BAR空间保存PCI总线域的存储器地址空间或者I/O地址空间；大多数设备仅使用存储器地址空间，而通常一个设备使用2~3个BAR寄存器就足够；

2. PCIe设备的数据传递：

地址译码方式，存储器读写总线事务到达PCI总线时，在这条总线上的所有PCI设备将进行地址译码，如果当前总线事务使用的地址在某个PCI设备的BAR空间中时，该PCI设备将使能DEVSEL#信号，认领这个总线事务；
处理器到PCI设备的数据传送：
PCI设备11在PCI总线域的地址范围是0x7300-0000~0x73FF-FFFF，在存储器域中对应的地址范围是0xF300-0000~0xF3FF-FFFF；我们假设处理器使用存储器写指令，访问0xF300-0008这个存储器地址；
存储器域将0xF300-0008这个地址发向HOST主桥，0xF000-0000~0xF7FF-FFFF这段地址已经由HOST主桥映射到PCI总线域地址空间，所以HOST主桥认为这是一个对PCI设备的访问。因此HOST主桥将首先接管这个存储器写请求；
HOST主桥将存储器域的地址0xF300-0008转换为PCI总线域的地址0x7300-0008，并通过总线仲裁获得PCI总线0的使用权，启动PCI存储器写周期，并将这个存储器写总线事务发送到PCI总线0上；
PCI总线0的PCI桥1发现0x7300-0008在自己管理的地址范围内，接管这个存储器写请求，并通过总线仲裁逻辑获得PCI总线1的使用权，将请求转发到PCI总线1上；PCI总线1的PCI设备11发现0x7300-0008在自己的BAR0寄存器中命中，接收这个PCI写请求，并完成存储器写总线事务；
假定PCI设备11需要将一组数据，发送到0x1000-0000~0x1000-FFFF这段存储器域的地址空间中；
PCI设备11需要对PCI总线域的地址空间0x9000-0000~0x9000-FFFF进行写操作；
PCI设备11通过总线仲裁逻辑获得PCI总线1的使用权，将存储器写总线事务发送到PCI总线1上；值得注意的是，这个存储器写总线事务的目的地址是PCI总线域的地址空间0x9000-0000~0x9000-FFFF，这个地址是主存储器在PCI总线域的地址映像；
PCI总线1上的设备，包括PCI桥2和PCI桥1，进行地址译码，确定这个写请求是不是发送到自己的BAR空间；
PCI桥1发现自己并不能处理当前这个存储器写总线事务，首先通过总线仲裁逻辑获得PCI总线0的使用权后，然后将这个总线事务转发到上游；
HOST主桥发现0x9000-0000~0x9000-FFFF这段PCI总线地址空间与存储器域的存储器地址空间0x1000-0000~0x1000-FFFF对应，于是将这段PCI总线地址空间转换成为存储器域的存储器地址空间，并完成对这段存储器的写操作；
存储器控制器将从HOST主桥接收数据，并将其写入到主存储器；

3. PCIe概述：

PCIe总线由包括事务层、数据链路层、物理层组成，使用数据报文进行数据传递；使用硬件实现了交换、路由、仲裁机制的协议栈；
PCIe体系结构中出现的RC(Root Complex)，RC主要功能与PCI总线中的HOST主桥类似，但增加了很多功能；
Intel没有使用PCIe总线控制器，而是RC管理PCIe总线；x86中，RC除了管理PCIe设备的数据访问，还包括访问控制、错误处理、虚拟化等；
在互连领域，使用高速差分总线代替并行总线，与单端并行总线相比，可以使用更高的时钟频率，从而减少信号线，提高总线带宽；
每一条PCIe链路只能连接两个设备，端到端的连接方式，两个设备互为发送端和接收端；两端都含有TX(发送逻辑)和RX(接收逻辑)；
PCIe总线物理链路的一个数据通路(lane)中，由两组差分信号，共4根信号线组成；一个PCIe链路可以包涵多个lane；
目前PCIe链路可以由多个lane组成，x1、x2、x4、x8、x12、x16、x32，每一个lane使用的频率与PCIe总线使用的版本相关；
PCIe各个规范的总线频率: 1.x - 1.25GHz; 2.x - 2.5GHz; 3.0 - 4GHz; 单Lane峰值带宽：1.x - 2.5GT/s; 2.x - 5GT/s; 3.0 - 8GT/s; 编码方式：1.x - 8/10b编码; 2.x - 8/10b编码; 3.0 - 128/130b编码；即PCIe链路上，130bit含有128bit有效数据；
PCIe链路能够提供的峰值带宽：x1 - 5GT/s; x2 - 10GT/s; x4 - 20GT/s; x8 - 40GT/s; x12 - 60GT/s; x16 - 80GT/s; x32 - 160GT/s; GT计算PCIe链路的峰值带宽：GT(Gigatransfer) = 总线频率 x 数据位宽 x 2；
PCIe的延时严重：芯片内外的串并转换、数据报文经过多层模型；
处理器系统中，一般提供x16的PCIe插槽，即16对差分信号组成发送链路，16对差分信号组成接收链路；
PCIe设备之间的数据传输：PCIe Device A -> Transaction Layer -> Data Link Layer -> Physical Layer -RX/TX -> Physical Layer -> Data Link Layer -> Transaction Layer -> PCIe Device B;
事务层：封装来自PCIe设备核心的数据成TLP包，发送给数据链路层；从数据链路层接收报文，转发给设备核心；数据链路层：来自事务层的数据到来，被添加Sequence Number前缀和CRC后缀，使用ACK/NAK协议保证报文的可靠传递；物理层：定义了LTSSM状态机，管理链路状态，并进行链路训练、链路恢复和电源管理；
PCIe链路必须使用Switch才能连接多个设备，Switch由1个上游端口和2~n个下游端口组成，RC端口位于上方，下游端口一般和EP相连；

4. PCIe组成部件：

大多数处理器系统，都使用了RC、Switch、PCIe-to-PCIe 桥这些基本模块连接PCIe和PCI设备；基于PCIe总线的设备，称为EP(Endpoint);
之前介绍的PCI设备基本配置空间由64Bytes组成，地址范围为0x00~0x3F，这是PCI设备必须支持的；PCIe设备还拓展了0x40~0xFF这段配置空间，主要存放与MSI中断机制和电源管理相关的Capabilities结构，可以提交中断请求的PCIe设备，必须支持MSI Capabilities结构；
PCIe设备还支持0x100~0xFFF这段扩展配置空间，PCIe总线的扩展配置空间中，存放PCIe设备独有的一些Capabilities结构；
x86中，使用CONFIG_ADDRESS寄存器和CONFIG_DATA寄存器访问PCIe的0x00~0xFF，使用ECAM方式访问0x100 ~ 0xFFF;

5. TLP的路由：

TLP的路由指TLP通过Switch或者PCIe桥片时采用哪条路径，最终到达EP或者RC的方法；PCIe总线定义了三种路由方法：基于地址、基于ID和隐性路由；
存储器I/O读写采用基于地址的路由方式；配置读写报文采用基于ID的路由方式；

6. MSI中断机制：

PCIe总线中，PCIe设备必须支持MSI/MSI-X中断请求机制，可以不支持INTx中断信息；
MSI中断机制使用存储器写请求TLP向处理器提交中断请求；
PCIe设备提交MSI中断请求时，向MSI Capabilities结构中的Message Address结构写Message Data数据，从而组成存储器写TLP，向处理器提交中断请求；
目前大多数PCIe设备使用MSI或者MSI-X中断机制提交中断请求，其中MSI中断机制最多支持32个中断请求，并且要求中断向量连续；而MSI-X中断机制可以支持更多中断请求，并且不要求中断向量连续；MSI-X中断机制更合理；
Message Address和Message Data寄存器应该是位于PCIe设备的配置空间中；而MSI-X机制使用的这两寄存器位于BAR空间，因此可以由用户决定使用MSI-X中断请求的数目；

7. Message Address和Message Data字段：

PCIe设备使用Message Address字段保存PCI总线域地址，其中[31:20]存放FSB Interrupt存储器空间基地址，值为0xFEE，PCIe设备向0xFEEX-XXXX这段“PCI总线域”地址空间进行写操作，首先进行PCI总线域到存储器域的地址转换，之后写操作翻译成FSB总线的Interrupt Message总线事务，从而向CPU内核提交中断请求；
FSB总线事务提交PCIe设备使用的中断向量，从而CPU不需要使用中断响应周期从寄存器获得中断向量；
Message Data的[7:0]为Vector字段，表示中断请求使用的中断向量，FSB将中断向量也通知处理器；
PCIe设备发送MSI/MSI-X中断请求之前，系统软件需要合理设置PCIe设备的MSI/MSI-X Capabilities寄存器，使得Message Address寄存器的值为0xFEExx00y(什么意思？)，同时设置Message Data寄存器的Vector字段；Message Address寄存器在存储器域和PCI总线域中的地址都为0xFEC00020;
PCI设备使用的irq号存放在pdev->irq中，该参数在Linux设备驱动程序初始化时，由pci_enable_device函数设置；irq号给系统软件使用，之后PCI设备的驱动程序可以使用request_irq函数将中断服务例程与irq号建立映射关系；
PCIe设备需要使用MSI中断机制时，将调用pci_enable_msi函数，该函数返回值为0时，表示成功返回，此时函数更新pci_dev -> irq参数；函数在纯软件层面进行一些全局变量的参数检查，硬件层面上检查上游的PCI桥等是否支持MSI报文的转发，PCI设备是否具有Capabilities表等；

PCI基本概念

2014-11-28T00:00:00+00:00

1. PCI体系结构：

PCI为局部总线，系统总线的延伸，用于连接外设；
PCI Express总线：PCIe总线；PCI-to-PCI桥：PCI桥；PCI Express-to-PCI桥：PCIe桥；Host-to-PCI主桥：HOST桥，也称为PCI主桥或者PCI总线控制器；

2. HOST主桥(PCI控制器)：

PCI总线与处理器地址空间隔离：PCI设备的独立地址空间，即PCI总线地址空间，通过HOST主桥和处理器地址空间隔离，处理器通过HOST主桥访问PCI设备，PCI设备通过HOST主桥访问主存储器；
HOST主桥的多极缓冲，确保处理器总线和PCI总线工作在各自的时钟频率不干扰，设备和处理器共享主存储器资源；
HOST主桥的一个重要作用就是对存储器地址与PCI总线地址进行转换；PCI总线域地址空间和存储器域地址空间是不一样的；
通过HOST主桥直接推出的PCI总线，可以通过PCI桥扩展出一系列PCI总线，HOST主桥为根节点，一棵PCI总线树，最多挂载256个PCI设备；
每个PCI设备都有独立的配置空间，含有设备在PCI总线中使用的基地址，系统软件可以动态配置，保证每个PCI设备的物理地址不同；
PCI总线可以使用MSI中断机制，通过存储器读写总线事务传递中断请求；
HOST主桥与主存储器在处理器系统的同一级总线上，PCI设备可以方便通过HOST主桥访问主存储器，即DMA操作；
HOST主桥还完成处理器和设备之前的数据交换，即处理器访问PCI设备地址空间和PCI设备使用DMA机制访问主存储器；
由于PCI总线是一个以HOST主桥为根的树形主从架构，不易于实现多处理器系统之间的对等互联；
HOST主桥中设置了许多寄存器，HOST处理器可以通过操作这些寄存器管理PCI设备，可以通过寄存器或者存储器映像寻址方式访问PCI设备寄存器空间；

3. PCI总线的存储器读写事务：

地址译码方式进行数据传递，即采用地址信号；
ID译码方式进行配置信息传递，使用PCI设备的ID号，包括Bus Number、Device Number、Founction Number和Register Number；
PCI设备在系统软件初始化配置空间后，设备在PCI总线树上有一个独立PCI总线地址空间，即BAR寄存器描述的空间，才能由其他设备访问;
HOST处理器使用PCI总线的存储器读写事务和I/O读写事务对PCI设备的BAR空间进行数据读写，BAR空间可以用存储器或者I/O译码方式；
PCI设备对主存储器进行读写，即DMA操作，读写操作结束后伴随着中断产生，可以使用MSI机制提交中断请求；
数据传送方式：Posted-数据请求通过PCI总线之后，将逐级释放总线资源，因此PCI总线利用率较高；Non-Posted-请求通过PCI总线时，并不及时释放总线资源，必须在当前总线事务结束后，才能释放；

4. HOST设备访问PCI设备：

HOST处理器对PCI设备的数据访问：发起存储器和I/O读写请求；对PC设备进行配置读写；
PCI设备配置空间，共6个BAR寄存器，每一个BAR寄存器都与PCI设备使用的一组PCI总线地址空间对应，BAR寄存器记录这组地址空间基地址；BAR寄存器对应的PCI总线空间为BAR空间，可以存放I/O地址空间，或存储器地址空间；存放的是“PCI总线域”而不是“存储器域”的物理地址；
x86处理器中，存储器域的I/O地址和PCI总线域的I/O地址相同，可以通过访问存储器域的I/O地址空间进行PCI设备的I/O地址空间访问；
存储器读写事务：HOST处理器初始化时，先将PCI设备使用的BAR空间映射到“存储器域”的地址空间，处理器通过存储器的读写指令访问“存储器域”的地址空间，HOST主桥将读写请求转换为PCI总线的存储器读写事务，发送给目标设备；
需要再次强调的是：处理器能够直接使用的是存储器域的地址；PCI设备能够直接使用的是PCI总线域的地址；许多处理器中，存储器地址与PCI总线地址完全相等，但含义完全不同；

5. PCI设备读写主存储器：

PCI设备与主存储器直接进行数据交换(DMA)时，需要获得数据传送的目的地址和传送大小；支持DMA传递的PCI设备可以在BAR空间设置两个寄存器，分别保存目的地址和传送大小，这两个寄存器也是PCI设备DMA控制器的组成部件；
PCI设备进行DMA操作，目的地址为PCI总线域的物理地址，HOST主桥负责其到存储器域地址的转换；HOST主桥需要合理设置，将存储器地址空间映射到PCI总线，PCI设备才能对这段存储器空间进行DMA操作；
许多处理器允许PCI设备访问所有存储器域地址空间，但是有些处理器设置PCI设备所能访问的存储器地址空间；只有在PCI总线域中有映像的存储器空间才能被PCI设备访问；

6. 存储器域与PCI总线域：

CPU访问主存储器时，将读写指令放入读写指令缓冲中，然后发送到DRAM控制器或者HOST主桥，再转换为DRAM或者PCI总线地址，分别进入DRAM域或者PCI总线域，再访问相应地址空间；
DRAM域地址空间指DRAM控制器可以访问的地址空间集合，目前处理器系统的DRAM一般由DDR-SDRAM组成，也称为主存储器；
多数时候，DRAM域空间是CPU区域空间的一部分，也有例外：显卡控制器可能借用一部分主存储器空间，被借用的空间不能被CPU访问，只能被显卡控制器通过DRAM控制器访问，这段空间不属于CPU域，而是外部设备域；
存储器域包括CPU内部通用寄存器、存储器映像寻址的寄存器、主存储器空间、外部设备空间；x86，外部设备空间与PCI总线域地址空间等效，因为使用PCI总线统一管理全部外部设备；
处理器系统中，CPU能访问的PCI总线地址一定在存储器域中有地址映射，而PCI设备能够访问的存储器域地址也一定在PCI总线域有映射；
PCI设备使用的地址空间保存在各自的PCI配置寄存器中(BAR)，这些PCI总线地址空间需要在初始化时映射成存储器域的地址空间，之后处理器才能访问，x86处理器中，HOST主桥的硬件逻辑中存在这个地址转换的概念；而PowerPC处理器通过独立的寄存器保存这个地址映射规则；

7. PCI设备配置空间访问机制：

PCI总线规定了配置空间的访问事务，使用ID号进行寻址，ID号由总线号(Bus Number)、设备号(Device Number)、功能号(Function)组成；
总线号在HOST主桥遍历PCI总线树时确定，总线号由系统软件决定；系统软件使用DFS算法扫描PCI总线树，并编号；与主桥直接相连的PCI总线为PCI总线0；与HOST主桥连接的PCI总线都为0，当有多个HOST主桥时，存在多个编号0的总线，但属于不同PCI总线域；
PCI总线的设备号由PCI设备的IDSEL信号与PCI总线地址线的连接关系确定；
功能号与PCI设备的设计相关，最多可以有8个功能设备，每个功能设备有自己的配置空间，但绝大多数设备只有一个功能设备；
x86使用南北桥结构连接CPU和PCI设备，北桥连接快速设备，如显卡、内存，并推出PCI总线，HOST主桥位于北桥中；
x86处理器定义了两个I/O端口寄存器，分别为CONFIG_ADDRESS和CONFIG_DATA寄存器，地址为0xCF8和0xCFC，x86处理器使用这两个I/O端口访问PCI设备的配置空间，其中CONFIG_ADDRESS存放PCI设备的ID号，CONFIG_DATA存放进行配置读写的数据；
CONFIG_ADDRESS寄存器各个字段： Enable位：第31位，为1时，对CONFIG_DATA寄存器进行读写将引发PCI总线的配置周期； Bus Number：第23~16位，记录PCI设备的总线号； Device Number：第15~11位，记录PCI设备的设备号； Function Number：第10~8位，记录PCI设备的功能号； Register Number：第7~2位，记录PCI设备的寄存器号；
x86处理器对CONFIG_DATA寄存器进行I/O读写访问，且CONFIG_DATA的Enable位为1时，HOST主桥将这个I/O读写访问转换为PCI配置读写总线事务，发到PCI总线，PCI总线根据保存在CONFIG_DATA寄存器的ID号，将PCI配置读写请求发送到指定PCI设备的指定配置寄存器；

8. PCI桥：

PCI桥的配置空间对其下PCI设备进行管理，系统软件不需要专门的驱动程序设置PCI桥，因此PCI桥称为透明桥；
有一种非透明桥，在PCI总线挂接另一个处理器系统时有用，即连接两个不同的PCI总线域(看起来当使用PCIe连接不同tail时需要使用非透明桥)
通过PCI桥连接的PCI总线属于同一个总线域，不需要进行地址转换；PCI桥可以扩展出新的PCI总线，但不能扩展PCI总线域，如果系统使用32位PCI总线地址，则系统的PCI总线域地址空间为4GB，总线域上的所有设备共享4GB的空间；

9. PCI设备的配置空间：

具体处理器应用时，PCI设备常将PCI配置信息存放在EEPROM中，PCI设备上电初始化时，将其读到PCI设备配置空间作为初始值，该过程由硬件逻辑完成(目测我们的芯片不采用这种方式，而是软件进行初始化)；
PCI设备的配置空间包含很多寄存器，决定了该设备在PCI总线中的使用方法，即常见的那个寄存器图(包括Device ID和Vender ID等)；PCI Agent设备配置空间包含的寄存器如下；
Device ID和Vender ID寄存器：由PCISIG组织分配，只读，其中Vender ID代表PCI设备生产厂商，Device ID代表厂商生产的具体设备；设备的识别，对于PCIe软核来说，完全由PCIe控制器来决定；
Revision ID和Class Code寄存器：只读，前者记载PCI设备的版本号，即Device ID的扩展；
Header Type寄存器：只读，8位组成，第7位为1表示该设备是多功能设备，为0表示为单功能设备；第6~0位表示当前配置空间类型，为0表示PCI Agent设备的配置空间，系统软件需要使用其区分不容类型的PCI配置空间，必须与设备实际情况对应(由此可见这些由硬件写入)；
Cache Line Size寄存器：记录HOST处理器使用的Cache行长度，该寄存器由系统软件设置，但PCI设备的运行过程中，只有硬件逻辑使用该寄存器；对于PCIe设备，该寄存器的值无意义，PCIe的报文中含有一次数据传送的大小，设备可以使用来判断数据区域与Cache的对应关系；
Subsystem ID和Subsystem Vender ID：也是记录PCI设备的生产厂商和设备名称，但与Vender ID和Device ID略有不同；
Expansion ROM base address：有些PCI设备在处理器还没运行操作系统之前，需要完成基本初始化操作，为了预先执行的功能，PCI设备需要提供一段ROM程序来初始化设备，该寄存器记录ROM程序的基地址；
Capabilities Pointer寄存器：PCIe中必须支持该寄存器，存放Capabilities寄存器组的基地址； *. Interrupt Line寄存器：系统软件对PCI设备配置时写入，记录当前PCI设备的中断向量号，设备驱动通过该寄存器，判断PCI设备使用处理器系统的哪个中断向量号； *. Interrupt Pin寄存器：保存PCI设备的中断引脚，如果不使用中断引脚，则必须为0； *. Command寄存器：PCI设备的命令寄存器，寄存器初始化时，为0，此时不能接受任何存储器或者I/O请求；设备驱动程序需要通过pci_enable_device函数，使能该寄存器的I/O和Memory Space位之后，才能访问该设备的存储器或者I/O地址空间； *. Status寄存器：绝大多数位都是只读位，保持PCI设备的状态； *. Latency Timer寄存器：PCIe设备不需要使用，必须设置为0； *. Base Address Register0~5：即BAR寄存器；

10. BAR寄存器：

Base Address Register0~5：即BAR寄存器，保存PCI设备使用的地址空间的基地址，保存设备在PCI总线域中的地址，每个设备最多可以有6个基址空间；
PCI设备复位之后，存放PCI设备需要使用的基地址空间大小，该空间是I /O空间还是存储器空间等信息；
软件对PCI总线进行配置时，首先获得BAR寄存器中的初始化信息，之后根据处理器系统的配置，将合理的基地址写入相应的BAR寄存器中；系统软件还可以使用该寄存器，获得PCI设备使用的BAR空间的长度，通过向BAR寄存器写入0xFFFF-FFFF，之后再读取该寄存器实现；
处理器访问PCI设备的BAR空间时，需要使用BAR寄存器提供的基地址；但处理器使用存储器域的地址，而BAR寄存器存放PCI总线域的地址，因此处理器系统并不能直接使用“BAR寄存器+偏移”的方式访问PCI设备的寄存器空间，而需要将PCI总线域的地址转换为存储器域的地址；
即使x86处理器系统使能了IOMMU，这两个地址也并不一定相等，因此处理器系统直接使用这个PCI总线域的物理地址，并不能确保访问PCI设备BAR空间的正确性；除此之外在Linux系统中，ioremap函数的输入参数为存储器域的物理地址，而不能使用PCI总线域的物理地址；
而在pci_dev -> resource[bar].start参数中保存的地址已经经过PCI总线域到存储器域的地址转换，因此在编写Linux系统的设备驱动程序时，需要使用pci_dev -> resource[bar].start参数中的物理地址，然后再经过ioremap函数将物理地址转换为“存储器域”的虚拟地址，再访问；

Linux Device Driver——PCI基础

2014-11-24T00:00:00+00:00

1. PCI接口：

PCI总线通过使用比ISA更高的时钟频率，获得更好的性能；时钟设置运行在25或者33MHz、66MHz甚至133MHz；
PCI对接口板自动探测，没有跳线，并且在系统启动时自动配置；设备驱动必须能够存取设备中的配置信息以便完成初始化；
每个PCI外设有一个总线号、一个设备号、一个功能号标识，PCI规范允许单个系统占用多达256根总线，每个总线占用32个设备，每个设备可以
是一个最多具有8个功能的多功能卡，每个功能在硬件层次被一个16位地址标识；
如果需要多个PCI总线，可以通过PCI桥实现，PCI系统的实现是树状分布；和PCI外设相关的16-位硬件地址，隐藏在struct pci_dev结构中；
PCI总线的I/O空间使用一个32位地址总线，而内存空间可以使用32位或者64位地址存取；系统启动时BIOS固件初始化PCI硬件，映射每个区到
不同地址来避免冲突，被映射的地址可以从配置空间读出，因此Linux驱动不需要使用探测读取设备，根据配置寄存器信息安全存取相应硬件；
每个设备的PCI(包括PCI Express设备)配置空间包含256Bytes，每个功能有4KB配置空间，配置空间排布标准化；配置空间的4个字节含有唯一
功能ID，因此驱动可以识别设备；即通过物理寻址找到设备的配置寄存器，根据寄存器信息进行正常的I/O存取；
PCI接口标准相对ISA创新之处在于配置地址空间；

2. 配置空间：

PCI设备上电时，硬件保持未激活，内存和I/O端口都没有映射到计算机地址空间，即设备只能被配置；BIOS固件可以读写配置地址空间；
系统启动时，固件配置PCI外设，分配安全的位置给外设提供的地址区；驱动存取设备时，将其内存和I/O区域映射到处理器地址空间；
所有的PCI设备都有至少一个256-Bytes的地址空间，前64字节是标准的，剩下的依赖设备；
venderID和deviceID标识一个设备，由PCI制造商分配，驱动使用这两个ID来查找设备；venderID有一个全球的注册，由供应商决定；
__u32 vender, device指定一个设备的PCI供应商和设备ID，如果驱动可以处理任何供应商或者设备ID，这两个值应该为PCI_ANY_ID;
PCI_DEVICE(vender, device)创建一个struct pci_device_id，该宏设置结构的供应商和设备成员为PCI_ANY_ID;

3. 注册PCI驱动：

struct pci_device_id结构可以告诉用户空间相应驱动支持哪些设备；
PCI驱动必须创建主结构struct pci_driver，包含函数回调和变量，才能被正确注册到内核；
const char *name；驱动名字，必须唯一，通常设置为和驱动模块名字相同；
const struct pci_device_id *id_table: 指向struct pci_device_id表的指针；
int (*probe)(struct pci_dev *dev, const struct pci_device_id *id): 指向PCI驱动中probe函数的指针，当它认为有一个这个驱动想要控制的struct pci_dev时，被PCI核心调用；
void (*remove)(struct pci_dev *dev): 指向对应的pci_dev被从系统中去除时调用的函数；
int (*suspend) (struct pci_dev *dev, u32 state): struct pci_dev被挂起时调用；函数可选；
int (*resume) (struct pci_dev *dev): pci_dev被恢复时调用；函数可选；
pci_register_driver(&pci_driver)注册struct pci_driver到PCI核心，若所有都成功注册，返回0，否则，返回负的错误码；
pci_unregister_driver(&pci_driver)注销内核中的struct pci_driver，绑定到这个驱动的PCI设备被去除，函数返回之前remove函数被调用；

4. 使能PCI设备：

在驱动可存取PCI设备的任何设备资源之前(I/O区域或者中断)，驱动必须调用pci_enable_device函数；
int pci_enable_device(struct pci_dev *dev); 唤醒设备；
函数将PCI配置空间的Command域的0位和1位置1，从而开启设备，即开启内存映射和I/O映射；还做开启中断的工作；

5. 存取配置空间：

驱动探测到设备以后，常常需要读写3个地址空间，内存、端口、和配置；这是唯一找到设备被映射到内存和I/O空间位置的方法；
CPU无法直接存取配置空间，为了存取配置空间，CPU必须读写PCI控制器中的寄存器，Linux提供标准接口存取配置空间；
对于驱动，配置空间可以通过8-bits, 16-bits, 或者32-bits数据传输来存取；

int pci_read_config_byte(struct pci_dev *dev, int where, u8 *val);
int pci_read_config_word(struct pci_dev *dev, int where, u16 *val);
int pci_read_config_dword(struct pci_dev *dev, int where, u32 *val);

以上函数从dev标识出的设备配置空间读取1个、2个或者4个字节；where参数是从配置空间开始处的字节偏移；取得的值通过val指针返回；
相对应的写配置空间函数：

int pci_write_config_byte(struct pci_dev *dev, int where, u8 val); 
pci_write_config_word, pic_write_config_dword;

6. 存取I/O和内存空间：

一个PCI设备实现6个I/O地址区，每个区域由内存区或者I/O区组成，大部分设备在内存区中实现其I/O寄存器；
PCI_ADDRESS_0到 PCI_ADDRESS_5为配置空间的6个32位配置寄存器；内核中PCI设备的I/O区域集成在通用资源管理中，不必存取配置
变量知道设备映射到的内存或者I/O空间；

unsigned long pic_resource_start(struct pic_dev *dev, int bar);	//函数返回某个bar的第一个地址(内存地址或者I/O端口号)；
unsigned long pic_resource_start(struct pic_dev *dev, int bar);	//函数返回某个bar的最后一个地址；

7. PCI中断：

Linux启动时，BIOS给设备分配唯一的中断号，中断号存储在PCI配置寄存器的60(PCI_INTERRUPT_LINE);

result = pic_read_config_byte(dev, PCI_INTERTUPT_LINE, &myirq);
if (result) {
	/*deal with error.*/
}

Linux Device Driver——内存分配

2014-11-24T00:00:00+00:00

1. kmalloc：

不清零获得的内存，分配的区在物理内存中连续；void *kmalloc(size_t size, int flags);size为分配块的大小，flags为分配标志；
flags：GFP_KERNEL 分配代表运行在内核空间的进程进行，意味着调用函数代表一个进程执行一个系统调用，能够使当前进程在少内存情况下睡眠等待一页；内部通过调用__get_free_pages进行；
如果一个模块需要分配大块内存，最好使用面向页的技术；__get_free_page(unsigned int flags);返回一个指向新页的指针，不清零该页；
flags：GFP_ATOMIC kmalloc从一个进程上下文外部调用时，当前进程不被睡眠，内核试图保持一些空闲页满足原子的分配；
Linux内核内存区：支持DMA操作内存区、普通内存、高端内存；
支持DMA操作内存区位于一个优先的地址范围，外设可以在此进行DMA存取，大部分健全平台，所有内存都在该区，在x86，DMA区在RAM的
前16MB。
kmalloc和__get_free_pages返回的内存地址是虚拟地址，实际物理地址寻址仍然由MMU管理；

2. vmalloc：

在虚拟内存空间分配一块连续内存区，尽管这些页在物理内存不连续，内核将其看作连续的地址范围；使用alloc_page调用获得每个页；
vmalloc分配的地址只有在处理器的MMU之上才有意义，当驱动需要一个真正的物理地址时，无法使用vmalloc；只有在为一个大的只存在于软件中的顺序缓冲分配内存时，调用vmalloc，vmalloc比__get_free_pages开销更大，因为必须获取内存并建立页表；
ioremap建立新页表，实际上不分配任何内存；返回值是一个特殊的虚拟地址，可以存取特定物理地址范围；虚拟地址最终通过iounmap释放；
ioremap对于映射一个PCI缓冲的物理地址到虚拟内核空间；

3. 获得大空间的缓冲区：

大量连续内存缓冲区的分配容易失败，系统内存长时间会碎片化，常常出现真正的大内存区不可得；
如果需要一个物理上连续的大空间内存缓冲区，最好启动时请求内存进行分配，只有直接链接到内核的驱动可以这样做；

4. 与硬件通讯：

驱动是软件概念和硬件电路之间的抽象层，需要存取I/O端口和I/O内存；
数字I/O是一个输入/输出打开的最简单形式，写到设备的数据出现在输出管脚，处理器可以直接存取到输入管脚上的电平；
PC通过读写外设的寄存器进行控制操作；一个设备的若干寄存器位于连续地址；
硬件级别上，内存区域和I/O区域没有概念上的区别，都通过在地址总线和控制总线发出信号来存取；
大部分PCI设备映射寄存器到一个内存地址区域，这种I/O存取内存更加有效；

5. 使用I/O端口：

I/O端口是驱动跟设备通讯的方法，内核提供注册接口以允许去东莞声明需要的端口；接口中核心函数是request_region;
struct resource *request_region(unsigned long first, unsigned long n, const char *name);
该函数告诉内核，要使用n个端口，从first开始，name参数是设备名，分配成功则返回非NULL；
驱动为硬件请求了需要使用的I/O端口范围之后，必须读/写到这些端口，

6. 使用I/O内存：

尽管I/O端口在x86世界流行，但设备通讯的主要机制是通过寄存器和设备内存的映射实现，即I/O内存，寄存器和内存之间的区别对软件透明；
I/O内存是一个RAM区域，处理器使用I/O内存跨过总线存取设备；
当处理器通过页表存取I/O内存，内核必须首先安排驱动可见的物理地址，即I/O操作之前调用ioremap做映射；
使用I/O内存区之前进行分配：struct resource *request_mem_region(unsigned long start, unsigned long len, char *name);
该函数分配一个len字节内存区；使用完毕调用release_mem_region进行释放；
不能直接引用从ioremap返回返回的地址指针，应当使用内核提供的存取函数进行I/O内存的存取：I/O读：unsigned int ioread8(void *addr); ioread16; ioread32; addr是从ioremap获得的地址，返回值从给定I/O内存读取；I/O写：void iowrite8(u8 value, void *addr); iowrite16; iowrite32;

7. 中断处理：

驱动只需要为其设备注册一个中断处理函数，中断到来时进行正确处理；
中断线资源有限，一个模块需要注册中断通道，不使用时进行释放；int request_irq(unsigned int irq, irqreturn_t (*handle)(int, void *, struct pt_regs *), unsigned long flags, const char *dev_name, void *dev_id);

8. 可移植性：

通常的C数据类型如int、long，在不同体系上大小不同；内核中经常使用的数据类型有自己的typedef语句，阻止了任何可移植性的问题；
使用内存时，一个内存页应该是PAGE_SIZE字节，不是4KB，页大小根据平台有4KB~64KB的可能性；

Linux Device Driver——并发和竞争

2014-11-18T00:00:00+00:00

1. 并发和竞争

实际产生竞争的情况

if (!dptr -> data[s_pos]) {
              dptr -> data[s_ops] = kmalloc(quantum, GFP_KERNEL);
              if (!dptr -> data[s_pos])
                   goto out;
         }

假设两个进程（A，B）独立地试图写入同一个设备的相同偏移，进程同时到达if测试，如果被测试指针为NULL，每个进程都会决定分配内存且复制给dptr -> data[s_ops]，显然只会有一个赋值可以成功；
如果A先赋值，则将被B覆盖，结果指针指向B分配的内存，而A分配的内存被丢掉，但是并没有返回给系统，产生了内存泄漏；
并发源：多个用户空间进程的运行；SMP系统能够同时在多个处理器上执行代码；内核代码抢占，驱动代码可能在任何时间失去处理器；设备中断，内核中延迟代码执行的机制等；
竞争来自对资源的共享存取，驱动设计时，应该避免共享的资源，比如全局变量的使用；

2. 信号量（旗标）

加锁，保证数据结构操作原子化；如果一个线程必须分配一个特殊内存块，这个分配必须在其他线程做测试之前，必须建立临界区，在任何给定时间只有一个线程可以执行代码；
一个Linux进程到达一个无法做进一步处理的地方时，阻塞，让出处理器直到某个时间被唤醒，进程通常在等待I/O完成时睡眠；
旗标：旗标是一个整数值，结合有一对函数，P和V。一个想要进入临界区的进程将在相关旗标上调用P，如果旗标值大于0，值减1且进程继续；如果旗标为0，进程必须等待别人释放旗标；解锁一个旗标通过调用V完成，递增旗标值，唤醒等待进程；
当旗标用作互斥，即阻止多个进程在同一临界区运行，值初始化为1。如此旗标在任何时候只能由单一进程或者线程持有。以这种方式持有旗标称为互斥锁，Linux中的旗标通常用作互斥锁；
旗标相关数据类型：struct semaphore；通常通过void sema_init(struct semaphore *sem, int val)对其初始化；
简化操作，互斥锁的声明和初始化：DECLARE_MUTEX(name); 将旗标变量初始化为1，也可以用于显示解锁；DECLARE_MUTEX_LOCKED(name);将旗标变量更改为0，即上锁状态；
在运行时间初始化：void init_MUTEX(struct semaphore *sem); void init_MUTEX_LOCKED(struct semaphore *sem);
P函数称为down，3个版本，包括int down_interruptible(struct semaphore *sem);递减旗标并等待需要的时间；
V函数为up，void up(struct semaphore *sem);up函数被调用，则调用者不再拥有旗标；

3. 自旋锁

大部分加锁通过自旋锁机制实现，自旋锁可以用在不能睡眠的代码中，例如中断处理；
一个自旋锁是一个互斥设备，只能有两个值，上锁和解锁；上锁，则代码进入临界区；如果该锁被别人获得，代码进入循环并反复检查该锁，直到可用，该循环即自旋锁的自旋部分；
“测试并置位”操作必须以原子方式进行，以便只有一个进程能获得锁；必须避免在超线程处理器上死锁——实现多个虚拟CPU以共享一个单处理器核心和缓存的芯片；特性上说，自旋锁使用在SMP处理器上；
运行时初始化自旋锁：void spin_lock_init(spinlock_t *lock); 进入临界区之前获得锁：void spin_lock(spinlock_t *lock);
所有的自旋锁等待都是不可中断的，一旦调用spin_lock，将自旋到锁变为可用为止；释放一个锁：void spin_unlock(spinlock_t *lock);
自旋锁核心规则：在持有锁时，是原子性的，不能睡眠；不能因为任何原因放弃处理器，除了服务中断；当驱动请求自旋锁并进入临界区，中间某处驱动失去了处理器（调用copy_from_user使进程睡眠或者内核抢占），可见的将来该锁都不可能释放，某个别的进程想获得同一个锁，则最好情况下会等待很长时间，最坏情况系统可能完全死锁；
必须一直是尽可能短时间持有，确保其他进程自旋等待释放锁的时间不会太长；长时间自旋也阻止了当前处理器调度，高优先级进程不得不等待；

4. 信号量与自旋锁

信号量和读写信号量适合于保持时间较长的情况，它们会导致调用者睡眠，因此只能在进程上下文使用（因为中断的上下文不允许休眠）
自旋锁适合于保持时间非常短的情况，因为一个被争用的自旋锁使得请求它的线程在等待重新可用时自旋，特别浪费处理时间，所以自旋锁不应该被长时间持有。
如果被保护的共享资源只在进程上下文访问，使用信号量保护该共享资源非常合适；如果对共享资源的访问时间非常短，自旋锁也可以。但是如果被保护的共享资源需要在中断上下文访问（包括底半部即中断处理句柄和顶半部即软中断），就必须使用自旋锁。

Linux Device Driver——模块相关

2014-11-18T00:00:00+00:00

1. 驱动编写策略：

编写内核代码存取硬件，但是不能强加不同策略给用户；驱动应该做到使硬件可用，将所有关于如何使用硬件的事情交给应用程序；
单个设备可能由不同程序并发使用，驱动有完全自由决定如何处理并发性；

2. 内核角色划分：

进程管理：内核负责创建，销毁进程；处理其与外部世界的联系；处理不同进程之间通信（信号，管道，进程间通讯原语）；控制进程如何共享CPU；
内存管理：内核为每个进程都在有限的可用资源上建立一个虚拟地址空间；
文件系统：内核在非结构化硬件上建立结构化的文件系统，Unix中所有东西都看作文件；
设备控制：每个系统操作都会映射到物理设备，除了处理器，内存等，任何设备控制操作都由设备驱动代码进行；
网络：操作系统管理网络，系统负责在程序和网络接口之间传递数据报文，根据程序的网络活动控制程序执行；路由和地址解析也在内核实现；

3. 模块：

可以在运行时添加到内核的代码，设备驱动是模块；
模块由目标代码组成（没有链接成完整可执行文件），通过insmod，rmmod去连接，卸载；

4. 设备和模块分类：

字符设备（char）：可以当作字节流来存取的设备，如同文件；字符驱动至少实现open, close, read, write等系统调用；文本控制台和串口是字符设备的例子；
块设备，通过位于/dev目录的文件系统结点存取，一个块设备可以驻有文件系统；Linux允许应用程序像字符设备一样写块设备，一次传送任意数目字节；块设备和字符设备与内核接口完全不同，但对用户透明；
网络接口：任何网络事务都通过接口进行，网络接口负责收发数据报文；

5. 驱动编写注意：

如今很多安全问题由缓冲区覆盖引起，忘记检查多少数据写入缓冲区，数据在缓冲区之外结束，覆盖无关数据；
任何从用户进程接收的输入，都要谨慎；
小心对待未初始化内存，从内核获得的任何内存都应该清零或者在其对用户进程/设备可用之前初始化，否则容易内存泄漏；

6. 内核版本：

偶数内核版本（2.6.x）是稳定的，通用发布；
奇数内核版本（2.7.x）是开发快照，代表开发的当前状态，几天过时；

7. Hello World模块：

module_init(hello_init), module_exit(hello_exit), 使用了特别的内核宏指出hello_init, hello_exit的角色；前者在模块加载到内核时调用，后者在模块被去除时调用；MODULE_LICENSE(“Dual BSD/GPL”)告知内核，该模块带有一个自由的许可证，否在模块加载时内核抱怨；
printk为内核自己的打印函数，没有C库帮助；insmod模块以后，被连接到内核并可存取内核的函数和变量，故可以调用printk；
在窗口系统中运行insmod、rmmod，不会在屏幕有任何输出，消息进入系统日志文件中，如/var/log/messages;

8. 内核模块相比应用程序：

应用程序执行单个任务，而内核模块只注册自己，以便服务将来应用，内核模块类似于事件驱动编程；
模块的退出函数必须小心恢复每个由初始化函数建立的东西；
应用程序可以调用其没有定义的函数，连接阶段使用合适库函数解决外部引用；而模块只连接到内核，能够调用的函数仅限于内核输出的那些；
处理错误方式不同，应用程序开发阶段错误通常无害，可以使用调试器追踪错误；而内核错误会杀死当前进程，甚至kernel panic；
模块在内核空间运行，应用程序在用户空间运行；
模块拓展内核功能，模块中的一些函数作为系统调用的一部分，另一些负责中断处理；
大多数应用程序（多线程除外），从头到尾不必担心其他事情发发生而改变其运行环境；而内核代码，并发经常发生；
内核编程的并发来源：系统运行多个进程，同一时间不止一个进程试图使用驱动；大部分设备可以中断处理器，中断处理异步，可能在驱动试图做其他事情时被调用；对于多处理器系统，驱动可能在多个CPU上并发执行；
内核代码的数据结构必须小心设计以保持多个执行线程分开，正确的并发管理在编写正确内核代码时必须；
应用程序存在于虚拟内存中，有一个非常大的堆栈区保存函数调用历史以及所有由当前活跃函数创建的自动变量；内核只有一个小的堆栈可能只有4096字节的页，内核模块函数与内核空间调用链共享堆栈；不能声明大的自动变量，如果需要大的结构，应当在调用时动态分配；
内核代码不做浮点运算，使能浮点将要求内核每次进出内核空间时保存和恢复浮点处理器状态，额外负担不值得；

9. 初始化和卸载：

实际初始化函数：

static int __init initialization_function(void) {
              /*code here.*/
         }
         module_init(initialization_function);

初始化函数应该声明为静态，不会在特定文件之外可见；__init 标志暗示内核，给定函数只在初始化使用，模块加载后会丢掉该函数，使其内存可作他用；module_init增加特别的段到目标代码，表明在哪找到模块的初始化函数；
实际卸载函数，注销接口，模块被去除之前返回所有资源给系统：

static void __exit cleanup_function(void) {
              /*code here.*/
         }
         module_exit(cleanup_function);

__exit标识代码只用于模块卸载，模块直接建立在内核或者内核配置成不允许模块卸载时，__exit将被丢弃；module_exit标明清理函数位置；

10. 错误处理：

注册时大量内存分配操作，分配的内存可能不可用，必须一直检查返回值；一旦失败不能加载，必须取消任何失败之前注册的动作；
错误恢复通常使用goto语句；

Leetcode:Maximal Rectangle

2014-11-05T00:00:00+00:00

Maximal Rectangle

给一个二维数组，用0，1填充，找出包含1的矩形的最大面积。

思路

开始想到的思路是，比较好的时间复杂度应该是n方，动态规划（似乎看到二维数组，首先就想到DP，估计跟最近做的几个二维DP的题目有关，还是得好好总结，建立方法论）。即f[i][j]纪录以matrix[i][j]为右下顶点的矩形的最大面积。但是这样出现了一个问题，到f[i][j]的转移方程没法写，无法从f[i-1][j]/f[i][j-1]得到，思维还是存在漏洞。
正确思路：这个题目应该跟一维数组时，求最大能够容纳的水容量，或者是两根柱子组成的面积最大，连续整数的最大长度这些题一个类型，只是把数组从一维变成了二维。这样的话，按照原来两遍夹逼的思路。两个全局的数组L，R，对每一列都适用，即纪录当前行位置，第j列的最大允许的左边界以及右边界。两个局部的指针left，right，纪录当前行每个位置的左边界与右边界。并且通过left与right去更新L，R数组。

完整代码:

class Solution {
public:
    int maximalRectangle(vector<vector<char> > &matrix) {
        if (matrix.empty())
            return 0;
        int m = matrix.size();
        int n = matrix[0].size();
        vector<int> H(n, 0);
        vector<int> L(n, 0);
        vector<int> R(n, n);
        int ret = 0;
        for (int i = 0; i < m; ++i) {
            int left = 0, right = n;
            for (int j = 0; j < n; ++j) {
                if (matrix[i][j] == '1') {
                    ++H[j];
                    L[j] = max(left, L[j]);
                }
                else {
                    left = j+1;
                    H[j] = 0;
                    L[j] = 0;
                    R[j] = n;
                }
            }
            for (int j = n-1; j >= 0; --j) {
                if (matrix[i][j] == '1') {
                    R[j] = min(right, R[j]);
                    ret = max(ret, H[j]*(R[j]-L[j]));
                }
                else {
                    right = j;
                }
            }
        }
        return ret;
    }
};

Leetcode:First Missing Positive(Bucket Sort)

2014-11-05T00:00:00+00:00

First Missing Positive

给一个未排序的整形数组，找出缺失的第一个正整数。算法需要满足O(n)的时间复杂度以及使用恒定的空间。
输入：A[] = {1, 2, 0}, n = 3 return 3.
输出：A[] = {3, 4, -1, 1}, n = 4 return 2.

思路

直觉：未排序整形数组，要达到O(n)的时间复杂度，直觉使用map。扫一遍，建立map，同时找出最大值。第二次扫，找出缺失的正整数。如此，为O(n)的时间复杂度以及O(n)的空间复杂度，Accepted，时间60ms.
另一思路：桶排序，即充分利用数组的索引，达到map的作用。数组的第i个索引位置，应该存放的元素应该是i+1, 当把能放到正确位置的元素都放好，再扫一遍，得出需要的解，时间复杂度为O(n), 空间复杂度为O(1)，Accepted，时间12ms.
第二种思路，充分利用已有的存储空间，空间复杂度得以优化。而且直接在数组上操作，map为数组上层的封装，使用STL，效率还是要差了一些。故第二种思路的时间性能也更高。

使用map的思路，完整代码:

class Solution {
public:
    int firstMissingPositive(int A[], int n) {
        map<int, int> mp;
        int max_num = A[0];
        for (int i = 0; i < n; ++i) {
            mp[A[i]] = i;
            max_num = A[i] > max_num ? A[i] : max_num;
        }
        for (int i = 1; i <= max_num; ++i)
            if (mp.find(i) == mp.end())
                return i;
        return max_num+1;
    }
};

使用桶排序的方法，完整代码:

class Solution {
public:
    void bucketSort(int A[], int n) {
        for (int i = 0; i < n; ++i)
            while (A[i] != i+1) {
                if (A[i] <= 0 || A[i] > n || A[i] == A[A[i]-1])
                    break;
                swap(A[i], A[A[i]-1]);
            }
    }

    int firstMissingPositive(int A[], int n) {
        bucketSort(A, n);
        for (int i = 0; i < n; ++i)
            if (A[i] != i+1)
                return i+1;
        return n+1;
    }
};

Linux下PCIe驱动以及DMA机制

2014-11-05T00:00:00+00:00

1. 驱动程序作用：

设备驱动程序向应用程序屏蔽了硬件在实现上的细节，使得应用程序可以像操作普通文件一样操作外部设备。Linux操作系统抽象了对硬件的处理，可以使用和操作文件相同的，标准的系统调用接口来完成打开，关闭，读写喝I/O控制操作，而驱动程序主要任务也就是实现这些系统调用函数。

每个设备文件对应两个设备号，其中主设备号标识设备种类，也标识了设备所使用的驱动程序；次设备号标识使用同一设备驱动程序的不同硬件设备。设备文件的主设备号必须与设备驱动程序在登陆该设备时申请的主设备号一致，否则用户进程无法访问到设备驱动程序。

2. 块设备与字符设备的区别：

二者之间区别仅仅在于内核与驱动程序之间的软件接口上，块设备利用一块系统内存作为缓冲区，当用户进程对设备进行读写请求时，驱动程序先查看缓冲区的内容，如果能满足用户要求，则返回相应数据，否则调用相应请求函数进行实际I/O操作。

3. DMA循环缓冲区的分配与实现：

对于高速数据信号的采集处理，需要在驱动程序的初始化模块（probe）中申请大量的DMA循环缓冲区，申请的大小直接关系着能否实时对高速数据处理的成败。直接内存访问（DMA）是一种硬件机制，允许外围设备和主内存直接直接传输I/O数据，避免了大量的计算开销。

4. Linux内核的内存分区段：

三个区段，可用于DMA的内存，常规内存以及高端内存。
通常的内存分配发生在常规内存区，但是通过设置内存标识也可以请求在其他区段中分配。可用于DMA的内存指存在于特别地址范围内的内存，外设可以利用这些内存执行DMA访问，进行数据通信传输。
DMA循环缓冲区的分配要求：物理连续，DMA可以访问，足够大。

5. Linux内存分配函数：

Linux系统使用虚拟地址，内存分配函数提供的都是虚拟地址，通过virt_to_bus转换才能得到物理地址。
分配内核内存空间的函数：kmalloc实现小于128KB的内核内存申请，申请空间物理连续；__get_free_pages实现最大4MB的内存申请，以页为单位，所申请空间物理连续；vmalloc分配的虚拟地址空间连续，但在物理上可能不连续。
Linux内核中专门提供了用于PCI设备申请内核内存的函数pci_alloc_consistent，支持按字节长度申请，该函数调用__get_free_pages，故一次最大为4MB。

6. DMA数据传输的方式：

一种是软件发起的数据请求（例如通过read函数调用），另一种是硬件异步将数据传给系统。对于数据采集设备，即便没有进程去读取数据，也要不断写入，随时等待进程调用，因此驱动程序应该维护一个环形缓冲区，当read调用时可以随时返回给用户空间需要的数据。

7. PCIe中向CPU发起中断请求的方式：

消息信号中断（MSI），INTx中断。
在MSI中断方式下，设备通过向OS预先分配的主存空间写入特定数据的方式请求CPU的中断服务，为PCIe系统首选的中断信号机制，对于PCIe到PCI/PCI-X的桥接设备和不能使用MSI机制的传统端点设备，采用INTx虚拟中断机制。
PCIe设备注册中断时使用共享中断方式，Linux系统通过request_irq实现中断处理程序的注册，调用位置在设备第一次打开，硬件产生中断之前；同样，free_irq时机在最后一次关闭设备，硬件不用中断处理器之后。
中断处理函数的功能是将有关中断接收的信息反馈给设备，并对数据进行相应读写。中断信号到来，系统调用相应的中断处理函数，函数判断中断号是否匹配，若是，则清除中断寄存器相应的位，即在驱动程序发起新的DMA之前设备不会产生其他中断，然后进行相应处理。

8. 数据读写和ioctl控制：

数据读写：应用进程不需要数据时，驱动程序动态维护DMA环形缓冲区，当应用进程请求数据，驱动程序通过Linux内核提供copy_from_user()/copy_to_user()实现内核态和用户态之间的数据拷贝。
硬件控制：用户空间经常回去请求设备锁门，报告错误信息，设置寄存器等，这些操作都通过ioctl支持，可以对PCIe卡给定的寄存器空间进行配置。

9. 中断处理程序的注册：

中断号在BIOS初始化阶段分配并写入设备配置空间，然后Linux在建立pci_dev时从配置空间中读出该中断号并写入pci_dev的irq成员中，所以注册中断程序时直接从pci_dev中读取就行。
当设备发生中断，8259A将中断号发给CPU，CPU根据中断号找到中断处理程序，执行。

10. DMA数据传输机制的产生：

传统经典过程：数据到达网卡 -> 网卡产生一个中断给内核 -> 内核使用 I/O 指令，从网卡I/O区域中去读取数据。这种方式，当大流量数据到来时，网卡会产生大量中断，内核在中断上下文中，会浪费大量资源处理中断本身。
改进：NAPI，即轮询，即内核屏蔽中断，隔一定时间去问网卡，是否有数据。则在数据量小的情况下，这种方式会浪费大量资源。
另一个问题，CPU到网卡的I/O区域，包括I/O寄存器和I/O内存中读取，再放到系统物理内存，都占用大量CPU资源，做改进，即有了DMA，让网卡直接从主内存之间读写自己的I/O数据。
首先，内核在主内存中为收发数据建立一个环形的缓冲队列（DMA环形缓冲区），内核将这个缓冲区通过DMA映射，将这个队列交给网卡；网卡收到数据，直接放进环形缓冲区，即直接放到主内存，然后向系统产生中断；
内核收到中断，取消DMA映射，可以直接从主内存中读取数据。

Leetcode:2Sum, 3Sum, 3Sum, 3Sum Closet 4Sum

2014-11-02T00:00:00+00:00

题目含义.

Leetcode 的Array相关题目，Two Sum，3Sum，3Sum Closet，4Sum。都是给定一个整形数组(以vector形式给出)，给定一个target number。在数组里找出若干个数，使得和为target number，或者最接近target number。返回满足条件的数组元素或者元素索引。

Two Sum

给一个整形数组，一个target，找两个元素，使得和为target，返回这两个元素的位置。
输入：numbers = {2, 7, 11, 15}, target = 9
输出：{1, 2}

几个想法

错误思路：开始想到的思路，排序后，通过两边指针夹逼的形式，排序复杂度为nlogn，两边夹逼复杂度为n。但是这题要求返回元素位置，而排序改变了元素。自然想到使用map，存储元素位置，但是既然使用了map，这题还得nlogn的复杂度，显然不太科学。于是有了下面的思路。
正确思路：通过一个map存储纪录每个元素的位置。扫一遍数组，对每一个元素，计算gap，然后在map中查找，key为gap的位置是否存在。由于在map中执行find操作，时间复杂度为1，故整体时间复杂度为n, Accepted.

完整代码:

class Solution {
public:
    vector<int> twoSum(vector<int> &numbers, int target) {
        vector<int> ret;
        int len = numbers.size();
        map<int, int> mp;
        for (int i = 0; i < len; ++i)
            mp[numbers[i]] = i; 
        
        for (int i = 0; i < len; ++i) {
            int gap = target - numbers[i];
            if (mp.find(gap) != mp.end() && mp[gap] != i) {
                ret.push_back(i+1);
                ret.push_back(mp[gap]+1);
                break;
            }
        }
        return ret;
    }
};

3Sum Closet

给一个整形数组，一个target，找三个元素，使得和最接近给定的target，输出最接近的值。假设只有一个解。
输入：num = {-1, 2, 1, 4}, target = 1
输出：2

几个想法

错误思路：开始想的是，通过Two Sum的方法进行延伸，既然是找3个数，可以通过一个map，纪录每两个数的和，便将3Sum 转化为Two Sum的问题来解决。
1. map的建立，时间复杂度为n^2
2. 通过map与pair配合的方式进行存储，map<int, pair<int, int> >
3. 总的时间复杂度为n^2，瓶颈为map的建立
4. 在数据量大的时候，超时
正确思路：该题不用返回索引，首先排序，再通过左右夹逼的方式，时间复杂度也是n^2，但是却Accepted. 应该是单纯的数组操作，比之封装在其上的数据结构，还是有性能优势

完整代码:

class Solution {
public:
    int threeSumClosest(vector<int> &num, int target) {
        int sum = num[0] + num[1] + num[2];
        int gap = abs(sum - target);
        int min_gap = gap;
        int ret = 0;
        sort(num.begin(), num.end());
        for (auto a = num.begin(); a != prev(num.end(), 2); ++a) {
            auto b = next(a);
            auto c = prev(num.end(), 1);
            while (b < c) {
                sum = *a + *b + *c;
                gap = sum - target;
                if (abs(gap) <= min_gap) {
                    ret = sum;
                    min_gap = abs(gap);
                }
                if (gap == 0)
                    return ret;
                else if (gap > 0)
                    c--;
                else
                    b++;
            }
        }
    
        return ret;
        
    }
};

3Sum

给一个整形数组，找三个元素，使得和为0.找出所有满足条件的解，每个元素只能取用一次。
返回的解(元素)，元素必须非递减，即(a, b, c)，其中a<= b <= c
输入：{-1, 0, 1, 2, -1, 4}
输出：{(-1, 0, 1), (-1, -1, 2)}

几个想法

错误思路：开始想到的是，照搬3Sum Closet的想法，两边夹逼。这题的关键是，要求输出的解无重复，而给定的输入数组有重复。
1. 对于第一个for循环，每一次循环开始，纪录a的值。每个循环，判断a的值，如果与上一次的a相同，相同则continue。但是忽略了b，c也可能重复。结果有重复。
2. 先不管重复情况，完全按照两边夹逼的方法，得到一个有重复的解，然后去重，即通过sort()将结果vector中的元组排序，再通过unique将重复元素扔到vector后面，即begin位置为没有重复的元组最后一个位置，对vector进行erase操作，将重复的删除。而这也是vector去重的一般方法。结果超时。
正确思路：回到错误思路1，即两边夹逼，对于a, b, c，均判断是否与上一个值相等，若想等，则continue。形式上有三个循环嵌套，但是平均复杂度，仍然为n^2，Accepted.

完整代码:

class Solution {
public:
    vector<vector<int> > threeSum(vector<int> &num) {
        vector<vector<int> > ret;
        if (num.size() < 3)
            return ret;
        
        sort(num.begin(), num.end());
        for (auto a = num.begin(); a != prev(num.end(), 2); ++a) {
            if (a != num.begin() && *a == *(a-1))
                continue;
            auto b = next(a);
            auto c = prev(num.end(), 1);
            while (b < c) {
                int target= *a + *b + *c;
                if (target == 0) {
                    ret.push_back({*a, *b, *c});
                    ++b;
                    while (*b == *(b-1))
                        ++b;
                    --c;
                    while (*c == *(c+1))
                        --c;
                }
                else if (target > 0)
                    --c;
                else
                    ++b;
            }
        }
        return ret;
    }
};

4Sum

给一个整形数组，一个target，找四个元素，使得和为target.找出所有满足条件的解，每个元素只能取用一次。
输入：num = {1, 0, -1, 0, -2, 2}, target = 0.
输出：{(-1, 0, 0, 1), (-2, -1, 1, 2), (-2, 0, 0, 2)}

几个想法

错误思路：从做前面几题的情况来看，这题如果使用左右夹逼的方式，最小时间复杂度为n^3，应该会超时。于是想到了map。
1. 先两层循环嵌套扫数组，纪录两两元素的和，value为两个元素的索引。考虑到一个和可能对应多个元素对，value使用了value，数据结构为map<int, vector<pair<int, int> > >，相当于把4Sum问题转化成了3Sum问题。请注意，只是相当于。
2. 再次两层循环嵌套扫数组，如果a与上次元素相同，跳过，对b，亦如此。计算gap，在map中寻找key为gap的位置是否存在，从vector中取出另外两个值的索引。结果超时。个人猜测是map,pair, vector 搭建的数据结构，严重影响了C++的效率。
正确思路：先排序，map形式仍然为map<int, vector<pair<int, int> > >，通过约定找出不符合条件的value，直接跳过。
1. 第二次两层循环嵌套扫数组，求出gap。由于map中每个value的第一个索引肯定小于第二个索引(先排序，再建map)，而第二次扫数组时的两个值，num[i], num[j]，也是前一个值小于后一个值。则建立一个约定，num[i] < num[j] < num[tmp[k].first] < num[tmp[k].second或者num[tmp[k].first] < num[tmp[k].second < num[i] < num[j]，对于不满足条件的值，跳过。
2. 这样的思路，可能出现的重复，主要在于，数组中可能有重复元素，则在map的建立时，某一些key对应的value(vector)中，是存在重复的。
3. 最后对结果vector去重，Acceptd.不过这种方法，运行时间比较长，leetcode上给出的时间在756ms. 在数组建立时进行有效去重，或者第二次循环嵌套扫描时先进行去重，应该会有所提高。

class Solution {
public:
    vector<vector<int> > fourSum(vector<int> &num, int target) {
        vector<vector<int> > ret;
        if (num.size() < 4)
            return ret;
        sort(num.begin(), num.end());
        map<int, vector<pair<int, int> > > mp;
        
        for (int i = 0; i < num.size(); ++i)
            for (int j = i+1; j < num.size(); ++j) {
                int index = num[i] + num[j];
                mp[index].push_back(make_pair(i, j));
            }
        
        int gap = 0;
        for (int i = 0; i < num.size(); ++i) {
            for (int j = i+1; j < num.size(); ++j) {
                gap = target - num[i] - num[j];
                if (mp.find(gap) == mp.end())
                    continue;
                auto tmp = mp[gap];
                for (int k = 0; k < tmp.size(); ++k) {
                    //if (i <= tmp[k].second)
                    //    continue;
                    //ret.push_back({num[tmp[k].first], num[tmp[k].second], num[i], num[j]});
                    if (j >= tmp[k].first)
                        continue;
                    ret.push_back({num[i], num[j], num[tmp[k].first], num[tmp[k].second]});
                    
                }
            }
        }
        
        sort(ret.begin(), ret.end());
        ret.erase(unique(ret.begin(), ret.end()), ret.end());
        return ret;
    }
};

Neural Network Accelerator II

2014-10-22T00:00:00+00:00

写在前面

这段时间由于工作需要，研究了一下ASPLOS’14的Best Paper，”Dianao: A Small-Footprint High-Throughput Accelerator for Ubiquitous Machine-Learning.” 这是中国大陆的学者首次获得 CCF 推荐的体系结构领域 A 类会议的最佳论文奖。而此前,ASPLOS 最佳论文奖一直被美国卡耐基梅隆大学、德州大学奥斯丁分校、微软等 8 个欧美著名研究机构所垄断。下面结合这篇文章，写写阅读摘要。

神经网络协处理器的发展.

现在的大多数协处理器研究者，关注的都是如何有效提高神经网络运算的效率。现今的深度神经网络，在规模上差别很大。寒武纪1号神经网络协处理器，强调存储对协处理器性能，功耗的决定性影响，通过一种优化的访存方式，解决了访存瓶颈问题。在台积电 65nm 工艺下,寒武纪 1 号主频可达 0.98GHz、性能 452 GOPS、功耗 0.485W、面积约为 3mm2。也就是说，它可以在通用处理器核 1/10 的面积和功耗开销下，达到通用处理器核 100 倍以上的人工神经网络处理速度。即便和最先进的 GPU 相比, 寒武纪 1 号的人工神经网络处理速度也不落下风，而其面积和功耗远低于 GPU 的 1/100。这样一个小面积，大吞吐量的机器学习协处理器，有着广泛的系统及产品级的应用前景。

当处理器架构发展到异构多核，无论从提高运算性能还是降低功耗的角度来说，设计协处理器，都是一个广泛采用的解决方案。那么，在什么应用领域，有了设计协处理器的需求？是在很多对高性能运算有迫切需求的应用领域，从图像，视频，语音识别到自动翻译领域，商业分析，以及各种各样依赖于机器学习技术的领域。在大部分的领域，都有机器学习的用武之地，CNN/DNN在过去几年成为了最火的机器学习算法，很多的应用领域，都可以套用深度学习的模型，取得良好的效果。即一种算法，可以解决若干应用问题，这是一个独特的设计神经网络协处理器的时机，为几种主流的算法，定制专用的运算平台，这是一个潜力巨大的未占领市场。

如今，大多数的深度学习运算任务，都在多核SIMD处理器，GPU集群或者FPGA上面执行，这是目前为止比较常用的解决方案。而有一些研究者已经提出了使用协处理器实现CNN或者MLP算法。协处理器应用的其他领域，像图像识别，也有用ASIC设计的方法实现卷积神经网络，或者其他典型的神经网络算法。但是这些协处理器实现，都是着眼于如何高效地实现运算，但它们或者因为设计简单，忽略了内存传输方面地问题，或者直接把协处理器通过DMA加到了内存上。并没有解决通用处理器集群运行神经网络算法受限的访存瓶颈问题。

神经网络训练问题

我们都知道，神经网络算法的训练代价很大，无论是浅层神经网络的随机梯度下降，还是深度学习的Wake-Sleep，在大量样本的情况下，都需要特别长的模型训练时间。于是很多的神经网络算法研究者，有了提高训练效率的需求，当然，这只是一小部分的市场。而有更多的最终用户，需要更好的产品体验，诸如图像识别，语音识别，广告推荐，等等。而深度学习在这些领域，受限于硬件瓶颈，还并未得到很好的应用。这是一块巨大的市场。一个革新的硬件平台，可以大大加速深度学习技术在各个领域的应用。

& 很多时候，我们都强调在线训练，在线调整模型的重要性，实际上，目前的大多数业界机器学习应用，都尚未做到在线实时调整模型，似乎也没有这个必要。毕竟增加小量样本的情况下，进行模型训练，有一个精确度与代价的权衡问题。我们会发现，在电商购买了某商品以后，多天之后，其网站还会给我们推荐同样的商品，这应该是模型并未重新训练的结果。一般大样本训练的模型，都会在增加新样本以后，通过一种增量训练的方法，调整模型(增量训练的方法，一直还没有去调研，mark一下)。所以，在线训练，对目前的深度学习应用来说，并不是显得那么的重要。

CNN/DNN 一般结构

CNN/DNN算法，由一系列的各种层组成，并按序列执行，各层可以认为相对独立，层与层之间全连接或者部分连接。每一个layer包括若干sub-layer，叫 feature map。总的来说，有三种layers，convolutional 以及pooling layers，在网络顶层有一个由若干layer组成的classifier。对于浅层网络MLP来说，由输入层，输出层以及若干隐含层组成。而深度神经网络的隐含层可以有各种变化，诸如RBM，LRN，CONV，MLP，POOLING等。在顶层是由若干层组成的分类器(果断时间好好整理整理深度学习模型，再作具体研究，本文只专注于论文内容，作适当延伸)。

卷积层

卷积层的作用，对输入特征做映射，因此输入输出feature map之间并不是全连接。设想输入是一个图片，卷积是一个2D变换，输入图片的一个子区域KxKy，以及一个相同维数的变换矩阵。变换矩阵(kernel values)是输入输出之间卷积层的突触权重。一个输入层通常包含多个feature map，而输出feature map通常通过对同样窗口大小的输入feature map做卷积得到。对于一个卷积层，pooling层，分类器级联的网络，kernel是3D，KxKy*Ni，Ni是输入的feature map数目，在一些情况下，连接是稀疏的，即不是所有的输入feature map都对最终的输出feature map有贡献。通常一个非线性函数用于卷积层输出，例如tanh(x).

POOLING层

Pooling层的作用，是统计临近数据集合的信息。以图像为例，倾向于只包含给定窗口大小或者一定尺度的显著的图像信息。重要的作用就是降低feature map的维数。每一个feature map都是独立的进行pooling，即2D pooling，而不是3D。卷基层和pooling层交替结合成为一个深度结构，顶层通常是一个分类器，线性或者是两层感知器。分类器通常聚集所有feture map，故而在这一层没有feature map的概念。

小型神经网络的硬件实现

最自然的把神经网络映射到硬件上的想法就是所有的神经元和突触都布局在硬件上，内存只是用来输入数据以及储存结果。简单地把软件神经元/突触全映射，所以硬件实现可以匹配概念上的神经网络。每个神经元都由逻辑电路实现，突触由锁存器或者RAM实现。这样地结构可以满足一些神经元与突触数目较小的小型神经网络，提供较大的速率与较小的功耗，因为数据的移动距离较小（比起从内存搬数据）。无论对于从一层到另一层的神经元，或者对于从一个突触锁存到相应神经元，都是如此。这样的结构，对于90-10-10的感知器来说，执行时间15ns，能耗为通用处理器的1/974.

但是，面积，功耗，延迟都是随着神经元数目呈二次方增长。我们综合出了一个ASIC神经网络，算出了它们的面积，延时，功耗。每个神经元执行如下操作，将输入神经元与突触相乘，将神经元对应的这些和进行相加，然后进行sigmoid变换。1616 layer需要0.71mm，3232 layer需要2.66mm。设想当神经元是成千上万的时候，一个硬件全映射的神经网络，面积是不可想像的，所以这样的实现对大型神经网络并不适合。

软硬件神经元一一映射神经网络的能耗-输入/输出神经元数目关系图.

寒武纪1号大型神经网络协处理器实现

####整体架构寒武纪1号包括4个主要模块，控制处理器模块（CP）负责取指令，并配置整个加速器的运行。神经网络计算功能部件（NFU）负责具体的神经网络计算。两个神经元缓存（NB）暂存正在处理的神经层及其依赖的神经层上神经元的数据。此外，还有一个突触缓存（SB）负责暂存正在处理的神经层及其依赖的神经层之间突触的数据。

寒武纪1号整体架构图.

将神经元/突触权值分布式存储于片上 RAM ，优化数据搬运

在运算开始阶段，突触/神经元初始权值通过主内存分别传入 SB 以及 NBin 两个 Buffer 中；运算阶段，通过控制处理器的指令，将相应的突触/神经元权值取到运算部件 NFU 中执行，并将执行结果送回 Buffer ；神经网络运算完毕，再将运算结果传回主内存。即神经网络运算过程中，只有 SB, NBin 以及 NBout 三个 Buffer与运算部件 NFU 有数据交互，并且为每个 Buffer 分别配置一个 DMA，并且独立存储指令请求，可以极大限度地进行指令预取而不用担心冲突情况的发生，有效地降低了访存延迟。相对于传统的 CPU/GPU 架构，数据搬运消耗只是采用通用处理器基于 Cache 层次数据搬运次数的1/30 ~ 1/10，极大限度缩短了数据传输路径长度。

不同数据权值的分块存储，好处有如下两点。首先，避免了不同数据类型混在一块，造成的带宽利用率不高/数据读写效率不高的问题。比如，NBin 以及 NBout 的宽度为 Tn2 Bytes, SB 的宽度为 TnTn2 Bytes. 如果数据存储在一块，当设计为 Tn2 Bytes 的宽度，则SB的值无法一次取出，增加了延迟。当设计为Tn2 Bytes, 会造成很大的带宽浪费，增加了能耗。其次，节省了解决冲突问题所需要的消耗。为了降低延迟，当数据不加区分存储在 Cache 中，Cache端口带宽必须设计为TnTn*2 Bytes，则Cache的面积太大，为了解决冲突，需要增加更多的判断逻辑，会增加功耗或者延迟，降低了神经网络运算效率。

旋转Buffer设计，软件神经元复用硬件神经元，支持任意规模神经网络

为了解决软件神经元复用硬件神经元，将 NBin Buffer 设计成了一个旋转Buffer，神经网络各层的输入权值在Buffer中进行分块存储，使用完毕即覆盖。则随着神经网络层次深度的增加，NBin Buffer也有能力处理。通过复用硬件神经元的方式，使得寒武纪神经网络协处理器可以支持任意规模的深度学习算法。

线性插值实现传输函数，高可配置性

NFU运算单元为三层设计，第一层为突触/神经元权值地乘法操作，第二层为加法树，实现部分和。第三层为传输函数地实现，通过线性插值的方式实现，因而可以实现诸如sigmoid的各种非线性传输函数。这样的分层次运算单元结构，通过指令的配置，可以模拟 MLP, CONVOLUTION, POOLING, LRN, RBM等各种形态的神经网络传输层，保证了神经网络的高可配置性。

16-bit 定点运算代替320bit 浮点运算

保证精度的同时，降低运算部件的复杂度，降低面积以及功耗。在运算部件的设计中，我们发现，当使用32-bit 的浮点操作与16-bit 的定点操作，对于 UCI 基准数据集，误差率分别为0.0311以及0.0337，误差率相差不大。而16-bit定点乘法器面积和功耗均为32-bit浮点乘法器的近1/7，由此可见，在能够保证正确率的情况下，使用16-bit的定点运算部件，是一个更好的选择。这也在一定程度上降低了我们设计的面积以及功耗。

Summary

看论文过程中大概纪录了一下关键点。感觉这个设计，最大的创新点，就是片山分块存储不同的权值到Buffer中，在保证了带宽使用效率的同时，还避免了考虑Cache冲突的问题。以及旋转Buffer的设计，使得软件神经元可以复用硬件神经元( 这点还没怎么看明白)。文章的核心内容就是，要使得突触权值尽量靠近要使用它的神经元。关于定点运算模拟浮点运算的操作，以及使用线性插值生成各种传输函数这两点，应该是很基本的，自己原来都不了解，还是功力不够。

Neural Network Accelerator I

2014-10-22T00:00:00+00:00

写在前面

从浅层学习到深度学习.

机器学习，即通过算法，使得机器能从大量历史数据中学习规律，从而对新的样本做智能识别或对未来做预测。从1980年代末期以来，机器学习的发展大致经历了两次浪潮：浅层学习（Shallow Learning）和深度学习（Deep Learning）。

80年代末期，用于人工神经网络的反向传播算法（BP算法）的发明，掀起了基于统计模型的机器学习热潮。人们发现，利用BP算法可以让一个人工神经网络模型从大量训练样本中学习出统计规律，从而对未知事件做预测。这种基于统计的机器学习方法比起过去基于人工规则的系统，在很多方面显示出优越性。这个时候的人工神经网络，虽然也被称作多层感知机（MLP），但实际上是一种只含有一层隐层节点的浅层模型。

90年代，各种各样的浅层机器学习模型相继被提出，比如SVM、Boosting、最大熵方法（Logistic Regression）等。这些模型的结构基本上可以看成带有一层隐层节点（如SVM、Boosting），或没有隐层节点（如LR）。这些模型在无论是理论分析还是应用都获得了巨大的成功。相比较之下，由于理论分析的难度，加上训练方法需要很多经验和技巧，所以这个时期浅层人工神经网络反而相对较为沉寂。

2000年以来互联网的高速发展，对大数据的智能化分析和预测提出了巨大需求，浅层学习模型在互联网应用上获得了巨大成功。最成功的应用包括搜索广告系统（比如Google的AdWords、百度的凤巢系统）的广告点击率CTR预估、网页搜索排序（例如Yahoo!和微软的搜索引擎）、垃圾邮件过滤系统、基于内容的推荐系统等。

2006年，加拿大多伦多大学教授、机器学习领域泰斗——Geoffrey Hinton和他的学生Ruslan Salakhutdinov在顶尖学术刊物《科学》上发表了一篇文章，开启了深度学习在学术界和工业界的浪潮。这篇文章有两个主要的信息：1. 很多隐层的人工神经网络具有优异的特征学习能力，学习得到的特征对数据有更本质的刻画，从而有利于可视化或分类；2. 深度神经网络在训练上的难度，可以通过“逐层初始化”（Layer-wise Pre-training）来有效克服，在这篇文章中，逐层初始化是通过无监督学习实现的。

更复杂的模型，更精确的刻画

浅层模型有一个重要特点，就是依靠人工经验来抽取样本的特征，而强调模型主要是负责分类或预测。在模型的运用不出差错的前提下，特征的好坏就成为整个系统性能的瓶颈。因此，通常一个开发团队中更多的人力是投入到发掘更好的特征上去的。要发现一个好的特征，就要求开发人员对待解决的问题要有很深入的理解。而达到这个程度，往往需要反复地摸索，甚至是数年磨一剑。因此，人工设计样本特征，不是一个可扩展的途径。

深度学习的实质，是通过构建具有很多隐层的机器学习模型和海量的训练数据，来学习更有用的特征，从而最终提升分类或预测的准确性。所以“深度模型”是手段，“特征学习”是目的。区别于传统的浅层学习，深度学习的不同在于：1. 强调了模型结构的深度，通常有5层、6层，甚至10多层的隐层节点；2. 明确突出了特征学习的重要性，也就是说，同过逐层特征变换，将样本在原空间的特征表示变换到一个新特征空间，使分类或预测更加容易。在大数据情况下，只有比较复杂的模型，或者说表达能力强的模型，才能充分发掘海量数据中蕴藏的丰富信息。

深度学习带来的硬件门槛问题

对于互联网公司而言，如何在工程上利用大规模的并行计算平台来实现海量数据训练，是各家公司从事深度学习技术研发首先要解决的问题。目前广泛采用的方法，都是搭建 CPU 集群，搭载大数据平台如Hadoop，或者通过GPU运行并行算法，进行处理。由于数据处理的延迟太高，显然不适合需要频繁迭代的深度学习。现有成熟的深度学习训练技术大都是采用随机梯度法（SGD）方法训练的。这种方法本身不可能在多个计算机之间并行。

即使是采用 GPU 进行传统的DNN 模型进行训练，其训练时间也是非常漫长的，一般训练几千小时的声学模型需要几个月的时间。而随着互联网服务的深入，海量数据训练越来越重要，DNN 这种缓慢的训练速度必然不能满足互联网服务应用的需要。Google搭建的DistBelief，是一个采用普通服务器的深度学习并行计算平台，采用异步算法，由很多计算单元独立地更新同一个参数服务器的模型参数，实现了随机梯度下降算法的并行化，加快了模型训练速度。但 Google 通过1.6万片 CPU 核处理器，10亿个内部节点构成的庞大系统，通过1000万帧图片，对其训练了 10 天，才实现了猫脸识别的无监督学习。

还有的公司，利用FPGA的高可配置性，使用FPGA集群来运行神经网络算法。然而，无论是 CPU, GPU, 还是FPGA, 对于大型深度神经网络来说，都价格太昂贵，而且受限于访存瓶颈，训练代价太大。这些方法，都无法满足深度神经网络发展的需要。

而自上世纪80/90年代，神经网络算法萌芽后，也一直有体系结构研究者，试图针对神经网络算法，研制专用协处理器。但从已有成果来看，或者是进行硬件神经元与软件神经元的一一映射，解决了访存的瓶颈，但这样的架构，满足不了深度神经网络随着网络复杂产生的参数爆炸性增长问题。进行网络在芯片上的全定制，对于浅层网络，还有应用的空间，但对于深度神经网络，不堪重负。

CPU/GPU解决方案的劣势

无论 GPU 还是 CPU 集群，都将神经网络从软件层面映射到运算逻辑单元，突触/神经元权值存储于主内存。而深度神经网络，层次多，层与层之间的连接权值较多，逐层运算，需要不断地进行突触/神经元权值的存取与更新。随着神经网络规模的增大，连接权值增多，访存速度成为了制约深度神经网络规模增大的瓶颈。而传统架构从主内存到运算部件的通路设计，中间经过多级Cache，突触与神经元连接权值需要分别从主内存取得，在带来访存速度瓶颈以及延时问题的同时，也会增加更多的功耗。而通用处理器为了满足其通用性，相对神经网络算法来说，会存在太多的冗余单元。这些都不利于使用CPU/GPU来搭建大规模的神经网络运算平台。

通用处理器从核心到主内存通路.

软硬件神经元全映射神经网络协处理器的劣势

在此之前有的神经网络协处理器，针对浅层神经网络定制，同层网络中的软件神经元与硬件神经元多为一一映射的关系，每个神经元用一个逻辑电路表示，突触使用一个锁存器/RAM实现。这样的设计，对于浅层网络，可以带来很大的的加速比。然而，软件神经元无法复用硬件神经元，随着神经元的增长，面积，功耗，延时都会以平方倍的关系增长。这样的协处理器，难以处理深度学习这样的大规模神经网络。下图所示，为软件/硬件神经元一一映射的协处理器结构：

软硬件神经元全映射协处理器.

寒武纪1号神经网络协处理器解决方案

寒武纪1号单核神经网络协处理器，将神经元/突触权值分布式存储于片上 RAM ，优化数据搬运，解决了访存瓶颈问题；并且通过硬件神经元分时复用，能够满足各种规模的深度神经网络。在台积电 65nm 工艺下,寒武纪 1 号主频可达 0.98GHz、性能 452 GOPS、功耗 0.485W、面积约为 3mm2。也就是说，它可以在通用处理器核 1/10 的面积和功耗开销下，达到通用处理器核 100 倍以上的人工神经网络处理速度。即便和最先进的 GPU 相比, 寒武纪 1 号的人工神经网络处理速度也不落下风，而其面积和功耗远低于 GPU 的 1/100。在下一篇文章中，我将就着论文内容，详细介绍寒武纪1号。

Reference.

本文参考了深度学习：推进人工智能的梦想，在此表示感谢。

C++ 参数传递

2014-10-08T00:00:00+00:00

参数传递

这是在前几天看C++ Primer 的第8章时做的笔记，之前大致翻阅过C++ Primer,很多知识点，看过，也就忘记了。最近工程上，接触C++比较多，在做的过程中，再回过头来细细回顾这本经典，很多原来模糊的东西，都变得明晰，而很多所以然，也渐渐知晓。

1. 常量引用

func(const double &ra)

当引用传递，又不想函数改变传进去的值时，可以使用常量引用，这种可以直接传递使用值。
普通值传递相当于是传递数据的副本，即需要复制原始结构的拷贝，会另外生成一份数据，故数据量大时，还是引用传递较为节省内存。

2. 返回引用值

free_throws & accumulate(free_throws & target, const free_throws & source) {
	return target;
}

将引用变量target传入了函数，该变量是可以被修改的，再返回对它的引用，如果函数头没有&，将返回对target指向变量的拷贝。
传统的返回机制，与按值传递函数参数类似，被调用函数返回在函数体内定义的临时变量时，该变量return以后存在一个临时存储单元中，再复制给上层调用函数的接收变量。
当返回为引用时，避免生成临时变量，效率更高。
函数体内定义的为临时变量，应该避免返回对临时变量的引用。当试图返回对临时变量的引用，子函数执行完毕，其声明的临时变量内存将被释放，即试图引用已经释放的内存，会引起程序奔溃。

3.形参实参不匹配

形参实参不匹配：当将int实参传递给const double & 形参时，实参与形参类型不匹配，但是形参可以转变成引用类型（实参），程序将创建一个正确类型的临时变量，使用转换后的实参值来初始化它。然后传递一个指向该临时变量的引用。

4. 基类引用

基类引用可以指向基类对象，也可以指向派生类对象，而无需进行强制类型转换。

5. 对于使用传递的值而不做修改的函数

数据对象很小，如内置，则按值传递
数据对象是数组，只能使用指针传递，使用const指针
数据对象是较大结构，使用const指针或者const引用
类对象，使用const引用，这是C＋＋新增引用特性的原因

6. 对于修改传递数据的函数

内置数据类型，使用指针
数组，使用指针
结构体，使用引用或者指针
类对象，使用引用

7. 带默认值参数的函数

char＊ left(const char *str, int n = 1)

该函数返回一个新的字符串，将其返回类型设置为指向char的指针，希望原始字符串保持不变，加入const限定符，希望n的默认值为1，当传递n值，将覆盖1。
当为某个参数设置默认值，必须将其右边的所有参数都设置默认值。
当被调用函数返回的是指针或者引用，又不是传入的参数引用，则在该函数体内使用new创建了新的内存空间，在使用完返回的引用或者指针时，应该通过返回的指针/引用将其删除。

C++ 数组初始化

2014-10-08T00:00:00+00:00

数组初始化

之前对C++的数组，特别是二维数组初始化，就有点混乱，每次有问题，上网查一下，回头还是一样的状态。前段时间刷Leetcod，做Palindrome Partitioning时，顺便查资料做了一个总结，方便以后查阅。

1. int **ptr 声明指向一群指向整数指针的指针，作类比，即指向地址ptr[N][N]，不知这样类比是否合适？

由于是指针的指针，所以需要两次分配内存才能最终使用。
第一次分配内存： int *ptr = new int[5]，即5个指向N个指针的指针，此时与2等价。
第二次分配内存：循环体内，ptr[i] = new int[N]，分别对5个指针分配内存。
释放内存操作：循环体内delete [] ptr[i]，删除每行的对象，结束循环后， delete [] ptr，释放第一次分配的N个指针内存。
函数参数传递：函数参数传递时，实参直接用ptr，形参用int **f指针。

2. int* ptr[5] 声明5个指向整数指针的指针，作类比，即指向地址ptr[5][N]

分配内存直接按1中第二次分配内存的方式。这种声明方式不能用一个变量len代替5的位置，在编译阶段变量并没有值，无法开辟空间。
内存释放操作与1中一样。

3. int (*ptr)[5] 声明指向一群指向5个整数数组的指针，作类比，即指向ptr[N][5]

如果想分配N个指针内存空间，ptr ＝ (int ()[5]) new int[5N]，则ptr[i]指向第i个5个整数数组的首地址。

4. 直接将二维数组作为参数传递，数组定义：int a[n][n] = {0}

由于编译器寻址为p+i*n+j, 故不能省略第二维的大小，这种情况下n一定要是确定值，不能使用变量
形参：int **a
实参：(int**)a
函数内对数组寻址：((int)array + n*i + j)

Machine Learning Course Summary

2014-10-07T00:00:00+00:00

Where it from

这份summary是研一上学期上卿老师的机器学习时候做的总结。考试前几个人成立了个讨论组，借着CSDN上面的一些博文，比如浙大的研究生Rachel Zhang ，并把课件内容做了一个总结，后来，这份资料就不知道哪里去了。记得当时就是按着课件内容，大略做了一个记录，对Machine Learning一直是云里雾里，直到后来，参加了阿里的大数据竞赛，之后又做了一个基于神经网络模型的时间序列数据分析方面的工作，以及一个kaggle的ctr方面的竞赛，才对ML的模型，特征有了一个相对清晰的认识。有一次尹叔准备阿里实习生的面试，还问我要过这一份资料，直到最近，偶然又从移动硬盘里翻了出来，Machine Learning的道路，要继续往前走，而这，仅仅当作对逝去光阴的缅怀。

Text Classification.

分类所需的类别体系预先设定,且长时间不改变。一篇文档分配给不同类别,置信度不同。人类的判断大多依据经验以及直觉,如何让机器像人类一样自己来通过对大量同类文档的观察来自己总结经验,作为今后分类的依据。这便是统计学习方法,亦是机器学习的基本思想。其中需要一批由人工进行了准确分类的文档作为学习的材料,计算机从这些文档重挖掘出一些能够有效分类的规则,这个过程被称为训练,而总结出的规则集合常常被称为分类器。训练完成之后,需要计算机用该分类器对于从来没有见过的文档进行分类时。

进行文本分类时,不光文本中是包含哪些词很重要,这些词出现的次数对分类也很重要。这一前提使得向量模型(俗称的VSM,向量空间模型)成了适合文本分类问题的文档表示模型。在这种模型中,一篇文章被看作特征项集合来看, 利用加权特征项构成向量进行文本表示,利用词频信息对文本特征进行加权。当特征集过大,容易引起过拟合。通过特征提取或特征重构降维。讨论的几种分类算法:朴素贝叶斯、支持向量机、k-NN、线性回归、逻辑回归。

Naive Bayes

关注文档属于某类别的概率。文档属于某个类别的概率等于文档中每个词属于该类别的概率的综合表达式。而每个词属于该类别的概率又在一定程度上可以用这个词在该类别训练文档中的词频信息来粗略估计,使用朴素贝叶斯算法时,在训练阶段的主要任务就是估计这些值。
[P(C_i|D)=\frac{P(D|C_i)P(C_i)}{P(D)}=\frac{P(w_1|C_i)P(w_2|C_i)…P(w_n|C_i)}{P(D)}]
朴素贝叶斯的缺陷:成立的前提条件是各特征条件独立,使用某个特征值在类别中出现的数目来估计P(w_i|C_i),只有在训练样本非常多的情况下结果才会准确。

k-NN Classification

在kNN算法看来,训练样本代表类别的准确信息(基于实例的分类器),而不管样本是使用什么特征表示的。其基本思想是在给定新文档后,计算新文档特征向量和训练文档集中各个文档的向量的相似度,得到K篇与该新文档距离最近最相似的文档,根据这K篇文档所属的类别判定新文档所属的类别,即该算法不存在真正意义上的训练阶段。kNN唯一的也可以说最致命的缺点就是判断一篇新文档的类别时,需要把它与现存的所有训练文档全都比较一遍,计算代价太大。

Supervised Learning && Unsupervised Learning

监督学习:学习过程中使用的样例是由输入/输出对给出时。最典型的监督学习例子就是文本分类问题,训练集是一些已经明确分好了类别文档组成,文档就是输入,对应的类别就是输出。非监督学习:学习过程中使用的样例不包含输入/输出对,学习的任务是理解数据产生的过程。典型的非监督学习例子是聚类,类别的数量,名称,事先全都没有确定,由计算机自己观察样例来总结得出。。

Overfitting && 线性可分

为了得到一致假设而使假设变得过度复杂称为过拟合。想像某种学习算法产生了一个过拟合的分类器,这个分类器能够百分之百的正确分类样本数据,但也就为了能够对样本完全正确的分类,使得它的构造如此精细复杂,规则如此严格,以至于任何与样本数据稍有不同的文档它全都认为不属于这个类别,即扩展性差。如果存在一个超平面能够正确分类训练数据,并且这个程序保证收敛,这种情况称为线形可分。如果这样的超平面不存在,则称数据是线性不可分。过拟合解决办法:减少特征数量,可以选用模型选择法;正则化,即保留所有特征,但降低参数值的影响。

特征提取算法:开方检验与信息增益

在特征提取时,选择相关性较大的量，可以通过开方检验或者计算信息增益
开方检验 (\sum_{i=1}^n\frac{(x_i-E)^2}{E}) ,小于事先设定的阀值,则假设成立,否者,假设不成立。
信息增益,信息熵的定义: (H(X)=-\sum_{i-1}^nP_i\log_2P_i \qquad H(C|X)=\sum_{i=1}^{n}P_iH(C|X=x_i))

单一参数线性回归

考虑用一条过原点的直线去拟合采样点,(Y=W^TX),未知参数w取什么值可以使得拟合最好,这是一个最小二乘法拟合问题。目标是使(\sum(Y_i^*-Y_i)^2) 最小。通过样本观察值去估算最好的W,有MLE和MAP两种方法。通过求偏导可求得最好的W.

多项式拟合

拟合函数：(Y(X,W)=\sum_{j=0}^{M}W_jX^j)
目标函数：(E(W)=0.5\sum_{i=0}^N{y(x_n,w)-t_n}^2)
过拟合：曲线和采样观察点拟合的很好但是却偏离了整体,称为过拟合,即对于多项式, 阶数越大,对采样点拟合越好,但是对噪声越敏感。而我们的终极目标是对于给定的新数据,能够做出精确的预测,应该避免过拟合。随着拟合多项式阶数的增大,训练误差减小,而测试误差先减小,后增大。对于过拟合,若增加训练样本,可以得到缓解。

正则化：最小二乘法与MLE是一致的,采用贝叶斯方法,可以避免过拟合现象,由于有效参数个数可以随着数据集的大小动态调整。从最小二乘法的角度,为了解决过度拟合的问题,我们可以改变优化目标, 加入正则化,限制W的值过大 [E(W)=0.5\sum_{i=0}^N(y(x_n,w)-t_n)^2+0.5\lambda

]

最小二乘法求解,即直接由数学公式求解, (\theta=(X^TX)^{-1}X^TY)

多元线性回归

输入为向量(包含多个特征分量),假如知道加在每个数据点上的噪声的方差,可以由MLE估计W
假定 [Y_i~N(\omega x_i,\delta_i^2)] ，求[\mbox{argmax(MLE)=argmin}\sum_{i=1}^R\frac{(y_i-\omega x_i)^2)}{\delta_i^2}]

逻辑回归

逻辑回归模型,是一个非线性函数,sigmoid函数,可以轻松处理0/1分类问题如果直接应用线性回归来拟合逻辑回归数据,就会形成很多局部最小值。是一个非凸集,而线性回归损失函数是一个凸函数,即最小极值点,即是全局极小点。模型不符。若采用逻辑回归的损失函数,损失函数就能形成一个凸函数。在线性回归中,若使模型选择与测量数据最接近,则其概率积最大,则形成一个极大似然估计,推导即得平方和最小公式;而逻辑回归采用对数形式。

正则化损失函数

线性回归： [J(\theta)=\frac{1}{2m}[\sum_{i=1}^{m}(h_{\theta}(x^{(i)})-y^{(i)})^2+\lambda\sum_{j=1}^{n}\theta_j^2]]
逻辑回归：[J(\theta)=-\frac{1}{m}[\sum{i=1}{m}y^{(i)}\log{h_{\theta}(x^(i))}+(1-y^{(i)})(1-y^{(i)})\log{(1-h_{\theta}(x^{(i)}))}]+\frac{\lambda}{2m}\sum_{j=1}^{m}\theta_j^2]
对损失函数正则化处理,相当于加上一个奥卡姆剃刀,把原本复杂的系数变得简单,解决由于维数增加导致的系数膨胀问题。
正则化,即给参数加惩罚项,当给不需要的参数加大的惩罚项时,为求使得损失函数最小的参数,则惩罚项大的参数将趋于0.从贝叶斯估计的角度来看,正则化项对应于模型的先验概率。可以假设复杂的模型有较大的先验概率,简单的模型有较小的先验概率。

模型选择

bias:多次训练所得的曲线的均值与实际最佳拟合情况之间的差值。
variance:多次训练所得的曲线与实际最佳拟合情况之间的差值,即方差。
欠拟合时,偏差大,即high bias,训练误差大,测试误差大;过拟合时,方差大, 即high variance,训练误差小,测试误差大(测试误差是个先减小后增大的过程)。
variance:估计本身的方差。bias:估计的期望和样本数据样本希望得到的回归函数之间的差别。
对于正则化中的λ,λ小 ,阶数大,overfit(flexible),对于不同的训练数据集的拟合结果抖动很大,则variance 大,bias是估计均值与实际值期望的偏差,bias小;反之,underfit(stable),对于不同的训练数据集的拟合结果抖动较小,则variance小, 不能很好地进行回归,bias大。
正则化:即为了避免过拟合,在误差函数中引入的一个分量。训练集越小,训练误差越小x,测试误差越大;训练集越大,训练误差越大, 测试误差越小,最终两者趋于相同。
欠拟合时,增加训练集,并不能改善性能;而在过拟合状态,增加训练集, 则可以改善性能。
欠拟合状态可采取的措施:减小λ,增加特征维数,增加多项式特征; 过拟合状态可采取的措施:增大λ,减少特征维数,增加训练样本;

稀疏编码

稀疏编码是一种无监督学习的方法,它用来寻找一组“超完备”基向量来更高效地表示样本数据,该基向量能够有效地找出隐含在输入数据内部的结构与模式, 可用于特征学习。
给定m 张nxn 的images, 希望找到一个字典,或者一组基,φi, 使得每个xi都能分解成 φi的线性组合,¬(x=\sum_{j=1}^{m}a_j\varphi_j),之所以说是sparse,是因为aj中大部分为0,而向量a就是另一种描述image的方式,也称为feature represen- tation的另一种方法,不同于raw pixels.
当引入了超完备基,系数ai不再由输入x唯一决定,因此引入稀疏性来解决由此产生的退化问题。要求系数稀疏,及要求输入向量,只有很少的几个值远大于0.通过给平方和最小加正则来定义代价函数,则可以通过控制惩罚项的参数达到稀疏的目的。

核函数

SVM即使将低维不可分的样本映射到高维空间中后就线性可分,由于最后用训练出来的模型进行分类预测时需要求高维空间中映射特征间的内积,而核函数的功能就是我们计算时不需要考虑高维空间的具体形式,降低了其计算复杂度。通过定义核函数,避免显示地定义基函数(特征映射)。核技巧:寻找一个映射X -> F,使得F维数比X高,因此模型更丰富,算法只需要计算点积,存在一个核函数,在需要计算点积的地方,都用相应核函数值替代。核函数构造方法:可以显示地定义一个特征映射,从而得到核函数的间接定义;或者直接定义,此时需要保证核函数为有效核。直接定义时:多项式核,Sigmoid核,RBF核,指数平方/高斯核,余弦相似度核,字符串核……非线性核有时能极大提升分类器性能,但在训练及预测时训练复杂度高。

SVM

SVM的目的:找到最大间隔的超平面,SVM是一种分类方法,一种监督学习方法

Boosting

一种贪心的自适应基展开算法,将一些弱规则组合得到最后的强规则。每次循环后提高误分样本的分布概率,即提高其在训练样本中的权重,使得下一次循环的弱分类机能够集中处理这些样本。最后将弱分类机进行组合,精度高的所占权重大。
训练误差为0后,测试误差还在减小的现象:训练误差只考虑了分类是否正确,却没有考虑分类的信度,随着循环次数的增加,训练样本的间隔会增大,因此,最后的强分类器越大,间隔可能更大,分类器变得简单,测试误差更小。
优缺点:Boosting亦有可能发生过拟合,但不常出现。分类快,简单且容易实现,没有参数需要调整,灵活度高;但是其依赖于弱分类器即数据,当弱分类器太强或者太弱,都会失败。

最小二乘法

求函数取得极值的方法:最小二乘法,梯度下降法; 其中最小二乘法为纯数学的方法,其推导有一个假设,即估计值与真实值之间的误差假设服从高斯分布。那么若回归所得估计值与真实值并非服从高斯分布,甚至差距很大,则算出来的模型对测试样本的预测则未必正确, 而梯度下降法是按下面的流程进行的:首先对θ赋值,这个值可以是随机的,也可以让θ是一个全零的向量。改变θ的值, 使得J (θ) 按梯度下降的方向进行减少。

线性判别分析LDA与主成分分析PCA

将带上标签的数据点,投影到维度更低的空间中,使得投影后的点,会形成按类别区分,一簇一簇的情况,相同类别的点,将会在投影后的空间中更接近。类内散度矩阵,类间散度矩阵。PCA的输入数据为不带标签的点,是一个预处理的方法,它可以将原本的数据降低维度,而使得降低了维度的数据之间的方差最大。用于特征提取,有最大化方差法,最小化损失法两种,前者类似K-L 算法,提取差异化最大的若干个特征,用于指导分类;而后者寻找D个正交的向量,用于特征重组。

Lasso与岭回归

都是对系数的模进行限制,lasso是对模的长度进行限制,岭回归是对模的平方进行限制。
Lasso: 实际建模过程中通常需要寻找对响应变量最具有解释性的自变量子集―即模型选择,以提高模型的解释性和预测精度。Lasso方法是一种压缩估计。它通过构造一个惩罚函数得到较为精炼的模型,使得它压缩一些系数,同时设定一些系数为零,因此保留了子集收缩的优点。
岭回归:是一种改良的最小二乘估计法,通过放弃最小二乘法的无偏性,以损失部分信息、降低精度为代价获得回归系数更为符合实际、更可靠的回归方法。

Tracking Learning Detection

2014-10-06T00:00:00+00:00

TLD简介.

TLD是一个可以实现在线学习、适应长时追踪的系统，这是英国萨里大学的捷克学生Zdenek Kalal在其攻读博士学位期间提出的一种新的单目标长时间跟踪算法，当时和尹叔两个人，借着作者在2010年发表的CVPR Best Paper “P-N Learning: Bootstrapping Binary Classifiers by Structural Constraints”, ZK关于TLD这个长时追踪系统，发了好几篇顶会，在作者主页上可以寻得。参照CSDN上, zouxy09 等人的博客，借着作者开放的 Matlab && C++ 混编源代码，深入研究了一下这个框架。当时几乎把全部源码注释了一下，本着作者开放源代码的精神，将TLD的实现过程，简要记录一下。

Bounding Box Scan

首先，在第一帧，在图像上圈出要追踪的物体，然后进行全图像的一个扫描，代码中选取了21种尺度，每种尺度均进行上下左右10%的平移，在图像上打网格，用一个6xn的数组存储所有的样本，每一列6个参数，前4个为样本左上角以及右下角的4个坐标，后两个参数分别为样本所处的尺度特征的指针以及该尺度下每一行样本的数目。在我们的实验中，我的摄像头设置为640x480px，圈出的物体为52x132px. 我们一共得到121841个样本。

Generate Features

特征的提取，文章中作者称采用2bitBP进行提取，而代码中，其实是采用了1bitBP，作者文章是10年发的，代码是11年开源的，我猜作者是对精确度与计算复杂度之间做了一个权衡。实际上采用1bitBP进行特征提取，TLD的效果已经非常好。我们知道作者采用的核心分类器，随机蕨，每一层都是一个点对的比较，1bitBP，就是说，每一层取图像上的两个点进行比较，左边点比右边点颜色深，为1，否则为0，这就是一个特征的生成。由下图可以看出，作者提取的点对，都是在同一水平或者同一竖直方向上。在这一步对于1010的随机蕨，用一个4010的数组对特征提取的点坐标进行记录，存储是归一化的值，这样可以很方便地求取在任何尺度下，需要提取点对的具体坐标值。

Generate Features display.

Generate Postive && Negtive Data

接下来，对第一帧图像生成正负样本，首先计算扫描图像所得的每个patch与所选bounding box的重合度，选取重叠度小于0.2且方差比bounding box方差的50\%大的patch，作为负样本，赋予标签0.选取重叠度大于0.6的10样本，作为正样本，将其每个正样本进行20次仿射，正负1\%尺度变换，正负10旋转，方差为5的高斯噪声，一共得到200个正样本，赋予标签1. 这些即是作者文章中所说的，带标签的样本。

Initialize Random Ferns

然后将带标签的正负样本，均分为两份，一份用作训练，一份测试，对随机蕨进行初始化。最终每个patch均会落入某一个叶子节点，用一个10位的二进制码表示。最后统计每个叶子节点的正负样本数以及正样本所占的比率，得到每个叶子节点为正样本的后验概率。再将测试样本依次通过各个fern，对于正样本，若10个fern产生的比率均值小于0.5，则判断错误，给相应的叶子节点正样本数加1，这个过程，可以反复测试，集合分类器的性能便能逐步提高，所以初始化时要花大量的时间，为了性能，在这一部也可以只用正样本进行初始化，毕竟每一帧，都会重复这样的学习过程。

Random Forest.

在扫描图像所得的patch中，找出一个与bounding box重叠度最高的正样本，加上bounding box，在负样本中挑出50个，均进行归一化处理，0均值，单位方差，最终变为255*1的一维列向量，这个归一化处理，我觉得是为了降低光照的影响。将这些样本作为最近邻分类器的样本集，作者文章中提到，之前这个级联分类器只用了方差分类器与随机蕨，后来才在最后级联了一个最近邻分类器，可见这个分类器应该对系统性能，产生了比较大的影响。

Nearest Neighbor Classifier

最近邻分类器的作用，对通过随机蕨且被正确分类的patch，分别求其与最近邻分类器样本集中各个样本之间的归一化互相关系数(NCC)，若与正样本或者负样本之间的NCC均值大于0.95，则将该样本加入该样本集，表明TLD又学到了物体的一个新外观或者是学到了又一个背景图片。随着TLD系统运行时间的增加，这个样本集会逐渐增大，追踪检测性能提高的同时也对机器硬件提出了一个更大的要求。作者代码中计算NCC是调OpenCV的函数。

NCC Calculation.

Tracking and Evaluation

对于追踪，以5px的间隔在第I帧的bounding box中取一个10x10的点阵。通过LK光流法对每个点进行追踪，为每个点建立FB error与NCC，并分别求出FB error与NCC的均值，找出FB error比均值小，NCC比均值大的点。找出的这些点即为置信度高的点，据此在第J帧图像上建立新的bounding box.当FB error的均值大于10px，表明追踪太不稳定，或者当bounding box出了图像边界，追踪失败。当追踪成功，为建立置信度模型，将检测到的bounding box作归一化处理，得到一个255x1的列向量，通过求NCC评估conf1，当conf1较大，则将valid置1，即追踪的bounding box可信。

Detection

对于检测，求图像的积分图与二次积分图，进而求每个patch块的方差，当其比bounding box方差的一半要小，则方差分类器将其过滤掉，这个阶段大约过滤掉一半的patch。对于通过方差分类器的patch，输入集合分类器，对每一棵fern，该patch均会落入一个叶子节点，由WEIGHT数组即可知道其为正样本的后验概率，10个fern求均值，返回给该patch在conf中对应位置。当样本检测完毕，寻找置信度大于阀值的patch返回100个置信度最大的。再将其通过最近邻分类器，找出置信度最大的一个patch，作为检测到的bounding box。

Finding a result

当追踪与检测同时有效，对检测所得的boxes，计算其两两之间overlap之和，根据重叠度对所得boxers进行最近邻聚类，并求每个聚类与追踪所得box的overlap以及置信度均值。找重合度小于0.5且置信度大于追踪所得结果置信度的聚类，即置信度高且远离追踪轨迹的检测结果。如果找到了一个这样的聚类，则对追踪器重新进行初始化，即将该box作为初始的追踪box，该box的置信度作为追踪器的置信度阀值。如果不只找到一个这样的聚类，即图像上有超过一个远离追踪位置的地方，有正样本聚集，找与追踪所得box的overlap超过0.7的检测box，用这些box的平均结果对追踪器进行重新初始化，即将该求得的box位置作为初始的追踪box。

若追踪失败，检测有效，则将检测所得的patch聚类，若只有一个聚类，则用其检测到的bounding box对追踪器进行重新初始化；否则，认为检测失败。

若检测失败但是追踪有效，则进行P-N learning，即对检测器进行更新。首先判断追踪所得box的置信度(tldNN)，当其与所选bounding box的相似度度小于0.5或者其box方差较小，不对检测器更新。否则，以追踪所得box为bounding box，在该帧图像上生成正样本，赋予标签1。与初始化时做法完全相同。仍然是找10个patch，不过仿射变换做10次。在该帧图像上生成负样本，赋予标签0，即与追踪所得box重叠度小于0.2且置信度最高的100个patch。计算追踪所得box与检测所得box的重合度，对重合度小于0.2的，亦作为负样本，对检测器进行更新，与初始化时机制相同。

Summary

以上，就是TLD的具体实现，作者的这个思路，还是很清楚的，主要有两个缺陷，TLD的学习需要时间，物体外观变化剧烈，且不再变回来，TLD将丢失物体，正负样本集是一个逐渐增大的过程，随着追踪的深入，对机器的性能要求很高，并没有一个很好的抛弃已学习到正负样本集的机制。

Sorting algorithm

2014-10-06T00:00:00+00:00

The first article, setup my blog.

之前一直有想法，搭一个独立博客，记录一下学习所得，顺便分享一些旅途中的经历，却一直没有下定决心。想着很多原来学习过程中总结过的东西，后来慢慢都丢了，未免有些遗憾。其实前几年还是挺喜欢写文章的，大都发布在各种社交网络，渐渐荒废。域名挑了个 lambda，一则，这是希腊希腊字母，多年过去，我还是喜欢个性；二则，lambda象形所代表的孤独，低调，正应了了我的追求。是以为域名。

几个概念

内排序：在排序过程中，待排序的所有记录全部被放置在内存中。
外排序：由于排序记录个数太多，不能同时放置在内存中，整个排序过程需要在内外存之间多次交换数据才能进行。
内排序算法分类：(依据排序过程中借助的主要操作)，插入排序, 交换排序, 选择排序, 交换排序。
复杂度为n**2：冒泡排序，简单选择排序，直接插入排序
复杂度为n**3/2：希尔排序
复杂度为nlogn：堆排序，归并排序，快速排序

冒泡排序

排序方法

初始：R[1..n]为无序区
第一趟扫描：依次比较(R[n]，R[n-1])，(R[n-1]，R[n-2])，…，(R[2]，R[1])；对于每对气泡(R[j+1]，R[j])，若 R[j+1].key<R[j].key，则交换R[j+1]和R[j]的内容。第一趟扫描完毕，关键字最小的记录被放在最高位置R[1]上
第二趟扫描：扫描R[2..n]，扫描完毕时，“次轻”的气泡漂浮到R[2]的位置上，最后经过n-1趟扫描，得到有序区R[1..n]
小改进：若在某一趟排序中，未发现气泡位置的交换，则说明排序完毕。为此，可以引入一个布尔量exchange，每次排序开始前，置为false，若排序过程中发生了交换，置为true，每趟排序结束检查exchange，若为false，则终止算法；否则继续。

完整代码:

void BubbleSort(int *list, int len) {
	int i, j, temp;
	int flag = 1;
	for(i = 0; i < len && flag; i++) {
		flag = 0;
		for(j = len; j > i; j--) {
			if(list[j-1] > list[j]) {
				temp = list[j-1];
				list[j-1] = list[j];
				list[j] = temp;
				flag = 1;
			}
		}
	}
}

简单选择排序

排序方法

冒泡排序需要不断交换元素位置，交换函数经常使用，封装成函数调用，函数调用需要压栈弹栈，时间开销大。而选择排序找到合适的关键字再做交换，移动一次就能完成相应关键字排序定位。

完整代码：

void SelectSort(int *list, int len) {
    int i, j, temp, min;
    for(i = 0; i < len; i++) {
        min = i;
        for(j = i+1; j < len; j++) {
            if(list[j] < list[min]) {
                min = j;
            }   
        }       
        if(i != min) { 
            temp = list[i];
            list[i] = list[min];
            list[min] = temp;
        }
    }
}

直接插入排序

排序方法

每次将一个待排序的记录，按其关键字大小插入到前面已经排好序的子序列中适当位置，直到全部记录插入完成。
设数组为a[0..n-1], 初始时，a[0]自成有序区；将a[i]并入a[0..i-1]形成a[0..i]的有序区间。

完整代码：

void InsertSort(int *list, int len) {
	int i, j, temp;
	for(i = 1; i < len; i++) {
		if(list[i] < list[i-1]) {
			temp = list[i];
			for(j = i-1; j >= 0 && list[j] > temp; j--)
				list[j+1] = list[j];
			list[j+1] = temp;
		}
	}
}

希尔排序

排序方法

实质是分组插入排序，又称为缩小增量排序，先将整个待排元素序列分割成若干子序列（由相隔某个增量的元素组成），分别进行直接插入排序。待整个序列中元素基本有序（增量足够小），再对全体元素进行直接插入排序，在元素基本有序的情况下，直接插入排序效率很高。
R = [49, 38, 65, 97, 26, 13, 27, 49, 55, 4]，第一次gap为10 / 2 = 5，将数组分为5组，(49, 13), (38, 27)… 分组后为(13, 49), (27, 38)…
R = [13, 27, 49, 55, 4, 49, 38, 65, 97, 26]，第二次gap为5 / 2 = 2，将数组分为2组，(13, 49, 4…)，(27, 55, 49…)，进行直接插入排序后为：R = [4, 26, 13, 27, 38, 49, 49, 55, 97, 65]
第三次gap = 1，进行最后一次插入排序，得最终序列。

完整代码：

void ShellSort(int *list, int len) {
	int i, j, temp, gap;
	for(gap = len / 2; gap > 0; gap /= 2)
		for(i = 0; i < gap; i++) {
			for(j = gap; j < len; j+=gap)
				if(list[j] < list[j-gap]) {
					int temp = list[j];
					int k = j - gap;
					while(k >= 0 && list[k] > temp) {
						list[k + gap] = list[k];
						k -= gap;
					}
					list[k + gap] = temp;
				}	
		}
}

堆排序

插入元素

void MinHeapFixup(int *list, int i) {
    int j = (i - 1) / 2;
    int temp = list[i];
    while(j >= 0 && i != 0) {
        if(list[j] <= temp)
            break;
        list[i] = list[j];
        i = j;
        j = (i - 1) / 2;
    }
    list[i] = temp;
}

删除元素

按定义，每次都只能删除第0个数据。为了便于重建堆，将最后一个数据的值赋给根结点，然后再从根结点开始进行一次从上向下的调整。调整时先在左右儿子结点中找最小的，如果父结点比这个最小的子结点还小说明不需要调整了，反之将父结点和它交换后再考虑后面的结点。相当于从根结点将一个数据的“下沉”过程。

void MinHeapFixdown(int a[], int i, int n)
{
    int j, temp;
	temp = a[i];
	j = 2 * i + 1;
	while (j < n)
	{
		if (j + 1 < n && a[j + 1] < a[j])
			j++;

		if (a[j] >= temp)
			break;

		a[i] = a[j];
		i = j;
		j = 2 * i + 1;
	}
	a[i] = temp;
}

堆化数组

void MakeMinHeap(int a[], int n) {  
    for (int i = n / 2 - 1; i >= 0; i--)  
        MinHeapFixdown(a, i, n);  
}

排序方法

void MinheapsortTodescendarray(int a[], int n)  
{  
    for (int i = n - 1; i >= 1; i--)  
    {  
        Swap(a[i], a[0]);  
        MinHeapFixdown(a, 0, i);  
    }  
}

归并排序

快速排序

算法实现

从j开始向前找一个比X小或等于X的数。符合条件，挖出再填到上一个坑a[0]，i++; 这样一个坑a[0]就被搞定了，但又形成了一个新坑，这次从i开始向后找一个大于X的数，符合条件，挖出再填到上一个坑中a[8]=a[3]; j–;
重复上面的步骤，先从后向前找，再从前向后找，最后将X填入最后一个坑中。

具体代码实现：

归并过程：

int AdjustArray(int *list, int l, int r) {
	int i = l, j = r;
	int x = list[l];
	while (i < j) {
		while(i < j && list[j] >= x) 
			j--;  
		if(i < j) {
			list[i] = list[j]; 
			i++;
		}

		while(i < j && list[i] < x)
			i++;  
		if(i < j) {
			list[j] = list[i];
			j--;
		}
	}
	list[i] = x;
	return i;
}

递归过程：

void QuickSort(int *list, int l, int r) {
	if (l < r) {
		int i = AdjustArray(list, l, r);
		QuickSort(list, l, i - 1); 
		QuickSort(list, i + 1, r);
	}
}

Reference.

本文参考了结构之法算法之道以及 More Windows Blog 的几篇文章，在此表示感谢。