您的当前位置：首页云计算的关键技术与应用实例

云计算的关键技术与应用实例

来源：智榕旅游

云计算的关键技术与应用实例.txt世上有三种人：一是良心被狗吃了的人，二是良心没被狗吃的人，三是良心连狗都不吃的人。︶﹋丶爱情是个梦，而我却睡过了头﹌第一篇从并行计算到云计算

第1章并行计算与云计算................ 2

1.1 并行计算到云计算的演变...................... 2 1.2 云计算需要定义吗？....... 4

1.3 云计算是否是新瓶装旧酒...................... 5 1.4 MPI与Hadoop，不同学科学者的选择...... 6

1.5 云计算与浏览器..................... 8

第2章MPI并行计算环境的建立..................... 10 2.1 配置前的准备工作.......... 10 2.2 挂载NFS文件系统......... 11 2.3 配置ssh实现MPI节点间

用户的无密码访问.......... 12

2.4 安装MPICH2......................... 12 2.5 建立并行计算环境时的注意事项......... 14

第3章并行计算时代的程序设计方法....... 15

3.1 最简单的并行程序.......... 15

3.2 获取进程标志和机器名......................... 18 3.3 有消息传递功能的并行程序........... 20 3.4 Monte Carlo法在并行程序设计中的应用......... 23 3.5 并行计算中节点间的 Reduce操作. 25

3.6 用MPI的6个基本函数实现 Reduce函数功能................ 28 3.7 计算与通信的并行.......... 30 3.8 节点间自定义复杂数据结构的传输.. 34

3.9 MPI与MySQL数据库的结合应用......... 37

3.10 设计MPI并行程序时的

注意事项..... 41

第4章从MPI走向云计算........... 43 4.1 MPI没有分布式文件系统支持.... 43

4.2 MPI无法应对节点的失效.................. 44 4.3 假如用MPI来构建云计算系统... 44 第二篇云计算的关键技术

第5章Map/Reduce是云计算的选择吗..... 48 5.1 Map/Reduce跨越50年的

历史....................... 48

5.2 实现Map/Reduce的C语言实例. 49

5.3 采用MPI实现并行化的

Map/Reduce功能................ 51 第6章Hadoop技术.. 58

6.1 Hadoop与MPI在数据处理上的对比....................... 58 6.2 Hadoop的主从式结构. 59

6.2.1 主从式文件系统HDFS....... 59 6.2.2 主从式计算系统 Map/Reduce.......... 60

6.2.3 文件分块策略分析.................... 61 6.3 Hadoop文件系统HDFS的前辈GFS......... 64

6.4 构建云文件系统需要解决的关键问题......... 66

6.5 云计算不相信节点服务器.................. 67 6.6 揭密云计算架构下的典型

服务器——Google服务器................. 68 6.6.1 Google服务器概述................... 68 6.6.2 揭开Google服务器的神秘面纱................ 69 6.6.3 Google服务器的配置

情况. 69

6.6.4 Google服务器的性能评测. 73

第7章Hadoop环境的建立.......... 75 7.1 Hadoop配置环境............... 75 7.2 配置ssh实现Hadoop结点间

用户的无密码访问.......... 76

7.3 JDK的安装配置................. 76 7.4 Hadoop的安装配置........ 77

7.5 Hadoop中的Hello World..................... 81 7.6 C语言程序在Hadoop 上运行................ 82 第8章动手做自己的云计算

V0.01系统..... 86

8.1 系统总体分析........................ 86 8.1.1 系统架构................... 86 8.1.2 文件分布式存储流程............. 88 8.1.3 计算与存储的整合流程...... 88

8.2 管理节点程序设计与分析.................. 89 8.2.1 管理节点服务器程序

主函数........................ 90 8.2.2 管理节点各线程函数的设计.. 93

8.2.3 主服务器中其他函数的

设计.. 95

8.3 子节点程序分析................. 98 8.3.1 子节点主函数..... 99

8.3.2 子节点各线程函数设计.. 102

8.4 客户端API设计............. 107

8.4.1 客户端文件的存储................ 108 8.4.2 客户端启动子节点计算... 113 8.4.3 客户端应用的简单实例... 114 8.5 客户端应用开发实例115 第三篇云计算应用实例

第9章基于不可信服务器节点的云计算基础架构....... 118

9.1 云计算基础架构的应用场景........ 118 9.2 云计算基础架构.............. 120 9.3 基于单向指针目录映射的分层

用户隔离...... 121

9.4 云文件系统的物理存储管理........ 123

9.5 云存储的安全级别划分...................... 124 9.6 计算和存储的整合....... 125 9.7 计算和存储的迁移....... 126

9.8 任务的可并行性和分类分析........ 127 9.9 简化的服务器级粗粒度计算和存储资源分配方案... 130

9.10 数据的云计算系统之旅.................. 133 第10章云计算与智能.................... 135 10.1 云计算的智能与人类

智能的比较........................ 135

10.2 云计算提升终端智能......................... 136 10.3 云计算智能与Monte Carlo 方法................ 138

10.4 云计算时代不确定性智能算法

示例——模拟谐振子算法........... 138

10.4.1 简谐振动的描述.................... 139 10.4.2 模拟谐振子算法描述...... 141 10.4.3 模拟谐振子算法流程...... 144 10.4.4 模拟谐振子算法分析...... 146 10.4.5 模拟谐振子算法应用于旅行商问题..... 149

10.4.6 模拟谐振子算法在连续和非线性优化问题中的

应用.......................... 161 10.4.7 模拟谐振子算法的隐含并行性................... 162

10.5 云计算中的人工智能......................... 162 第11章云计算企业之间的竞争性分析................... 164

11.1 云计算技术流派分析.......................... 164 11.1.1 存储型—数据密集云计算平台............ 164 11.1.2 计算型—计算密集云

计算平台............ 165

11.1.3 综合云计算平台.................... 165

11.2 国际云计算公司分析.......................... 165 11.2.1 云计算技术的提出者 Google.................... 166

11.2.2 “端”的霸主微软............. 166 11.2.3 蓝色巨人IBM的蓝云.... 167 11.2.4 云计算的市场先行者 Amazon公司. 168

11.2.5 Salesforce从SaaS走入

云中.......................... 168

11.2.6 热爱白皮书的Sun............... 169 11.2.7 EMC云计算的核心是

虚拟化................... 170

11.2.8 渔翁得利的思科.................... 170

11.3 国内云计算公司分析.......................... 171 11.3.1 拥有基础设施的世纪互联............ 171

11.3.2 阿里巴巴下决心

入云.......................... 172 11.3.3 中国移动的BigCloud...... 172 11.3.4 国产旗帜友友云计算

平台.......................... 173 11.3.5 曙光高性能与云计算...... 173 11.3.6 展览也要云..... 173

11.4 开源云计算平台分析.......................... 174 11.5 国际国内云计算平台提供商

对比研究.. 175

11.6 产业综合分析.................. 179 11.6.1 云计算与网络设备商的关系.......................... 179 11.6.2 云计算与移动通讯运营商的关系..... 180

11.6.3 云计算与服务器提供商的关系..... 180

11.6.4 云计算与应用程序开发商的关系..... 181

后记：未来的计算机—不确定性和

隐含并行计算...................... 182 附录：计算力的标准Linpack测试详细指南..................... 186 参考文献196

面对云计算，有的人越来越糊涂，经常听到有人用云里雾里来形容现在的云计算。云计算系统

确实是一个庞大和综合的系统，即使是国际大公司也不敢贸然进军云计算领域，大量的企业不

是将自己的传统技术优势称为云计算，就是雷声大雨点小的观望。一般开发者更是不适应在机

群的环境下工作，所以本章将用一个简单的例子来展现云计算的基本特点和技术开发方式，我

们并不保证这个系统是一个完善的系统，但它具备了云计算的一些基本特点如计算和存储的整

合、计算向存储的迁移、文件的分布式存储、计算的并行化等，我们对这些功能采用了最简单

的实现方法以使大多数读者能从中体会到云计算技术的核心理念，所以我们命名这个系统为云

计算V0.01，运行环境为Windows。 8.1

系统总体分析

我们进行系统总体结构设计时主要着眼于云计算基本特征的实现，不考虑系统中很多细节性的

要求和高级要求，并采用中等水平的读者能完成的难度设计。

设计需要实现的基本功能如下。（1）向开发云应用的客户提供可以调用的API函数，利用API函数实现对云计算系统的访问。（2）实现分布式的文件存储。

（3）实现计算向存储的迁移，使计算和存储在同一个节点完成，避免数据在网络中的传送。（4）向用户隔离计算的并行性和存储的分布性，用户无需关心系统具体的操作过程。（5）初步实现对数据求和及求最大值的处理，演示云计算的基本特点。读者可以通过增加处理

函数实现更多的计算功能。 8.1.1

系统架构

云计算V0.01系统是一个完全模型化的实验用系统，开发和运行环境为Windows系统，通过对该

系统的学习使读者对云计算技术的基本要点有一定的了解，云计算V0.01将云计算设备分为3个

角色：管理节点、子节点和客户端。管理节点和子节点构成了云计算的服务器端，客户端通过

对API的调用实现对云计算系统的访问，并通过API整合为不同的应用程序。为了简化系统的设

计难度，我们在做云计算V0.01时限定所做的计算任务包括对大数据量数组求和、求最大值

等操

作，读者可通过实际的系统体会存储的分布化与计算的并行化的关系，并理解计算向存储迁移

的作用。云计算V0.01没有实现存储的副本策略，因此暂时不能处理节点失效的问题，这也是为

了降低系统难度的需要。以下的系统架构方法仅供参考和学习，并且不代表我们赞成这一架构，

不同的读者可以设计不同的系统架构。

系统的整个架构如图8.1所示，这种架构方式是一个以客户端为核心的架构方法，系统中的所有

操作指令均由客户端发出，管理节点不和任一子节点作数据和指令的通信，管理节点的作用主

要是维护root.dat和node.dat两个系统文件。root.dat文件存储着现在系统中已注册的用户名及该用

户所对应的文件分块描述文件所在节点的IP地址，系统利用这一文件可实现用户的注册、认证

及用户登录后获得文件分块描述文件所在节点的IP地址。node.dat文件则维护着整个云计算系统

所有子节点的IP地址、端口、最大空间、剩余空间等信息，客户端通过该文件能够获得整个机

群的信息，从而实现向各子节点的直接连接。客户端从管理节点获得了相关的系统信息后将根

据这一信息直接向各个子节点发起连接，完成文件存储及计算的功能，这大大提高了数据传输

的速率，减轻了管理节点的负荷。各用户文件的具体分块和存储方式被系统用该用户的用户名

（username）作为文件名的文件分块描述文件存储于其中的一个子节点，这一子节点的IP可在

root.dat文件中找到。

图8.1 云计算V0.01的系统结构

在云计算V0.01系统中不同角色间存在两类数据的传送：一类是命令数据CMD，管理节点和子

节点通过命令数据判断自己下一步所要完成的任务；一类是信息数据，这类数据是系统要完成

相关任务所需要数据，如系统描述信息、文件信息等，这类数据的数据量相对较大。由于采用

了计算向存储的迁移策略，系统中出现用户文件数据传输的情况很少，这大大提高了系统的运

行效率。

8.1.2

文件分布式存储流程

系统在进行文件存储时先通过客户端连接管理节点，读取root.dat文件数据，检验是否有该用户

存在，并获取用户数据块文件所在节点的IP地址。通过读取node.dat文件从管理节点读取

子节点

的IP地址的列表，根据以上信息完成对数据的分割，启动多线程函数同时连接各子节点将数据

分别保存在各个节点上，最后更新username表以备访问时重新找到文件的分布情况。uesername

文件将被存储于某一节点上，管理节点会根据现有username文件的分布情况向用户分配一个节

点的IP地址存放username文件，文件名就是该用户的用户名，由于用户名在系统中是惟一的，

所以每个用户的username也是惟一的，不会造成混乱，如图8.2所示。图8.2 文件的分布式存储流程 8.1.3

计算与存储的整合流程

如图8.3所示，在云计算V0.01系统中，我们利用获得的用户名、文件名、数据块号以及数据分

块信息文件的IP地址信息，可以惟一地确定任一数据块的位置和文件名，客户端同时向各个子

节点发送启动计算的命令，各节点就地读取数据块本地文件，并对其进行计算，计算完成后发

送回客户端汇总得到最后的结果。图8.3 计算与存储的整合流程

这一计算过程不用移动任何数据，对于数据的处理就在存储数据块的节点完成，系统根据客户

端的指令，将计算迁移到节点上分布式的完成，大大提高了计算效率，避免了数据在网络中的

大量流动所造成的效率下降，对于海量数据来说，这一做法的效果是相当明显的。对于不同的

数据，我们可以定义不同的数据处理方法，从而扩展系统的应用领域。 8.2

管理节点程序设计与分析

管理节点在云计算V0.01系统中只与客户端进行通信，存储系统中的节点信息和用户注册信息，

并不负责任务的调度工作。

在管理节点我们将保存root.dat和node.dat两个系统信息文件。root.dat文件保存用户名及该用户文

件系统所在的子节点的IP地址，采用userInfo数据结构来描述。客户端程序只有获得了子节点IP

地址才能和该子节点直接建立连接获取子节点上的用户存储情况文件，该文件的文件名就是用

户的用户名，通过这一个文件可以知道数据的具体存储情况，从而由客户端直接与数据块存储

节点建立连接。node.dat文件保存了云计算系统的所有子节点的IP地址、总空间和可用空间等信

息，由nodeInfo数据结构来描述。

管理节点各函数调用关系如图8.4所示。

图8.4 管理节点函数调用结构 8.2.1

管理节点服务器程序主函数

管理节点主程序为整个管理程序的主入口，通过4个线程函数来监听并完成客户端所提交的任务。

程序8.1

/*文件名mainsever.cpp*/

// 定义管理节点服务器程序的入口点 void test();

int _tmain(int argc, _TCHAR* argv[])

{

openfile(); //获得root.dat、node.dat的文件指针 test(); //该函数完成对主服务器的配置工作 WSADATA wsa; int ret = 0;

int PORT = 5100; SOCKET s_socket;

SOCKET c_socket;

struct sockaddr_in s_sockaddr;

struct sockaddr_in c_sockaddr;

int c_sockaddr_len = sizeof(c_sockaddr); ret = WSAStartup(MAKEWORD(2, 2), &wsa); if(ret != 0)

{

cout << \"Init WinSock failed:\" << ret << endl;

return 0; }

if((s_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == SOCKET_ERROR) {

cout << \"Create Socket Failed:\" << WSAGetLastError() << endl; WSACleanup(); return 0;

}

s_sockaddr.sin_family = AF_INET; s_sockaddr.sin_port = htons(PORT);

s_sockaddr.sin_addr.s_addr = htonl(INADDR_ANY);

if(bind(s_socket, (SOCKADDR *)&s_sockaddr, sizeof(s_sockaddr)) == SOCKET_ERROR) {

cout << \"bind failed:\" << WSAGetLastError() << endl; closesocket(s_socket); WSACleanup(); return 0;

}

if(listen(s_socket, 5) == SOCKET_ERROR) {

cout << \"Listen Failed:\" << WSAGetLastError() << endl; closesocket(s_socket); WSACleanup(); return 0; }

CMD cmd;

//进入循环接收来自客户端的操作命令cmd while(1) {

c_socket = accept(s_socket, (SOCKADDR *)&c_sockaddr, &c_sockaddr_len); recv(c_socket, (char *)&cmd, sizeof(CMD), 0);//从客户端获取操作命令 SOCKET *tsock = (SOCKET *)malloc(sizeof(SOCKET)); *tsock = c_socket; switch(cmd) {

case USERADD:

_beginthreadex(NULL, 0, &useraddthread, tsock, 0, NULL);//进入增加用户线程 break;

case USERGET:

_beginthreadex(NULL, 0, &usergetthread, tsock, 0, NULL);//进入获取用户信息线程

case USERDEL:

_beginthreadex(NULL, 0, &userdelthread, tsock, 0, NULL);//删除用户，暂未定义

case GETNODE:

_beginthreadex(NULL, 0, &getnodeaddrthread, tsock, 0, NULL);//进入获取节点信息线程 default: break; } }

cin.get(); cin.get(); return 0;

}

//test()函数用于配置各子节点的IP、端口等信息，并将信息存储到管理节点的node.dat文件

void test()

{

cout << \"输入地址信息\" << endl; char ip[16];

int port = 5101;

while(1) {

cout << \"输入IP\" << endl; scanf(\"%s\

if(strcmp(ip,\"0\") == 0) break;

if(nodeadd(ip, port, 1024*10) == 0) cout << \"该记录已经存在\" << endl; }

cout << \"主服务器配置完成\" << endl; }

上面的管理服务器主程序在5100端口监听来自客户端的连接及操作命令，其命令由cmd定义，根据从客户端接收到的命令进入不同的处理线程，在本系统已实现的功能有添加用户功能、获

取用户信息功能和获取节点信息功能。管理节点服务器在启动时就调用test()函数完成对子节点

信息的添加及配置。节点信息被存到node.dat文件，用户信息被存到root.dat。在用户需要进行数

据访问时将读取这两个文件获得当前云计算系统所有已接入系统的子节点，并判断当前用户是

否存在，如存在则返回其文件分配信信息存储位置。

我们要注意的是在现在这个系统中管理节点并不和任何的子节点进行通信，也不直接协调子节

点的工作。用户在获取相关信息后将直接与子节点联系进行操作和数据访问，这样可以大大减

轻主节点的负载。

在管理节点程序中我们定义了一些常用的数据结构主要有userInfo，该数据结构与root.dat文件有

关，包括用户名、用户数据配置文件所在节点的IP地址等信息，因为用户数据文件的信息没有

存放在管理节点而是放在某一个子节点上的，客户端要访问文件数据首先要从管理节点的 root.dat文件中获取该用户数据配置文件所在节点的IP地址，再通过该IP地址获取数据的存储信

息。另一个数据结构是nodeInfo，该数据结构与node.dat文件有关，包括节点IP、端口、节点总

容量、可用空间等，系统中所有节点的相关内容都采用这一数据结构存入node.dat文件。主节点服务器程序部分参数及数据结构的定义如程序8.2所示。程序8.2

/*文件名melem.h*/

#define USERADD 1 //添加用户 #define USERGET 2 //获取用户信息 #define USERDEL 3

#define GETNODE 4 //获取节点信息

#define BLOCKSIZE 1024//定义文件块大小 typedef int CMD; //CMD为命令标识 /*此结构体写入root.dat文件*/ typedef struct {

char user[20]; //用户名

char ip[16]; //用户数据配置文件所在节点的IP地址 int port; }userInfo;

/*此结构体写入node.dat文件*/ typedef struct {

char ip[16]; //存储节点的IP地址 int port; //端口号

int userNum; //用户数目

_off_t totalsize; //节点的总容量 _off_t freesize; //节点的可用空间 }nodeInfo;

typedef struct {

char ip[16];

int port; }nodeaddr; 8.2.2

管理节点各线程函数的设计

管理节点程序的功能基本是由其定义的4个线程函数（其中删除用户未定义）提供的，这些函数

的功能主要是完成用户信息的注册、服务器节点信息的管理和用户数据配置信息的管理。管理

节点可以看作是一个信息的中转站，其自身并不完成任何的数据操作和处理工作。各线程的函数定义如下。 1

．增加新用户线程函数程序8.3

/*文件名mthread.cpp*/

/*增加新的用户，用于新用户注册功能*/ unsigned _stdcall useraddthread(LPVOID p) {

SOCKET* tsock = (SOCKET *)p; struct sockaddr_in taddr; int len = 20;

char* username = (char *) malloc (len * sizeof(char)); recv(*tsock, username, len, 0);//从客户端接收用户名 int result = useradd(username);

send(*tsock, (char *)&result, sizeof(int), 0); closesocket(*tsock); free(username); free(tsock); return 1;

}

函数useraddthread()接收来自于客户端的新注册用户名，调用useradd()函数将用户名及存储该用

户文件信息的节点IP地址写入主节点的root.dat文件，客户端访问该文件可以获得某一用户的文

件存储信息文件所在的子节点IP地址，该文件的文件名就是用户名。 2

．获取用户信息线程函数程序8.4

/*文件名mthread.cpp*/

/*客户端获取用户信息文件*/

unsigned _stdcall usergetthread(LPVOID p) {

SOCKET* tsock = (SOCKET *)p; struct sockaddr_in taddr; int len = 20;

char* username = (char *) malloc (len);

userInfo *user = (userInfo *) malloc (sizeof(userInfo)); recv(*tsock, username, len, 0);

cout << \"接收到的用户名:\" << username << endl;

/*根据用户名读取root.dat中的用户及对应存储文件描述信息的子节点IP*/ if(userget(username, user) == 0) {

cout << \"get false\" << endl; strcpy(user->user, \"0\"); strcpy(user->ip,\"0.0.0.0\"); user->port = 0;

}

cout << \"int_thread:\" << user->user << \" \" << user->ip << \":\" << user->port << endl; send(*tsock, (char *)user, sizeof(userInfo), 0); closesocket(*tsock); free(username); free(user); return 1;

}

函数usergetthread()接收来自客户端的用户名，并在root.dat文件中查找该用户名对应的userInfo

数据结构，并传回给客户端。其中调用userget()函数从root.dat读取与username对应的userInfo信

息。通过调用这一函数客户端可以知道对应用户的文件描述文件存储在哪个子节点上，通过连

接该子节点获取文件的具体存储方式。客户端在调用一这函数后将通过返回的IP地址与存储了

数据分块描述情况文件的子节点进行连接。 3

．文件分块线程函数程序8.5

/*文件名mthread.cpp*/

/*根据node.dat文件中的节点信息，将数据块分配到各节点*/ unsigned _stdcall getnodeaddrthread(LPVOID p) {

SOCKET* tsock = (SOCKET *)p; int blocknum = 0;

nodeInfo *node = (nodeInfo *) malloc (sizeof(nodeInfo)); nodeaddr *naddr = (nodeaddr *) malloc (sizeof(nodeaddr));

recv(*tsock, (char *)&blocknum, sizeof(int), 0); //获取数据块个数 for(int i = 0; i < blocknum; i++) {

memset(node, 0, sizeof(nodeInfo)); memset(naddr,0, sizeof(nodeaddr));

datagetnode(node);//获取该数据块的存储位置 naddr->port = node->port; strcpy(naddr->ip, node->ip);

send(*tsock, (char *)naddr, sizeof(nodeaddr), 0); //该数据块的存储位置发送回客户端 }

closesocket(*tsock); free(node); free(naddr); free(tsock); return 1;

}

函数getnodeaddrthread()接收来自客户端的数据块个数，并为每个数据块分配一个存储节点，数

据块的分配通过调用datagetnode()函数来完成，该函数按剩余空间最大的策略向各数据块分配存

储节点，并将分配结果发送回客户端，由客户端根据接收到的子节点IP直接连接子节点来完成

文件的存储工作，并将存储结果写入子节点中的数据分块描述文件中，以便系统在下次读取时

获得数据的存储情况。 8.2.3

主服务器中其他函数的设计

主服务器其他函数定义。

程序8.6

/*文件名mfile.cpp*/

/*向node.dat文件添加节点信息*/

int nodeadd(char* ip, int port, _off_t totalsize) {

nodeInfo *temp = (nodeInfo *) malloc (sizeof(nodeInfo)); fseek(fp_node, 0, 0); /*判断该节点是否已存在*/

while( fread(temp, sizeof(nodeInfo), 1, fp_node) == 1) {

if(strcmp(temp->ip, ip) == 0 && temp->port == port) {

free(temp); return 0; }

}

strcpy(temp->ip, ip); temp->port = port;

temp->userNum = 0;

temp->totalsize = totalsize;

temp->freesize = totalsize; /*写入node.dat文件*/

fwrite(temp, sizeof(nodeInfo), 1, fp_node); fseek(fp_node, 0, 0); fflush(fp_node); free(temp);

return 1; }

/*分配用户数据描述文件存储节点的IP*/ int usergetnode(nodeInfo *node) {

nodeInfo *temp = (nodeInfo *) malloc (sizeof(nodeInfo)); fseek(fp_node, 0, 0); int num = 0; int no = 0;

/*寻找已分配uesername文件最少的节点IP*/

if(fread(node, sizeof(nodeInfo), 1, fp_node) != 1) return 0;

while( fread(temp, sizeof(nodeInfo), 1, fp_node) == 1) {

++num;

if(temp->userNum < node->userNum) {

*node = *temp;

no = num; } }

memset(temp, 0, sizeof(nodeInfo)); *temp = *node;

temp->userNum += 1;

fseek(fp_node, no*sizeof(nodeInfo), 0);

fwrite(temp, sizeof(nodeInfo), 1, fp_node); fseek(fp_node, 0, 0); fflush(fp_node); free(temp); return 1; }

/*将username及对应存储数据描述文件的节点IP写入root.dat文件*/ int useradd(char* username)

{

userInfo *temp = (userInfo *) malloc (sizeof(userInfo)); nodeInfo *node = (nodeInfo *) malloc (sizeof(nodeInfo)); fseek(fp_user, 0, 0);

while( fread(temp, sizeof(userInfo), 1, fp_user) == 1) /*检测该用户名是否存在*/

if(strcmp(temp->user, username) == 0) {

free(temp);

free(node);

return 0; //该用户名已经存在

}

if(usergetnode(node) == 0)//获取该用户数据描述文件存储节点的IP，通过node参数传出

return -1; //获取节点失败

memset(temp, 0, sizeof(userInfo)); strcpy(temp->user, username); strcpy(temp->ip, node->ip);

temp->port = node->port;

/*将userInfo信息写入root.dat文件，确认数据块描述文件的存储位置*/ fwrite(temp, sizeof(userInfo), 1, fp_user) ; fseek(fp_user, 0, 0); fflush(fp_user); free(temp); free(node);

return 1; }

/*根据用户名，读取root.dat文件中的userInfo数据*/

int userget(char* username, userInfo *user)

{

userInfo *temp = (userInfo *) malloc (sizeof(userInfo)); fseek(fp_user, 0, 0);

while( fread(temp, sizeof(userInfo), 1, fp_user) == 1) if(strcmp(temp->user, username) == 0) {

*user = *temp; return 1; }

return 0; }

/*根据node.dat文件获取系统中的节点信息nodeInfo，并按最大剩余空间优先策略分配给数据块

/*分配完成后更新node.dat文件的内容*/

int datagetnode(nodeInfo *node) {

nodeInfo *temp = (nodeInfo *) malloc (sizeof(nodeInfo)); fseek(fp_node, 0, 0); int num = 0;

int no = 0;

if(fread(node, sizeof(nodeInfo), 1, fp_node) != 1) return 0;

/*首先向剩余空间最大的节点分配数据块*/

while( fread(temp, sizeof(nodeInfo), 1, fp_node) == 1) {

++num;

if(temp->freesize > node->freesize) {

*node = *temp; no = num; } }

memset(temp, 0, sizeof(nodeInfo)); *temp = *node;

temp->freesize -= BLOCKSIZE;

fseek(fp_node, no*sizeof(nodeInfo), 0);

/*将分配后的信息写回node.dat文件，更新文件信息*/ fwrite(temp, sizeof(nodeInfo), 1, fp_node); fseek(fp_node, 0, 0); fflush(fp_node); free(temp); return 1;

}

/*获得rood.dat和node.dat的文件指针*/ /*fp_user指向root.dat文件*/ /*fp_node指向node.dat文件*/ void openfile()

{

if( (fp_user = fopen(\"root.dat\fp_user = fopen(\"root.dat\

if( (fp_node = fopen(\"node.dat\fp_node = fopen(\"node.dat\} 8.3

子节点程序分析

云计算V0.01中子节点主要完成数据的存储及用户文件存储信息的保存，各用户文件存储信息的

文件名为该用户的用户名，子节点程序需要在所有的节点上同时运行。文件的存储和访问由客

户端与子节点直接连接来完成，子节点和管理节点不进行任何的数据通信工作。

各数据块存储的文件名为username_filename_blockNo，即用户名加文件名加数据块号，之间用

下划线连接。

子节点函数调用结构如图8.5所示。图8.5 子节点函数调用结构 8.3.1

子节点主函数

子节点的主程序启动后监听来自于客户端发过来的命令cmd，根据不同的命令进入不同的线程

进行处理。程序8.7

/*文件名blocksever.cpp*/

// blocksever.cpp : 定义控制台应用程序的入口点 int _tmain(int argc, _TCHAR* argv[]) {

WSADATA wsa; int ret = 0;

int PORT = 5101; SOCKET s_socket;

SOCKET c_socket;

struct sockaddr_in s_sockaddr;

struct sockaddr_in c_sockaddr;

int c_sockaddr_len = sizeof(c_sockaddr); ret = WSAStartup(MAKEWORD(2, 2), &wsa); if(ret != 0) {

cout << \"Init WinSock failed:\" << ret << endl;

return 0; }

if((s_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == SOCKET_ERROR) {

cout << \"Create Socket Failed:\" << WSAGetLastError() << endl; WSACleanup(); return 0; }

s_sockaddr.sin_family = AF_INET; s_sockaddr.sin_port = htons(PORT);

s_sockaddr.sin_addr.s_addr = htonl(INADDR_ANY);

if(bind(s_socket, (SOCKADDR *)&s_sockaddr, sizeof(s_sockaddr)) == SOCKET_ERROR) {

cout << \"bind failed:\" << WSAGetLastError() << endl; closesocket(s_socket); WSACleanup(); return 0; }

if(listen(s_socket, 5) == SOCKET_ERROR) {

cout << \"Listen Failed:\" << WSAGetLastError() << endl; closesocket(s_socket); WSACleanup(); return 0; }

CMD cmd;

while(1) {

c_socket = accept(s_socket, (SOCKADDR *)&c_sockaddr, &c_sockaddr_len); recv(c_socket, (char *)&cmd, sizeof(CMD), 0);

SOCKET *tsock = (SOCKET *)malloc(sizeof(SOCKET)); *tsock = c_socket;

/*获取用户文件存储信息，该文件存储于其中一个子节点*/ /*用户根据管理节点提供的IP，直接连接该子节点获取*/ if(cmd == USERINFOGET)

_beginthreadex(NULL, 0, &userinfogetthread, tsock, 0, NULL);

else if(cmd == FILEINFOADD)

_beginthreadex(NULL, 0, &fileinfoaddthread, tsock, 0, NULL);//添加文件存储信息

else if(cmd == STOREBLOCK)

_beginthreadex(NULL, 0, &storedatathread, tsock, 0, NULL); //存储数据块 else if(cmd == GETDATA)

_beginthreadex(NULL, 0, &getdatathread, tsock, 0, NULL); //完成计算工作

else continue; }

return 0; }

子节点的主函数的功能是启动对客户端发出命令的监听和执行，主要是完成4项工作，分别由4

个不同的线程函数来完成。一是获取文件存储信息；二是在文件分块描述文件中添加信息；三

是实现数据块的存储工作；四是在各节点启动计算，完成存储与计算的整合工作。子节点程序要用到的一些常用数据结构定义如下。程序8.8

/*文件名belem.h*/ #ifndef BELEM_H #define BELEM_H

#include \"stdafx.h\" #define USERNAME_LEN 20 #define FILENAME_LEN 64 #define BLOCKNAME_LEN 128 #define LISTLEN 5

#define MAINIP \"127.0.0.1\" #define USERADD 1 #define USERGET 2 #define USERDEL 3

#define USERINFOGET 5 #define FILEINFOADD 6 #define STOREBLOCK 7

#define GETDATA 8 typedef int CMD;

/*fileInfo数据结构为子节点上用户数据文件描述的内容*/ typedef struct {

char filename[FILENAME_LEN]; //文件名 int blockNO; //数据块号

char ip[16]; //数据块存放节点的IP地址 int port; }fileInfo;

/*数据块描述数据结构*/ typedef struct {

int blockNO; char ip[16]; int port; }blockInfo;

typedef struct {

fileInfo *e; int length; int size; }fileInfoList; #endif

8.3.2

子节点各线程函数设计 1

．获取文件存储信息线程函数程序8.9

/*文件名bthread.cpp*/

unsigned _stdcall userinfogetthread(LPVOID p) //获取用户信息文件线程 {

SOCKET* tsock = (SOCKET *)p;

char username[USERNAME_LEN];

recv(*tsock, username, USERNAME_LEN, 0); FILE *fp;

if((fp = fopen(username, \"rb\")) == NULL)

fp = fopen(username, \"wb+\"); //打开用户存储信息描述表 struct _stat info;

_stat(username, &info);//获取文件信息 _off_t filelen = info.st_size;

send(*tsock, (char *)& filelen, sizeof(_off_t), 0); if(filelen > 0) {

char *buf = (char *) malloc (filelen); fread(buf, 1, filelen, fp); send(*tsock, buf, filelen, 0); free(buf); }

closesocket(*tsock); fclose(fp); return 1; }

用户从管理节点获取到数据块描述文件所在的节点IP地址后，即可连接该节点并调用此函数获

取文件内容，由于该文件的文件名就是用户名，所以子节点只要知道了用户名即可知道需要打

开的文件名，该节点通过socket接收用户名就是这个原因。 2

．添加数据块描述信息线程函数程序8.10

/*文件名bthread.cpp*/

unsigned _stdcall fileinfoaddthread(LPVOID p)//添加文件信息线程 {

SOCKET* tsock = (SOCKET *)p; int listlen = 0;

char filename[FILENAME_LEN]; char username[USERNAME_LEN];

fileInfo ftmp;//定义文件信息数据结构 blockInfo btmp; fileInfoList L; initlist(&L);

recv(*tsock, username, USERNAME_LEN, 0); //获取用户名

recv(*tsock, filename, FILENAME_LEN, 0); //获取文件名

recv(*tsock, (char *)& listlen, sizeof(int), 0) //获取文件分块个数，即获取顺序表的长度

for(int i = 0; i < listlen; i++) //获取各个数据块的存储信息与在文件中的顺序号，顺序号以0 开始 {

recv(*tsock, (char *)&btmp, sizeof(btmp), 0);//接收数据块信息，包括块号、存储的IP地

址

strcpy(ftmp.filename, filename); strcpy(ftmp.ip, btmp.ip); ftmp.blockNO = btmp.blockNO; ftmp.port = btmp.port;

addlist(&L, ftmp);//加入顺序表

}

FILE *fp;

if((fp = fopen(username, \"rb+\")) == NULL)

fp = fopen(username, \"wb+\");

fileadd(&L, fp);//将文件存储信息的顺序表添加到数据分块文件中，文件名就为用户名 fclose(fp);

int result = 1;

send(*tsock, (char *)&result, sizeof(int), 0); destroylist(&L); closesocket(*tsock); free(tsock); return 1;

}

添加数据块描述信息线程函数从客户端通过socket接收用户名、文件名及文件分块个数，并将每

个数据块的块号blockNO和存储位置所在IP地址等信息建立顺序表，将此顺序表存到该用户的文

件分块描述文件中。

这一线程函数调用fileadd()函数实现向username添加文件块存储信息，这个信息由fileInfo数据结

构来描述，fileadd()函数定义如下。程序8.11

/*位于文件bfile.cpp中*/

int fileadd(fileInfoList *L, FILE * fp) //fp为username文件指针 {

char filename[20]; fileInfo file;

strcpy(filename, L->e[0].filename);

if(filesearch(filename, fp) == 0) //检测是否有同名文件 filedel(filename,fp); //如有同名文件则删除并覆盖该文件 fseek(fp, 0, SEEK_END);

for(int i = 0; i < L->length; i++) {

file = L->e[i];

fwrite(&file, sizeof(fileInfo), 1, fp); }

return 1; }

/*在username文件中检测是否有同名文件*/ int filesearch(char* filename, FILE *fp) {

fileInfo ftmp;

fseek(fp, 0, 0);

while( fread(&ftmp, sizeof(fileInfo), 1, fp) == 1) if(strcmp(ftmp.filename, filename) == 0) return 0; return 1; }

/*覆盖同名文件*/

int filedel(char* filename, FILE *fp) {

fileInfo ftmp; fseek(fp, 0, 0); while(!feof(fp))

{

fread(&ftmp, sizeof(fileInfo), 1, fp); if(strcmp(ftmp.filename, filename) == 0) {

strcpy(ftmp.filename, \"0\");

fseek(fp, ftell(fp)-sizeof(fileInfo),0); fwrite(&ftmp, sizeof(fileInfo), 1, fp);

fseek(fp,ftell(fp), 0); } }

return 1; }

在文件存储信息的添加过程中我们采用顺序表来维护各数据块的存储信息，因此定义了几个基

本的顺序表操作。程序8.12

/*位于文件blist.cpp*/ /*初始化顺序表函数*/

int initlist(fileInfoList *L)

{

L->e = (fileInfo *) malloc (LISTLEN * sizeof(fileInfo)); if(L->e == NULL) {

printf(\"初始化表，分配内存失败\"); return 0; }

L->length = 0;

L->size = LISTLEN;

return 1; }

/*向顺序表中加入一个数据块存储信息*/

int addlist(fileInfoList *L, fileInfo e) {

if(L->length >= L->size)

{

fileInfo *newbase = (fileInfo *)

realloc

LISTLEN)*sizeof(fileInfo)); if(newbase == NULL) {

printf(\"向表添加数据，增加内存空间失败\"); return 0; }

L->e = newbase; L->size += LISTLEN; }

L->e[L->length] = e; ++ L->length; return 0;

}

/*释放存储空间*/

int destroylist(fileInfoList *L)

(L->size

(L->e,

{

L->length = 0; L->size = 0; free(L->e); return 0; } 3

．保存数据块线程函数程序8.13

/*文件名bthread.cpp*/

unsigned _stdcall storedatathread(LPVOID p)//保存数据块 {

SOCKET* tsock = (SOCKET *)p; int datalen = -1;

int blockNo = -1;

char filename[FILENAME_LEN];

char username[USERNAME_LEN];

recv(*tsock,username, USERNAME_LEN, 0); recv(*tsock, filename, FILENAME_LEN, 0);

recv(*tsock, (char *)& blockNo, sizeof(int), 0); recv(*tsock,(char *)& datalen, sizeof(int), 0); char *buf = (char *) malloc (datalen); recv(*tsock,buf, datalen, 0);

cout << \"storedatathread blockNo:\" << blockNo << endl; cout << \"storedatathread buflen:\" << datalen << endl;

char blockname[BLOCKNAME_LEN]; //数据块文件名

sprintf(blockname, \"%s_%s_%d\生成数据块文件名 FILE *fp;

fp = fopen(blockname, \"w+\"); //打开数据块文件 fwrite(buf, 1, datalen, fp); //写入信息 fclose(fp); free(buf);

closesocket(*tsock); free(tsock); return 1; }

本函数完成对各数据块的存储工作，客户端根据管理节点的数据块存储安排，获取各数据块存

储节点的IP地址，由客户端直接连接各存储节点，调用storedatathread()函数，本函数获取数据

块的所属用户名、文件名、块号、块大小和数据块的具体内容，将数据块存储在当前节点，各

个数据块的命名原则为用户名_文件名_块号（username_filename_blockNO），这样任何一个数据

块将有一个惟一的文件名，该数据块的存储信息同时被写入了数据块描述文件。虽然文件被分

割为多个数据块并存储在不同的子节点上，但由于有数据块描述文件，我们可以在任何时候恢

复并访问该文件。

．获取数据计算结果线程函数程序8.14

/*文件名bthread.cpp*/

unsigned _stdcall getdatathread(LPVOID p)//获取数据计算结果 {

SOCKET* tsock = (SOCKET *)p; int datalen = 0; int blockNo = 0;

_off_t result = 0;

char filename[FILENAME_LEN];

char username[USERNAME_LEN];

recv(*tsock,username, USERNAME_LEN, 0); recv(*tsock, filename, FILENAME_LEN, 0);

recv(*tsock, (char *)& blockNo, sizeof(int), 0); FILE *fp;

char blockname[BLOCKNAME_LEN];//数据块文件名

sprintf(blockname, \"%s_%s_%d\fp = fopen(blockname, \"r\"); //打开本节点上的数据块文件 getresult(&result, fp); //在本节点完成计算工作 fclose(fp);

cout << \"num:\" << result << endl;

send(*tsock, (char *)& result, sizeof(_off_t), 0); closesocket(*tsock); free(tsock); return 1; }

获取数据计算结果线程函数实现了在这个云计算系统中计算与存储的整合演示，我们以对一串

数据求和操作为例，客户端根据数据块存储描述文件的描述向各个存储有数据块的节点发送用

户名、文件名和数据块号，这些信息实际上就确定了一个数据块文件的位置，存储每个数据块

的节点就在该节点就地启动对该数据块的计算工作，完成计算后将自己的局部计算结果发送到

客户端，由客户端完成数据的最后整合工作。这样就避免了大量数据在机群中的移动，大大提

高系统的工作效率，体现了“计算向存储迁移”的云计算理念。这一线程函数中的getresult()函数

就是完成计算工作的函数，根据不同的数据和工作需要我们定义不同的计算函数，这一函数必

需在所有的节点上都要驻留，这样系统才能将计算向该节点迁移。函数getresult()在本例中的定义如下。

程序8.15

/*位于文件bfile.cpp中*/

/*完成对本节点数据块内数据的求和操作*/ int getresult(_off_t *num, FILE *fp) {

fseek(fp, 0, 0); char c; int i = 0; int j = 0; while(!feof(fp)) {

c = fgetc(fp); cout << c; j = 0;

while(!feof(fp)) {

i = 0;

if(c >= '0'&& c <= '9') {

i = atoi(&c); j = 10*j +i; }

c = fgetc(fp); cout << c;

if(c < '0'|| c > '9') break; }

*num += j; }

return 1; }

我们的计算数据是按字符串存储，函数getresult()对本节点数据块实施求和操作，我们同样也定

义其他的数据处理函数，如类似wordcount函数等，通过这一函数我们实现对数据的本地化处理，

每个getresult()函数只处理本节点所存储数据块的数据。这一函数演示了计算向存储的迁移过程。 8.4

客户端API

设计

云计算V0.01为客户端提供了可以访问的API函数，从负载上我们给客户端增加了一些负载，将

文件的分块等工作交给了客户端来完成，只是将计算工作交给子节点来完成。客户端的主要工

作模式是从管理节点读取系统信息，根据这一信息与各子节点直接进行联系完成文件操作及计

算任务。

下面是系统提供的主要API函数，分别在capi.cpp和cfun.cpp中定义。

int cwrite(userInfo user, char* filename, FILE *fp, FILE *fp_tmp); //将数据写入节点

int getdata(char* username, char* filename, FILE *fp_tmp);

int creatconnect(char* ip, int port, SOCKET *csock); //链接服务器，成功返回1，失败返回0

int userregister(char* username); //用户注册

int userlogin(char* username, userInfo *user, FILE *fp); //用户登录 int getuserfile(userInfo user, FILE *fp); //从节点获取用户信息文件 int getuseraddr(userInfo *user); //从主节点获取用户信息文件存放地址 int getnode(nodeaddrList *L, int num); //从主节点分配节点地址

int userinfoadd(fileInfoList *L, userInfo user, FILE *fp_tmp);//用户信息文件中添加一个文件信息

8.4.1

客户端文件的存储

客户端文件的存储是通过调用API函数cwrite()来实现的，它在实际调用时采用如下的形式： cwrite(user, \"data.txt\

函数参数中user为文件所属用户的用户名，data.txt为需要存储的数据文件，fp为该文件的指针，

fp_t是临时文件的指针。F数据结构存储有本次文件分割后所有数据块的存储信息，即username

文件中的信息。函数cwrite()同时把该信息写入子节点和本地的临时文件中。 API函数cwrite()的定义如下。程序8.16

/*保存在文件capi.cpp中*/

/*实现文件分布式存储功能的API*/

int cwrite(userInfo user, char* filename, FILE *fp, FILE *fp_tmp) {

cout << \"In cwrite \" << endl; datalist D;

threadelemlist T; threadlist H;

initdatalist(&D);

initthreadelemlist(&T); initthreadlist(&H);

filecut(&D, fp);//文件分块

blockdatalist(&D, &T, user.user, filename);

HANDLE hd;

for(int i = 0; i < T.length; i ++) {

hd =(HANDLE) _beginthreadex(NULL, 0, &storedatathread, &(T.e[i]), 0, NULL); addthreadlist(&H,hd); }

WaitForMultipleObjects(H.length, H.e, true, INFINITE); fileInfo finfo; fileInfoList F; initFInfolist(&F); /*建立文件分块信息列表*/

for(int i = 0; i < T.length; i++) {

strcpy(finfo.filename, filename); strcpy(finfo.ip, T.e[i].ip); finfo.port = T.e[i].port;

finfo.blockNO = T.e[i].blockNO; addFInfolist(&F, finfo);

}

/*fileInfoList数据结构存储有该用户所有文件的分块信息*/ userinfoadd(&F,user, fp_tmp); destroyFInfolist(&F); destroydatalist(&D);

destroythreadelemlist(&T); destroythreadlist(&H); return 1;

}

文件存储API函数在完成对数据结构的初始化后，首先调用文件分块函数filecut()，分块函数对

fp所指向的文件进行分块，分块数据由datalist数据结构来维护，datalist数据结构描述如下。

程序8.17

/*保存在文件celem.h中*/ /*数据块数据结构*/ typedef struct {

char buf[BLOCKSIZE]; //数据块缓冲区 int datalen; //数据块大小 int blockNO; //块号 }data;

/*数据块顺序表结构*/. typedef struct {

data *e; //数据块结构体数组指针

int length; //数据块个数 int size; //数据块大小 }datalist;

数据存储API调用filecut()函数后，实现将文件的分块信息写入datalist表，分块完成后datalist表的

内容将如图8.6所示。

图8.6 分块完成后datalist表的内容程序8.18

/*保存在文件cfile.cpp中*/ /*实现文件分块功能*/

int filecut(datalist *L, FILE *fp) {

char c;

data d;

memset(&d, 0, sizeof(data));

d.blockNO = 0; //对数据块的块号赋初值 d.datalen = BLOCKSIZE; int i = 0; fseek(fp, 0, 0); /*生成数据块*/

while(!feof(fp)) {

++d.blockNO; //数据块号增加 d.datalen = BLOCKSIZE;

for(i = 0; i < BLOCKSIZE; i ++) {

c = fgetc(fp); d.buf[i] = c; }

/*将分块信息写入datalist表*/ if(feof(fp)) {

d.datalen = i;

adddatalist(L, d); //向数据块表中增加一个数据块记录 break; }

c = fgetc(fp);

fseek(fp, -1L, 1); while(1) {

if(c<'0'&& c> '9') break;

if(d.buf[i-1]<'0'|| d.buf[i-1]> '9')

break; else { --i;

--d.datalen; fseek(fp, -1L, 1); }

}

adddatalist(L, d); }

return 1; }

文件的分割完成后cwrite()函数调用storedatathread（）函数启动向各子节点的写入操作，完成数

据的分块存储。storedatathread()函数的定义如下。程序8.19

/*文件存放位置cthread.cpp*/

unsigned _stdcall storedatathread(LPVOID p) {

threadelem *t = (threadelem *)p; WSADATA wsa;

SOCKET csock; int ret = 0;

ret = WSAStartup(MAKEWORD(2, 2), &wsa); if(ret != 0)

{

cout << \"Init WinSock failed:\" << ret << endl; return 0; }

csock = socket(AF_INET, SOCK_STREAM, 0); CMD cmd;

if(creatconnect(t->ip, t->port, &csock) == 0) {

cout << \"链接节点服务器失败\" << endl; closesocket(csock); WSACleanup(); return 0;

}

cmd = STOREBLOCK;

send(csock, (char *)&cmd, sizeof(CMD), 0); send(csock, t->username, USERNAME_LEN, 0);

send(csock, t->filename, FILENAME_LEN, 0);

send(csock, (char *)&(t->blockNO), sizeof(int), 0); send(csock, (char *)&(t->datalen),sizeof(int), 0);

send(csock, t->data, t->datalen, 0); closesocket(csock); WSACleanup(); return 1; }

函数storedatathread（）向子节点发送的命令cmd为STOREBLOCK，该命令将启动子节点的存储

任务完成数据块的存储工作，同时客户端向子节点发送用户名、文件名等信息。

存储API函数cwrite()在最后调用userinfoadd()函数将文件分块信息写入节点服务器的usrename文

件并写入本地临时文件，从而完成整个文件分布式存储工作。程序8.20

/*文件保存位置cfun.cpp*/

int userinfoadd(fileInfoList *L, userInfo user,FILE *fp_tmp)/*文件分块信息写入节点服务器的

usrename文件并写入本地临时文件*/ {

WSADATA wsa;

SOCKET blocksock;

int ret = 0;

ret = WSAStartup(MAKEWORD(2, 2), &wsa); if(ret != 0) {

cout << \"Init WinSock failed:\" << ret << endl; return 0;

}

blocksock = socket(AF_INET, SOCK_STREAM, 0);

if(creatconnect(user.ip, user.port, &blocksock) == 0) {

cout << \"链接节点服务器失败\" << endl; closesocket(blocksock); WSACleanup(); return 0; }

CMD cmd = FILEINFOADD;

char filename[FILENAME_LEN]; strcpy(filename, L->e[0].filename); int listlen = L->length; blockInfo btmp;

send(blocksock, (char *)&cmd, sizeof(CMD), 0); //发送添加文件信息命令 send(blocksock, user.user, USERNAME_LEN, 0); //发送用户名 send(blocksock, filename, FILENAME_LEN, 0); //发送文件名

send(blocksock, (char *)&listlen, sizeof(int), 0); //发送表长度 for(int i = 0; i < listlen; i++)

{

strcpy(btmp.ip, L->e[i].ip); btmp.port = L->e[i].port;

btmp.blockNO = L->e[i].blockNO;

send(blocksock, (char *)& btmp, sizeof(blockInfo), 0);//向子节点发送数据分块信息 }

int result = 0;

recv(blocksock, (char *)&result, sizeof(int), 0); if(result != 1) {

cout << \"在节点上添加文件信息失败\" << endl; return 0;

}

fileadd(L, fp_tmp);//将文件信息添加到本地临时文件 return 1; }

函数userinfoadd()写入节点上的username文件中的内容如图8.7所示，是各数据块所属文件、存储

位置的IP、文件块号等信息，根据这些信息我们能找到所有该文件的数据块并对其进行计算处理。

图8.7 函数userinfoadd()写入节点上的username文件中的内容 8.4.2

客户端启动子节点计算

客户端启动子节点计算的API函数调用为getdata()，它实际调用时是如下的形式 getdata(username, \"data.txt\

参数username为用户名，data.txt为数据的文件名，fp_t是本地临时保存文件分块信息的文件指针。

函数getdata()的具体定义如下。程序8.21

/*文件保存位置capi.cpp*/

int getdata(char* username, char* filename, FILE *fp_tmp) {

fileInfo file; fileInfoList L; threadlist H; threadelemlist_r T; initFInfolist(&L); initthreadlist(&H);

initthreadelemlist_r(&T);

fileget(filename, &L, fp_tmp); threadelem_r t;

for(int i = 0; i < L.length; i++) {

strcpy(t.username, username);

strcpy(t.finfo.filename, L.e[i].filename); strcpy(t.finfo.ip, L.e[i].ip); t.finfo.port = L.e[i].port;

t.finfo.blockNO = L.e[i].blockNO; addthreadelemlist_r(&T, t); }

HANDLE hd;

for(int i = 0; i < T.length; i++) {

hd =(HANDLE) _beginthreadex(NULL, 0, &getdatathread, &(T.e[i]), 0, NULL); addthreadlist(&H,hd);

}

WaitForMultipleObjects(H.length, H.e, true, INFINITE); destroyFInfolist(&L);

destroythreadelemlist_r(&T); destroythreadlist(&H); return 1; }

其中getdatathread()函数向各节点发送计算指令GETDATA，启动各子节点相应的计算程序工作，

并向各节点发送相应的文件信息。getdatathread()函数定义如下。程序8.22

/*文件存放位置cthread.cpp*/

unsigned _stdcall getdatathread(LPVOID p)//获取计算结果 {

threadelem_r *t = (threadelem_r *)p; WSADATA wsa; SOCKET csock; int ret = 0;

ret = WSAStartup(MAKEWORD(2, 2), &wsa); if(ret != 0)

{

cout << \"Init WinSock failed:\" << ret << endl; return 0; }

csock = socket(AF_INET, SOCK_STREAM, 0);

CMD cmd;

if(creatconnect(t->finfo.ip, t->finfo.port, &csock) == 0) {

cout << \"链接节点服务器失败\" << endl; closesocket(csock); WSACleanup(); return 0;

}

cmd = GETDATA;

_off_t result = 0;

send(csock, (char *)&cmd, sizeof(CMD), 0); send(csock, t->username, USERNAME_LEN, 0);

send(csock, t->finfo.filename, FILENAME_LEN, 0);

send(csock, (char *)&(t->finfo.blockNO), sizeof(int), 0); recv(csock, (char *)&result, sizeof(_off_t), 0); NUM += result; closesocket(csock); WSACleanup(); return 1; }

8.4.3

客户端应用的简单实例

下面的程序是一个以控制台程序实现的客户端系统，它实现了云计算V0.01的基本功能。程序8.23

/*文件名client.cpp*/ #include \"stdafx.h\" #include #include #include #include #include #include \"celem.h\" #include \"cfun.h\" #include \"cglobal.h\" #include \"cthread.h\" #include \"clist.h\" #include \"capi.h\"

#pragma comment (lib, \"wsock32.lib\") using namespace std;

int _tmain(int argc, _TCHAR* argv[]) {

char username[20]; userInfo user;

cout << \"用户注册\\n输入用户名:\" << endl; scanf(\"%s\

cout << username << endl;

FILE *fp_t;

fp_t = fopen(\"temp\打开temp文件 cout << userlogin(username,&user, fp_t) << endl; //产生需要计算的数据并写入文件 FILE *fp;

fp = fopen(\"data.txt\int m = 0;

for(int i = 0; i < 500; i++) {

fprintf(fp,\"%d \m += i; }

fclose(fp);

cout << \"\" << m << endl; fp = fopen(\"data.txt\fseek(fp_t, 0, 0);

cwrite(user, \"data.txt\实现文件的分布式存储 fclose(fp);

/*向各子节点发出计算指令，并汇总结果*/ getdata(username, \"data.txt\/*NUM为求和的结果*/ cout << NUM << endl; cin.get(); cin.get(); return 0; }

这一程序的输出为对所有数据求和的值，系统先由各节点计算存储在自己节点上的数据之和，再发送到客户端完成数据的汇总求和工作，一旦文件已实现分布式的存储，中间将不会有任何

数据文件的传输工作，大大加快了计算的进程，实现了计算向存储的迁移。 8.5

客户端应用开发实例

通过客户端API的支持我们可以验证云计算V0.01的部分功能，在前面的讲述中我们已给出过一

个控制台程序的例子，下面这两个示例是我们做的一个带有用户界面的测试系统，实现对一组

数据的求和及求最大值的操作。数据我们采用自己生成的从0开始的一组连续整数，读者可以采

用自己生成的数据来实验。求最大值的操作我们前面没做讲解，读者可自行设计函数来实现这

一计算功能。相关的运行界面如图8.8和图8.9所示，该界面是采用Visual C++编写的C/S架构的对

话框程序。

图8.8 对20000个数据求和的用户界面

图8.9 在20000个数据中求最大值的用户界面

以上的实例只是我们云计算V0.01的一种应用方式，用户可根据自己的需要增加相应的功能，云

计算V0.01是个很不完善的系统，对于可并行化的问题云计算V0.01的这种做法应该是一种可行

的做法，我们更希望读者能在初步理解其结构的基础上以自己的思想开发出自己的云计算实验

系统，我们并不想以此来禁锢读者的思维。

现在很多的企业已经开始向用户提供云计算服务，一个可以实用化的云计算基础架构需用解决

许多关键的技术，云计算时代IT技术人员需要协调有史以来最大规模的服务器群，并保证整个

系统能够持续不断正常运行。云计算时代用户的大量关键数据、关键业务和关键应用被转移到

云端，因此系统的安全性、高可用性、高性能成为对云计算系统的基本要求。

现在的云计算企业良莠不齐，由于云计算平台技术是一个复杂的系统，技术涉及面相当宽，对

从事云计算研发的企业的技术实力和资金实力有很高的要求，其中真正能在现阶段进行云计算

平台研发的企业并不是太多，现阶段大量号称能提供云计算服务的企业更多的都是将自己原有

的技术和资源中类似云计算的部分称为云计算：如主机租用、网络存储等。

要实现上万台甚至上百万台服务器的协调工作，并向开发者提供丰富的API，满足普通用户和企

业级用户多样化的需求是一件十分困难的问题，所以一个可以实用化的云计算系统是一个复杂

的系统工程，甚至不是一个企业能独立完成的，它需要服务器提供商、存储设备提供商、系统

平台提供商、网络设备提供商、网络带宽提供商、应用开发商共同努力。从Google的经验和未来服务器群的庞大规模来看，将服务器失效作为云计算系统的服务器模型

是符合实际情况的，这种情况下单个服务器可以看作是不可信的节点，在系统设计时必须要将

不可信服务器节点的失效屏蔽在系统之内，不能向开发者和普通用户传递。

本章将以不可信节点为模型介绍一个云计算基础架构的模型，我们并不奢望这一模型是十全十

美的，只是希望能为读者提供一种构建系统的思路。 9.1

云计算基础架构的应用场景

我们要设计云计算的基础架构首先要确认这一系统的应用场景，应用场景的确认实际就确认了

对云计算系统的总体要求。一个可实用的云计算基础架构一定是面向真实场景的架构，云计算

的生命力就是面向用户、以用户为中心，本章中的云计算基础架构就是以实际的云计算中心为

设计场景，这一场景主要包括以下的要点。

（1）节点数量的规模是十分巨大的，单个节点的失效概率比较大，从而整个系统出现某个节点

失效的概率是相当大的。

这一场景要求系统能对所有节点进行有效监控和协调，及时对节点失效故障作出迅速的报警，并将故障的详细情况向管理节点汇报，作出相应的数据和计算迁移操作，保证系统的连续运行。

由于系统节点数量十分巨大，所以系统中出现失效节点的概率是很大的，正如我们前面讲过的

原理如果一个节点在一年内的失效机率为0.1%，即每1 000年出现一次失效，在有10 000个节点

的机群中一年内出现有一个节点失效的概率是1 000%，在有1 000 000个节点的机群中一年内出

现有一个节点失效的概率是100 000%，即一年内会出现1 000个节点失效，这个概率就比较大了，

平均每天有3个节点会失效。其实一个节点一年内的失效机率为0.1%是相当低的了，没有哪台服

务器能运行1 000年才出现失效的，如果这个值加大那每天将有数以百计的节点会失效。（2）云计算中心可能跨区域地在多个中心之间整合。

由于云计算中心可能会位于不同的地方，中心之间的协调和通讯是系统必须要考虑的问题，而

且由于存在跨区域的云计算中心为数据存储提供了一个比跨机柜更为高级的跨区域数据安全保

证级别，对于安全性要求很高的数据可以提供跨区域级的数据备份，从而也就可以在重大节点

故障发生时实现跨区域的计算和存储的迁移，系统可以实现更高的可用性。（3）用户在云计算系统上是要同时从事数据密集和计算密集的工作的，而不是单一的存储或计

算工作。

现有的很多云计算系统未实现数据密集应用和计算密集应用同时支持，而今后云计算系统在面

向多样化的用户时，不同需求的用户将在同一个系统运行和工作，有从事科学计算的、有从事

信息挖掘的、有从事简单办公的、有从事图像处理的，这些应用既有数据密集的也有计算密集

的，还有计算和数据同时密集的，所以云计算系统必须要灵活应对这种多样化的需求。（4）一个云计算基础架构应该具备适应大量不同应用的能力，个人用户、企业级用户、开发者

都能在这个系统中工作。

大量的应用在系统中运行，系统必须要对不同的应用、不同的用户进行有效的软硬件隔离，从

而保证这些业务之间不能出现相互影响，不同用户的数据之间不能相互覆盖。（5）非云计算基础架构的设计者和提供者是不需要了解任何云计算中心的软硬件情况的，他们

只需要对计算和存储资源按需使用，云计算中心对他们来讲只是一个随需应变的资源池。对普通用户映射出按需提供的计算和存储资源池是云计算中的一项核心技术，虚拟化的方法是

解决这一问题的重要手段。

以上应用场景为云计算基础架构的设计提出相应的要求，在设计云计算系统时必须考虑其对应

用场景的适应性。当然我们所提供的应用场景并不是一个非常全面的场景，一个商业级的产品

可能需要考虑更为复杂的场景情况。 9.2

云计算基础架构

根据我们在上面提出的云计算应用场景模型，本节提出一个云计算的基本架构，为读者提供参

考。这一架构的框架如图9.1所示。图9.1 不可信节点的云计算基础框架图在这一框架下我们着力要解决以下几个问题。

（1）不可信节点出现故障时对用户的隔离。

（2）计算与存储的整合，以适应计算密集和数据密集的任务。（3）计算资源和存储资源的虚拟化。

（4）应用层不同应用和不同用户之间数据存储和计算的隔离。

（5）应用层接口和操作系统的提供。

我们曾强调这一云计算系统是基于不可信节点设计的，框架的底层就是由大量的这类节点组成，

各服务器使用现有的主流操作系统，通过各类网络将所有的节点连接起来成为一个庞大的机群

系统，这一部分组成了云计算的物理硬件核心，这一核心的复杂性将通过云计算的软件核心层

对所有用户屏蔽。这些复杂性包括节点故障、网络故障、节点间的调度、负载平衡、数据安全、

数据存储位置、计算位置、各节点的具体配置、系统高可用性的实现等。Google的系统给了我

们良好的示范，我们在搜索框中进行搜索时同时有大量的服务器在为我们工作，但所有服务器

的工作细节我们完全不用知道，我们面对的只是一个简洁的搜索框。

这一框架中计算和虚拟化层实现对计算资源和存储资源虚拟为用户提供弹性化的计算和存储资

源。分布式文件系统为系统提供有副本策略的文件存储服务，文件存储的安全级别可分为：单

机级、跨服务器级、跨机柜级和跨区域级。该文件系统不但为系统提供了一个安全的存储平台，

而且由于其分布式和带副本策略所以可以为计算层提供存储支持，实现计算向存储的迁移，降

低数据在网络间的传递时间，并且在节点失效时可以实现计算和存储同时向备份节点的迁移，从而在节点不可信的情况下实现系统的高可用性。虚拟化层、文件系统层和计算层构成了云计

算基础架构的软件核心层，也是现阶段我们需要主要攻克的技术层，通过软件核心层云计算中

的存储、计算和失效将被全部隔离，应用层将无法“看”硬件层的工作细节，

应用层通过云操作系统和API与云计算基础架构接口，由于其位于硬件核心层和软件核心层之上，不同用户和应用程序在使用该平台时只能“看”到的是一台“可弹性伸缩的巨型计算机”，下

层的软件和硬件运行的细节情况都无法“看”到。

这一框架实现了云计算将所有节点的计算资源和存储资源细节隐藏于云端的功能，体现了云计

算“大象无形”的技术哲学之妙。 9.3

基于单向指针目录映射的分层用户隔离

在一个云计算平台上需要运行大量的应用程序，有大量的用户同时在一个平台上工作，他们的

任务多种多样：有个人存储业务，有企业级存储业务，有企业级应用业务，有SaaS应用业务，有高性能计算业务。这些不同的业务需要在云计算平台上各自独立的运行而不能出现数据和计

算的交叉。由于云计算中心需要面对的应用种类、数量和规模是前所未有的，所以应用及用户

隔离技术是云计算中心需要考虑的问题。

在隔离技术上数据的隔离是最为重要的，我们提出一种目录映射的单向指针分层用户隔离的方

法供读者参考，目录结构如图9.2所示。

图9.2 目录映射的单向指针分层用户隔离

这种目录映射方法采用单向指针树状结构组织，对系统的访问权限与该应用的根目录所处的层

有关，目录节点的上层节点能获得下层节点的指针，而下层节点是不允许反向访问其上层节点

的，同层节点也是不能进行相互访问的，只有文件系统的根目录具有最高的文件访问权限，拥

有根目录权限的应用具备访问系统所有文件的权限，但为了系统数据的安全一般系统根目录权

限不会分配给任何应用使用的。所有的中间节点均只是文件夹的性质，所以只存储下一级的目

录或叶子节点指针而不会真正存储文件在分布式文件系统中的具体存储方式和位置，只有叶子

节点的数据结构才存储某一文件的具体存储位置和方式。在这种情况下每一个应用在进行文件

访问时都会从它权限所在的目录层顺着单向指针直到叶子节点才能获得该文件的存储信息。这种文件目录组织模式有效地实现了用户数据的隔离，这种隔离是由目录映射的单向性完成的，

而不会在数据的物理存储位置进行隔离，不同应用的数据在物理存储位置上是无需采用隔离措

施的。这种模式也为每个应用创建自己的文件隔离提供了方便，因为某个应用被分配到某一目

录层以后它们下级目录可以由自己自由创建并分配给不同子应用使用，由于目录指针的单向

性，

下级目录的应用是不可能逾越该应用的目录结构的。这种自我分层可以一直做下去，这样就为

应用提供企业创造了灵活的用户管理和隔离方法，特别是类似SaaS的应用。

例如，某SaaS应用在云系统中被分配了一个空目录层作为这个SaaS应用的根目录，按指针的单

向性原则这个目录是没有访问该云系统中其他任何应用目录权限的，SaaS应用的根目录所有者

只具有创建和访问虚线内目录的权限。由于SaaS应用需要为每个用户创建存储空间，因此这个

应用会在自己的目录层下创建很多的子目录，而子目录之间也是不能相互访问的，不同的用户

之间数据也是隔离的，但SaaS应用的根目录可以实现对所有子目录的控制和管理。而SaaS应用

的子目录也可根据需要创建自己的下一级目录或叶子节点，只有到了叶子节点才会真正存储文

件在系统中的真实保存位置。这一目录分配过程如图9.3所示图9.3 SaaS应用目录分配机制示例

其他应用的目录分配和管理与此类似，通过单向目录管理机制可以实现多种不同的复杂用户在

系统中和谐共存，使文件系统为云计算提供灵活的存储管理机制，从而适应不同的应用领域。 9.4

云文件系统的物理存储管理

当某一应用在我们的云平台上访问一个文件时，最终必须顺着指针首先访问到目录映射的叶子

节点，才能获得文件的实际存储信息。叶子节点存储着该文件的全部元数据，通过叶子节点的

信息我们可以对存储在云系统分布式文件系统的文件进行访问和处理。在云计算系统中，对于

非常大的文件往往会采用文件分块的方式进行存储，这些大文件会被系统按一定的策略分为若

干个数据块，并将这若干个数据块存储于云系统的不同节点上，相关的存储系统会写入文件目

录树中的某一个叶子节点中，为系统下次对该文件的操作提供信息，这些工作由文件系统中的

文件数据分块及副本备份策略管理来完成，该层向目录树屏蔽具体的文件分块及副本策略，只

是将最后的分配结果写入某一叶子节点中。

前面的目录树并不会实际地存储文件，所有文件真正写入磁盘中是由文件数据分块及副本备份

策略管理来完成的，只有执行了这一层的工作文件才会真正写入机群系统中完成文件的物理存

储过程。文件数据分块及副本备份策略管理层在文件系统中的地位如图9.4所示。图9.4 物理存储管理

对于文件是否分块我们应该作具体的分析，文件大小很小的文件是不需要做分块处理的，这在

前面我们已经讨论过，Google的文件系统GFS和Hadoop的文件系统HDFS由于每个分块比较大，

只适合管理大文件并且对频繁的数据读写支持的很差，事实上无法满足云计算用户多样化的需

求。云计算的文件系统必须要考虑对大文、小文件以及频繁读写的文件同时支持策略。 9.5

云存储的安全级别划分

云计算时代个人和企业所有大量的数据不再存储在自己的硬盘中，大部分数据会通过网络存储

于云计算系统之上，数据的安全性成为了用户非常关心的问题。由于同一个云计算系统中可能

存在不同类型的客户：有企业，有个人。不同用户对自己数据的安全性要求不一，而且支付能

力也不同，所以云计算系统应该为不同用户提供不同级别的数据安全保障，体现云计算按需服

务的理念。

在应用场景中我们已经讲过云计算中的计算节点是不可信的，云计算中心可能是垮区域的，所

以文件数据分块及副本备份策略层还需要完成的任务是对文件的安全级别管理，这里的安全级

别我们暂时不考虑文件加密的问题，只要是考虑节点失效时的安全管理。在文件数据分块及副

本备份策略层的支持下文件分块后会同时在不同的地方保存文件的副本，以使系统在节点失效

时能恢复数据块，并成功重组文件。文件的安全分级方法如图9.5所示。

图9.5 云计算文件的安全分级

图中我们将文件安全级别从低到高分为单机级，跨服务器级，跨机柜级，跨数据中心级。单机

级就是每个数据块只存储在一个服务器上，这意味着只要有任何一个存储有该文件数据块的服

务器失效就会导致文件破坏，我们前面算过这个概率是很大的，所以对于分块存储的文件一般

不会采用这一级别的安全策略，但对于小型文件未实行分块存储的可以考虑采用这种安全级别。

跨服务器级就是每个数据块会在不同的服务器上做备份，当其中一个服务器失效时则自动访问

其他的备份存储块，保证数据的完成性。

跨机柜级就是数据分块及副本备份策略层在备份数据块时会自动将数据块的备份向不同机柜的

服务器存储，以防止机柜失效后破坏数据，由于机柜内的服务器往往会共用网络交换设备，一

旦网络交换设备出现故障有可能会造成整个机柜通讯终断，无法获得数据，跨机柜级的安全

策

略能进一步提高数据的安全性。

跨数据中心级就是数据分块及副本备份策略层会将数据块副本存储在不同地区的数据中心，两

个中心之间可能会相隔千里，这种安全级别的文件在遇到重大灾难和重大事故时也能保证数据

的完整性，这种安全级别数据存储代价较大，一般适用于银行、电信和其他核心数据等相当关

键的数据存储应用上。不同安全级别之间一般情况下是向下继承的，也就是说跨数据中心级的

安全策略同时也会实现跨机柜、跨服务器级，安全级别越高存储代价越高，费用也越高，在云

计算系统中用户可根据自己的情况定制不同级别的存储服务，数据分块及副本备份策略层将根

据定制服务的级别采用不同的策略来存储你的文件。 9.6

计算和存储的整合

存储只是人们对信息的保存，对信息的处理也是云计算时代的一个重要工作，分布式的存储方

式为实现计算向存储的迁移提供了可能。计算和存储的整合是云计算的一个特征，现在云计算

领域有很多的企业将计算与存储隔裂的观点是不妥的，没有实现计算和存储整合的系统原则上

不能称为云计算系统，当然计算和存储可以由不同的企业来提供但不同的企业之间也必须有接

口来整合计算和存储。

在信息时代我们所面对的问题中有数据密集型的问题，有计算密集型的问题，也有数据和计算

同时密集的问题，我们以数据和计算同时密集的问题为例来看在云计算中计算和存储的整合模

式，如图9.6所示。

图中分为两条线，一条中是单纯的数据读取，它的工作过程我们前面已提到：文件读取任务下

达后用户应用首先获得自己在目录结构中的权限并通过单向指针取得对下层目录的管理权，搜

索到某一叶子节点获取具体的文件存储信息，根据这一信息与相关的节点服务器建立数据连接

获得各数据块，按叶子节点的描述，用户应用将文件重组还原完成文件的读取工作。图9.6 计算与存储的整合流程

另外一条线是带计算任务的应用，我们用这种应用来代表数据和计算同时密集的任务：系统首

先获得计算任务，该任务按第一条线文件读取的方法到达叶子节点获得各数据块的存储信息，此时计算任务立即在文件存储服务器就地启动计算工作，完成后只向主节点传送相关结果并不

向主节点传送文件数据块，主节点汇总后生成最后的结果返回用户应用，这一过程中没有了文

件的传送和重组过程，计算和存储都在一个节点上面，实现了计算向存储的迁移，节省了数据

传输的时间，对于大文件这一策略效果非常明显。 9.7

计算和存储的迁移

在基于不可信节点的云计算系统中，我们不但要考虑计算与存储的整合，还必须在节点失效时

考虑计算和存储的迁移。一般的云计算系统（如Hadoop）实现存储的迁移，但对计算和存储同

时迁移则做的不够好，实现计算迁移的基础是数据块必须采用副本策略，这样计算迁移时才能

重新找到所要处理的数据。一般来看信息通过网络进行迁移是比较慢的，而计算的迁移可以由

系统很快完成，在有副本策略的系统中，只需要找到副本所在地，将计算迁移过去就完成了存

储和计算的迁移工作，所以效率非常高。计算和存储的迁移操作如图9.7所示。

在图10.7中机群监控系统不断对各节点的工作状态进行实时的监控，一旦发现有节点失效立即

发出节点失效报警，通过管理节点比对当前的任务列表，如果恰好有一个计算任务在失效节点

上则进行节点失效处理，由于我们在云计算系统的采用了数据块副本策略，管理节点会根据该

节点数据块的副本存储情况按照失效处理策略找到一个存有当前处理数据块副本的节点，并在

该节点上重新启动对该数据块的处理工作，完成存储和计算的同时迁移，这样就不会造成整个

工作任务的重启。整个迁移过程由系统自动完成，用户不用干预。实现存储和计算迁移的基础

是文件的数据块必须有分布式的副本存储策略，没有副本的数据块将无法完成迁移工作。这一

迁移过程可以用图9.8来描述。

图9.7 节点失效时计算和存储的迁移图9.8 计算和数据块迁移

图9.8演示了节点失效后计算和存储的迁移，在上面数据块的迁移过程中数据块并不会在节点间

传递，所有不会占用数据传输时间，而计算的迁移可以很快的完成，因此整个迁移过程是一个

很快的过程，采用这种方法后当节点失效时就不会像MPI一样造成整个任务的终止退出。这种

迁移方法向用户屏蔽了节点的失效现象，从用户看来云计算系统是一个永不失效的大计算机。 9.8

任务的可并行性和分类分析

云计算基础平台在运营的过程中会面向不同的用户提出的不同的存储和计算的需求，有单纯信

息存储需求、有海量数据处理需求、有高性能计算需求、有用户日常信息处理需求、有图形图

像处理需求，是否采用多个节点同时来存储和处理一个问题，我们是需要考虑该任务的可并行

性特性的。如何将串行的程序进行并行化到目前为止还没有找到一个通用的方法，不同的问题

往往需要进行不同的分析，这是并行计算的软件技术一直落后于硬件发展速度的原因，同时由

于没有通用的并行化方法使并行程序能够解决的问题很少，只有少数的一些行业如气象、军事、

石油等领域有专门的计算软件，这造成了并行计算技术一直未能向普通用户普及，这一问题在

云计算技术上同样是存在的，云计算最后的成功将取决于是否满足了普通用户的需求，普通用

户需求的多样性在我们还没有找到串行程序并行化的通用规则时必须要找到另外的解决办法。

由于大多数普通用户对计算的需求相对是很小的，如文字处理、日常办公、Web应用等，这类

问题占用存储资源和计算资源相当的小，用户向云计算系统发起这类服务请求云系统完全没有

必要启用并行计算的方式来处理，根据我们的测试在计算量并不大的时候采用并行计算不但计

算时间不会减少反而由于网络通讯所用时间造成计算时间增加。对于需要较大计算量和存储量

的应用，我们就必须考虑其分布式存储和并行计算的问题了，这也是体现云计算按需提供计算

力和存储力的核心部分。为了很好地分析这类问题我们首先看一看串行程序的并行化技术。串行程序的并行化我们现在还没有找到一个通用的模型来自动解决，对于一个计算过程来讲，循环结构是在程序设计中出现的较多，而且是主要占用系统计算资源的一个结构，往往程序运

行时大部分时间是花在执行循环程序上了，循环次数及嵌套层数的增加会使问题的计算时间按

指数上升，成为程序运行中的主要计算瓶颈。因此研究循环程序的并行化问题是我们在进行程

序并行化工作中最为重要的一个方面。循环结构1

for(i=0; i<1000; i++) { „;

}

循环结构2

for(i=0; i<1000;i++)

for(j=0; j<1000; j++ for(k=0; k<1000; k++) { „; }

上面的两个循环只是由于嵌套层数相差了两层，执行的时间就有可能相差大约100万倍，因此在

进行任务划分时对循环结构的处理是并行化过程中的重要一环。这当中数据之间的相关性对并

行起着重要影响。 1

．数据的相关关系和并行化

我们在研究循环程序的并行化时必需分析计算数据之间的相关性，从而讨论计算执行时的数据

划分方法。只要数据之间存在着相关关系，我们在进行程序并行化时就要特别注意。分析计算

程序中语句间的依赖关系我们称为相关分析（Dependency Analysis），语句间的相关关系可分为

数据流相关、数据反相关、输出相关3种相关关系。如语句Sj 在语句Si

之后执行，其中A、B、C、

D、E为变量，那么这3种相关关系可描述如下。（1）数据流相关。

如某计算问题有以下两个基本语句。 Si

：B = A + C Sj

：D = B*E 其中，语句Si

的左边变量B也出现在语句Sj 的右边变量集内，且Sj 要从Si

取得其计算出的值，则称语句Sj

与语句Si

流相关（Flow-dependent），此时Si 必须在Sj

之前执行并计算出变量B的值之后才能完成语句Sj 的计算工作。

（2）数据反相关。

如某计算问题有以下两个基本语句。 Si

：D=B*E

：B=A+C

以上两个语句执行次序刚好和数据流相关的情况相反，语句Si 的右边变量B也出现在语句Sj 的左

边变量集内，这种情况我们称为语句语句Sj 反相关于语句Si

（Anti-dependent），这种情况下语句 Si

未取用B值之前不能执行语句Sj ，否则B值将发生改变。（3）输出相关。

如某计算问题有以下两个基本语句。 Si

：B = A + B Sj

：B = A*E 这种情况下Si 和Sj

左边的变量一样，则称语句Sj

输出相关（Output-denpendent）于Si

。

考虑到以上3种相关关系，我们得到程序并行化时的一些原则。

（1）数据不存在相关关系的计算可并行执行，也可串行执行。如下面的语句Si 和Sj

，它们的数

据之间无任何相关性，我们可以同时执行这两条计算语句。 Si

：A = C + B Sj

：E = D*F

（2）存在流相关或输出相关的计算不可并行执行。（3）存在反相关的计算，只要保证Si 中的B值先读和Sj

中计算所得到的B值后写，则允许其并行执行。 2

．相关距离与相关方向向量

令a = (a1,a2„,an)和b = (b1,b2

，„,bn)是n层循环内的n个整数下标向量，假定a和b存在数据相关性，则相关距离向量D = (D1,D2,„,Dn)定义为b-a；而相关方向向量d = (d1,d2,„,dn)定义为：例如，如下3层循环嵌套： for i=l1 to u1 do for j=l2 to u2 do

k=l3 to u3 do

A(i+1,j,k-1)=A(i,j,k)+C end for end for end for

其中b=(I+1,j,k-1), a=(i,j,k),则数组A的三维迭代之间的相关距离向量D=(i+1-i,j-j, k-1-k)=(1,0,-1)，