2011 英特尔® 线程挑战赛—

并行语法分析器与公式解释器

邓辉   denghui0815@hotmail.com

由于时间关系，文档写的不是太仔细，抱歉!

 源码下载

问题描述

公式语法分析器和解释器分析连续的输入文字流，检查语法是否正确，根据输入内容分析出其数据结构并解析公式。公式的结果可以存储在变量中，将来的公式可以使用所有未作为公式的某个值从内存中除去的变量。最新多核硬件中的并行处理功能可用于增加语法分析器和解释器的吞吐量。许多热门 Web 浏览器的 JavaScript 引擎中的最新增强功能都需要提高与网络相关的语法分析器的处理速度。

问题描述：

编写一段多线程代码，解释、执行输入语句并生成输出结果。发送到输出结果的文字顺序应与程序输入语句中的顺序一致。您可以并行执行多个语句以增加吞吐量。

注意：关键字和变量区分大小写。行结束符为分号 (;)

下面的示例定义了两行：

var x = 50;

var y = 10;

有效关键字和函数：

注意：公式可以用作参数，而公式结果应为该参数的值。为方便起见，您可以将语法分析器类型映射为许多高级语言中定义的标准类型，例如有符号整数、有符号双精度和字符串（允许的最大长度为 256 个字符）等数字类型。

示例：

output(50 + 20);

string(35 + 32);

string(32 * 12 * multiplier);

使用 var 关键字定义变量后，可以不用关键字将新值赋予该变量。例如：

var a = 50;

a = a + 1;

a = 30;

free(a);

数字以及数字变量的有效算术运算符：

注意：语法分析器将支持从整数到双精度数据类型的隐式转换。

圆括号用于将表达式分组以控制执行顺序。

例如：

var m = ((50 * d) / div) + 25;

应按以下步骤解析：

 (50 * d)

(上一个运算的结果) / div

(上一个运算的结果) + 25

字符串括在双引号 (") 内 — ASCII 码 34、" 或 "

字符串的有效运算符：

注意：不允许使用 {string} + {number} 连接。需要使用 string({number}) 将数字转换为字符串。关键字和例程名称对于变量名称无效。如果发生语法错误，程序应停止执行并显示错误消息指出导致发生语法错误的行号和语句。

有效数学例程/函数：

输入描述：

此程序的输入内容来自命令行上指定的一个文本文件（此文件名作为程序的第一个参数）。文件结束标志着待执行语句的结束。如上所述，解释器可以决定用来解释输入文件中所有语句的最佳机制并生成输出结果。

输出描述：

该程序将解释输入文件中的每个输出函数并为其输出一行。输出内容应包含调用结果，并且输出顺序与输入文件中一致。保证输出结果正确无误最为重要，但高吞吐量和可扩展性作为评分考量因素也很重要。程序的输出结果将储存在命令行上作为第二个参数指定的文本文件中。如果出现语法错误，应按照前面的说明将相应消息写入到输出文件中。

命令行示例： formulaint.exe input.txt output.txt

输入示例文件，input.txt：

var a = 150;

var b = 320;

var c = (a + b) / 20;

var d = ((320 / 2) * 50);

output("Value for a: " + string(a));

output("Value for b: " + string(b)); var message = "a / b = ";

message = message + string(a / b);

var unusedStr = "I will not use this string at all. Will you waste memory on me?";

output(message);

free(message);

free(unusedStr);

free(a);

free(b);

free(c);

free(d);

输出示例文件，output.txt：

Value for a: 150.0000000000

Value for b: 320.0000000000

a / b = 0.4687500000

计时：将使用此程序的总执行时间进行计分。为得到最准确的计时结果，所提交的代码需要包含计时代码并将计算出的总执行时间打印到标准输出，否则将使用外部秒表计时。

串行算法

解释器首先需要完成的功能是分词，分词规则如下：

1.     关键字： var sqrt pow string free output

2.     运算符号： = + - * / ( )；

3.     数字；    

4.     字符串；

5.     变量名；

6.     语句结束符号 ;

7.     分割符号 空格 \t \r \n

而语法分析器需要支持四种语法：

1.     变量定义语句：   var 变量名 = 表达式；

2.     变量赋值语句：   变量名 = 表达式；

3.     变量释放语句：   free（变量名）；

4.     输出语句：       output（表达式）；

在语法解析时将表达式转换为逆波兰表达式。

转换方法

1.     首先构造一个运算符栈，此运算符在栈内遵循越往栈顶优先级越高的原则。

2.     读入一个用中缀表示的简单算术表达式，为方便起见,设该简单算术表达式的右端多加上了优先级最低的特殊符号“#”。

3.     从左至右扫描该算术表达式，从第一个字符开始判断，如果该字符是数字，则分析到该数字串的结束并将该数字串直接输出。

4.     如果不是数字，该字符则是运算符，此时需比较优先关系。

做法如下：将该字符与运算符栈顶的运算符的优先关系相比较。如果，该字符优先关系高于此运算符栈顶的运算符，则将该运算符入栈。倘若不是的话，则将栈顶的运算符从栈中弹出，直到栈顶运算符的优先级低于当前运算符，将该字符入栈。

5.     重复上述操作(3)-(4)直至扫描完整个简单算术表达式，确定所有字符都得到正确处理，我们便可以将中缀式表示的简单算术表达式转化为逆波兰表示的简单算术表达式。

例如：

        a =  ( (b + c) * pow(d, e));

                   变量           运算符                   表达式

a                                       a

a               =                       a

a b             =                       a b

a b             = +                     a b

a b c           = +                     a b c

a b c           =                       a b c +

a b c           = *                     a b c +

a b c           = * pow                 a b c +

a b c d         = * pow                 a b c + d

a b c d e       = * pow                 a b c + d e

a b c d e       = *                     a b c + d e pow

a b c d e       =                       a b c + d e pow *

a b c d e       =                       a b c + d e pow * =

最后是对表达式求值。

热点分析

使用Intel Amplifier分析热点，结果如下：

结果表明，表达式求值函数与变量取值函数占用的时间较大。

并行算法

由于表达式包含输入和输出，如果表达式的输入没有交集时，这些表达式可以并行求值。所以可以分析表达式的输入，根据依赖关系激活表达式，已求值的表达式输出更新未求值表达式的输入。当一个未求值的表达式所有输入均已更新，则将其加入到待求职表达式队列中。利用多个线程并行对待求值表达式的求值运算。        

使用Intel Amplifier分析Concurrency，结果如下：

邓辉   denghui0815@hotmail.com

 源码下载

问题描述

给定一个整数尺寸的矩形区域，此区域可以再细分为多个方格，同样也是整数尺寸。此过程称为拼贴矩形。 对于这种用方格拼成的矩形，我们可以使用一系列分组的整数对拼贴进行编码。 从给定矩形水平方向的上方开始，从左向右、从上向下“读取”方格。 用括号将处于相同水平（位于拼贴矩形顶部）的方格的侧面长度组合到一起，然后按从左向右的顺序列出

例如，4x7 矩形将按以下方式拼贴…

 _ _ _ _ _ _ _

|         |     |_|

|         |_ _|_|

|         |_|     |

| _ _ _ |_|_ _|

…将编码为 (4 2 1) (1) (1 2) (1)

问题描述：编写一段多线程代码，输入未知数量的有序整数集，并判断其中的一些整数组是否可形成某些用方格拼成的矩形的正确编码。 用于测试的整数集将保存在此程序的命令行上所列的第一个文本文件中。对于发现的所有有效编码，此程序将输出矩形的高度和宽度，以及格式正确的拼贴编码。 输出内容将保存在命令行上所列的第二个文本文件中。

输入描述：此程序的输入内容来自命令行上一个指定的文本文件。 连续行会按顺序对应到矩形的相同可能拼贴。 “0”（零）用于表示拼贴整数集的结束。输入文件中的每个文本行将包含 20 个整数，拼贴的最后一行可能少于 20 个整数，并且会以零结尾。 文件结束标志着拼贴整数集的结束。

输出描述：对于输入文件内的每个可能拼贴整数集，此程序将输出矩形的尺寸和每个矩形的拼贴编码，并将输出结果储存在此程序的命令行上所列的第二个文件中。如果从输入的整数集中得不到可行的编码，则应该打印一条消息说明这种情况。 整数集的输出顺序必须与输入顺序相同。

命令行示例： tiling.exe setsin.txt rectout.txt

输入文件示例，setsin.txt:

4 2 1 1 1 2 1 0

2 1 1 0

17 10 9 5 4 1 2 1 8 1 5 0

36 33 5 28 25 9 2 7 16 0

输出文件示例，rectout.txt:

Set 1

dimensions: 4 x 7

(4 2 1) (1) (1 2) (1)

Set 2

dimensions: 2 x 3

(2 1) (1)

dimensions: 3 x 2

(2) (1 1)

Set 3

Cannot encode a rectangle

Set 4

dimensions: 61 x 69

(36 33) (5 28) (25 9 2) (7) (16)

计时：将使用此程序的总执行时间进行计分。为得到最准确的计时结果，所提交的代码需要包含计时代码并将计算出的总执行时间打印到标准输出，否则将使用外部秒表计时。

串行算法

根据问题描述，我们需要将矩形按读入的顺序，按从左向右、从上向下的规则进行拼贴，如果所有矩形拼贴完成，得到的仍然为矩形，即得到一组合法的编码。

假设所有矩形的面积为nArea,前n个矩形的宽度和为Wn，那么nArea % Wn 必须零，才能可能拼贴出一个宽度为Wn、面积为nArea的矩形。

在进行拼贴时，我们需要记录每个矩形的下边沿，即矩形下边沿的起点和长度（x，y，len）。如果定义边沿到原点的距离为 y * W + x，那么下一个矩形拼贴的位置为到原点距离最小的边沿的起点（用红色标识）。

例如数据：100 150 50 50 100 50 50 50 50 50 0

1.     当n为3时，第一行有3个矩形，那么W = 100 + 150 + 50 = 300；拼贴这三个矩形后得到三个矩形的边沿。

其中红色标识出该边沿到原点的距离最小。

2.     在红色点处拼贴第4个矩形。

3.     在红色点处拼贴第5个矩形。

4.     在红色点处拼贴第6个矩形。

当前边沿（150， 100， 150）与 边沿（150， 250， 50）连续且等高，进行合并得到边沿（150， 100，200）。

5.     在红色点处拼贴第7个矩形。

6.     依次拼贴剩余的矩形。

7.     最终合并后得到一条边沿(200, 0, 300),拼贴结束。

由于本算法需要反复获取到原点距离最小的边沿，那么可以将边沿放入二叉堆，其提取最小值的复杂度为O（logn），可大大提高求解速度。

算法的流程图如下：

核心函数源码：

#define  XCOMPAREEDGE(ValA, ValB) (ValA.nVal64 < ValB.nVal64)

// 二叉堆FixDown

__inline void XFixDown(int i, int nHeap, XEdge* pHeap)

{

     int j = i * 2 + 1;

     if (j + 1 < nHeap && XCOMPAREEDGE(pHeap[j + 1], pHeap[j]) ) ++j;

     while (j < nHeap && XCOMPAREEDGE(pHeap[j], pHeap[i]))

     {

         const __m128i tmp = pHeap[i].m128Val; pHeap[i].m128Val = pHeap[j].m128Val; pHeap[j].m128Val = tmp;

         i = j; j = i * 2 + 1;

         if(j + 1 < nHeap && XCOMPAREEDGE(pHeap[j + 1], pHeap[j])) ++j;

     }

}

// 二叉堆FixUp

__inline void XFixUp(int i, XEdge* pHeap)

{   

     int j = (i - 1) >> 1;

     while(i > 0 && XCOMPAREEDGE(pHeap[i], pHeap[j]))

     {

         const __m128i tmp = pHeap[i].m128Val; pHeap[i].m128Val = pHeap[j].m128Val; pHeap[j].m128Val = tmp;

         i = j; j = (i - 1) >> 1;

     }

}

void XTilingRect(XProblem* pArray)

{

     int*   pRect = pArray->pRect;

     int    nRect = pArray->nRect;

     int    i,j,xs,nHeap = 0;

     uint64 nArea = 0,nRetCnt=0;

     uint32 nW,nH;

     XEdge* pHeap = (XEdge*)scalable_malloc(nRect * sizeof(pHeap[0]) + (nRect + 2) * sizeof(int));

     int*   pCnt = (int*)(pHeap + nRect);

     if(pHeap == NULL) XError("XTilingRect 内存不足!");

     XStringExpand(&pArray->xRet, 32 + nRect * 8);

     XStringAddStr(&pArray->xRet, "Set ", 4);

     XStringAddInt(&pArray->xRet, pArray->nIndex + 1, 0);

     XStringAddStr(&pArray->xRet, "\n", 1);

     // 计算所有矩形的总面积

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

     {

         nArea += (uint64)pRect[i] * pRect[i];

     }

     // 循环ys为的矩形个数

     for(nW = 0, i = 0; i < nRect; ++i)

     {

         nW += pRect[i];

         nH = (uint32)(nArea / nW);

         if((uint64)nW * nH == nArea)

         {

              // 将ys为的边界加入堆

              for(xs = 0, nHeap = 0; nHeap <= i; ++nHeap)

              {

                   pHeap[nHeap].ys = pRect[nHeap];

                   pHeap[nHeap].xs = xs;

                   pHeap[nHeap].len = pRect[nHeap];

                   xs += pRect[nHeap];

                   XFixUp(nHeap, pHeap);

              }

              int nPreY = 0, nCnt = 0, nCur = nHeap;

              pCnt[nCnt++] = 0;

              while(nHeap)

              {

                   // 取出最靠近原点的边

                   XEdge xEdgeCur = pHeap[0];

                   // 将该边从堆中移去

                   pHeap[0] = pHeap[--nHeap];

                   XFixDown(0, nHeap, pHeap);

                   while(pHeap[0].ys == xEdgeCur.ys && pHeap[0].xs == xEdgeCur.xs + xEdgeCur.len)

                   {    // 合并连续的边

                       xEdgeCur.len += pHeap[0].len;

                       // 将该边从二叉堆中移去

                       pHeap[0] = pHeap[--nHeap];

                       XFixDown(0, nHeap, pHeap);

                   }

                   if(nPreY != xEdgeCur.ys)

                   {    // 换行判断

                       pCnt[nCnt++] = nCur;

                       nPreY = xEdgeCur.ys;

                   }

                   // 消除当前边

                   xEdgeCur.len += xEdgeCur.xs;

                   while(xEdgeCur.xs < xEdgeCur.len && nCur < nRect)

                   {    // 将新的边界加入堆

                       pHeap[nHeap].ys = xEdgeCur.ys + pRect[nCur];

                       pHeap[nHeap].xs = xEdgeCur.xs;

                       pHeap[nHeap++].len = pRect[nCur];

                       xEdgeCur.xs += pRect[nCur++];

                       XFixUp(nHeap - 1, pHeap);

                   }

                   if(nHeap == 0 && nCur == nRect)

                   {    // 完成拼接，输出结果

                       ++nRetCnt;

                       XTilingRectOutPutXString(&pArray->xRet, pArray->pRect, nW, nH, pCnt, nCnt - 1);

                       break;

                   }

                   else if(xEdgeCur.xs != xEdgeCur.len)

                   {    // 发生拼接错误

                       break;

                   }

              }

         }

     }

     scalable_free(pHeap);

     if(nRetCnt == 0)

         XStringAddStr(&pArray->xRet, "\nCannot encode a rectangle\n\n", 28);

     else

         XStringAddStr(&pArray->xRet, "\n", 1);

}

热点分析

使用Intel Amplifier分析热点，结果如下：(数据为17sisrs.txt 复制为36192行)

分析结果显示热点处于：

1.      XLoadData_File

// 加载测试数据文件版本

void XLoadData_File(const char* szInput, XProblemAry* pProblemAry)

{

     char szLine[2048] = {0};

     FILE* fp = fopen(szInput, "rb");

     if(fp == NULL) XError("打开输入文件失败!");

     int   nReadSize = 1024;

     XProblem xProblemRead = {0};

     XProblemAryExpand(pProblemAry, 512);

     XProblemExpand(&xProblemRead, nReadSize);

     while(fgets(szLine, sizeof(szLine), fp) != NULL)

     {

         if(xProblemRead.nRect + 20 > nReadSize)

         {

              nReadSize += nReadSize;

              XProblemExpand(&xProblemRead, nReadSize);

         }

         int* pRead = xProblemRead.pRect + xProblemRead.nRect;

         int i,nRead = sscanf(szLine, "%d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d",

                                 pRead, pRead + 1, pRead + 2, pRead + 3, pRead + 4,

                                 pRead + 5,pRead + 6, pRead + 7, pRead + 8, pRead + 9,

                                 pRead + 10, pRead + 11, pRead + 12, pRead + 13, pRead + 14,

                                 pRead + 15,pRead + 16, pRead + 17, pRead + 18, pRead + 19);

         if(pRead[nRead - 1] == 0)

         {

              xProblemRead.nRect += nRead - 1;

              xProblemRead.nIndex = pProblemAry->nProblem;

              XProblemAryExpand(pProblemAry, 8);

              XProblemCopy(&pProblemAry->pProblem[pProblemAry->nProblem++], &xProblemRead);

              xProblemRead.nRect = 0;

         }

         else if(nRead == 20)

         {

              xProblemRead.nRect += nRead;

         }

         else

         {

              XError("错误的数据，不足个整数，且没有结尾!");

         }

     }

     XProblemFree(&xProblemRead);

     fclose(fp);

}

该函数功能为数据加载，通过FILE*访问文件，使用sscan读取数字，效率较低。使用内存映射读取数据可以提高效率。优化后代码如下：

// 加载测试数据内存映射串行版本

void XLoadData_Serial(const char* szInput, XProblemAry* pProblemAry)

{

     // 文件大小

     uint64 nFileSize = 0;

     // 文件映射

     XFILEMAPHANDLE hFileMap = XFileMapOpen(szInput, XFILEMAP_READONLY, nFileSize);

     if(hFileMap == NULL) XError("XFileMapOpen Error!");

     // 读取测试数据的大小

     const char *pInput = (const char*)XFileMapView(hFileMap, XFILEMAP_READONLY, 0, (uint32)nFileSize);

     if(pInput == NULL) XError("XFileMapView Error!");

     int   nReadSize = 1024;

     XProblem xProblemRead = {0};

     XProblemAryExpand(pProblemAry, 512);

     XProblemExpand(&xProblemRead, nReadSize);

     const char *pReadTmp = pInput;

     const char *pReadEnd = pInput + nFileSize;

     while(pReadTmp < pReadEnd)

     {

         xProblemRead.nRect = 0;

         while(pReadTmp < pReadEnd && (*pReadTmp < '0' || *pReadTmp > '9'))  ++pReadTmp;

         while(pReadTmp < pReadEnd)

         {

              if(xProblemRead.nRect + 20 > nReadSize)

              {

                   nReadSize += nReadSize;

                   XProblemExpand(&xProblemRead, nReadSize);

              }

              int  j,*pReadRect = xProblemRead.pRect + xProblemRead.nRect;

              for(j = 0; j < 20; ++j)

              {

                   XREAD_INT(pReadTmp, pReadEnd, pReadRect[j]);

                   if(pReadRect[j] == 0 || pReadRect[j] == -1) break;

              }

              if(j < 20)

              {

                   if(pReadRect[j] == 0)

                   {

                       xProblemRead.nRect += j;

                       xProblemRead.nIndex = pProblemAry->nProblem;

                       XProblemAryExpand(pProblemAry, 8);

                       XProblemCopy(&pProblemAry->pProblem[pProblemAry->nProblem++], &xProblemRead);

                       break;

                   }

                   else

                   {

                       XError("错误的数据，不足个整数，且没有结尾!");

                   }

              }

              else

              {

                   xProblemRead.nRect += j;

              }

         }

     }

     XProblemFree(&xProblemRead);

     XFileMapUnView((void*)pInput, (unsigned int)nFileSize);

     XFileMapClose(&hFileMap);

}

2.     XStringAddInt

功能为输出整数到字符串，采用了sprintf，可通过查表法提高效率。

// 增加整数

void XStringAddInt(XString* pString, uint32 nOut, int nSpace)

{

     char szNum[32];

     sprintf(szNum, nSpace ? "%d " : "%d", nOut);

     XStringAddStr(pString, szNum, strlen(szNum));

}

增加映射表初始化函数，并修改XStringAddInt。

char   g_pNum2String[100000][8];

char   g_pNum2String_Zero[100000][8];

uint8  g_nNumeStringLen[100000];

// 初始化数字到字符串转换表

void XInitNum2StringTab()

{

     cfor(int i = 0; i < 100000; ++i)

     {

         sprintf(g_pNum2String[i], "%d ", i);

         sprintf(g_pNum2String_Zero[i], "%05d ", i);

         g_nNumeStringLen[i] = strlen(g_pNum2String[i]) - 1;

     }

}

// 增加整数

void XStringAddInt(XString* pString, uint32 nOut, int nSpace)

{

     const uint32 nHigh = nOut / 100000;

     if(nHigh)

     {

         XStringAddStr(pString, g_pNum2String[nHigh], g_nNumeStringLen[nHigh]);

         XStringAddStr(pString, g_pNum2String_Zero[nOut % 100000], 5 + nSpace);

     }

     else

     {

         XStringAddStr(pString, g_pNum2String[nOut], g_nNumeStringLen[nOut] + nSpace);

     }

     //char szNum[32];

     //sprintf(szNum, nSpace ? "%d " : "%d", nOut);

     //XStringAddStr(pString, szNum, strlen(szNum));

}

3.     XTilingRect

矩形拼贴算法，使用二叉堆，优化空间较小。

再使用Intel Amplifier分析热点，结果如下：(扩大数据为17sisrs.txt 复制为108576行)

分析各个热点函数后，发现XStringAddStr还有优化空间。因为每次增加的字符串都比较短，所以memcpy的效率较低，改为循环赋值可提高效率。

// 增加字符串

__inline void XStringAddStr(XString* pString, const char* pData, int nLen)

{

     XStringExpand(pString, nLen);

     memcpy(pString->pData + pString->nUse, pData, nLen);

     pString->nUse += nLen;

}

修改后代码：

// 增加字符串

__inline void XStringAddStr(XString* pString, const char* pData, int nLen)

{

     XStringExpand(pString, nLen);

     char * pDst = pString->pData + pString->nUse;

     for(int i = 0; i < nLen; ++i)

     {

         pDst[i] = pData[i];

     }

pString->nUse += nLen;

     //memcpy(pString->pData + pString->nUse, pData, nLen);

}

相同矩形的拼贴，可通过优化算法大大提高效率，修改XTilingRect加入判定和优化代码。

BOOL bEqual = TRUE;

// 判断是否所有矩形尺寸相同

for(i = 1; bEqual && i < pArray->nRect; ++i)

{

     if(pArray->pRect[i] != pArray->pRect[i - 1]) bEqual = FALSE;

}

if(bEqual)

{

     // 循环ys为的矩形个数

     for(nW = 1; nW <= nRect; ++nW)

     {

         nH = nRect / nW;

         if(nW * nH == nRect)

         {

              for(j = 0; j <= nH; ++j)

              {

                   pCnt[j] = nW * j;

              }

              // 完成拼接，输出结果

              ++nRetCnt;

              XTilingRectOutPutXString(&pArray->xRet, pArray->pRect, nW * pRect[0], nH* pRect[0], pCnt, nH);

         }

     }

}

并行算法

由于每个输入文件中存在多个测试数据，在并行对这些测试数据求解时无需考虑数据冲突问题，所以通过cilk_for即可实现并行优化。

for(int i = 0; i < xProblemAry.nProblem; ++i)

{

     XTilingRect(xProblemAry.pProblem + i);

}

利用Cilk优化后代码如下：

cilk_for(int i = 0; i < xProblemAry.nProblem; ++i)

{

     XTilingRect(xProblemAry.pProblem + i);

}

编译后，再使用Amplifier检测Concurrency结果如下：

   算法已经具有良好的并行度,但XLoadData_Serial和XStringFree函数为串行执行，其中XStringFree在XSaveDataAndFree_Serial调用，所以优化IO也变得重要，同样使用cilk_for实现并行版本的加载数据XLoadData_Parallel和保存数据函数XSaveDataAndFree_Parallel。

重新编译后，再使用Amplifier检测Concurrency结果如下：

   目前仅有一个系统函数__security_init_cookie没有并行，其为系统在mainCRTStartup中调用。

性能测试

测试环境：

    Operating System: Windows XP Professional (5.1, Build 2600) Service Pack 3

    Language: Chinese (Regional Setting: Chinese)

    System Manufacturer: Dell Inc.

    System Model: Vostro 1088                     

    BIOS: Phoenix ROM BIOS PLUS Version 1.10 A02

    Processor: Intel(R) Core(TM)2 Duo CPU     T6570  @ 2.10GHz (2 CPUs)

    Memory: 2046MB RAM

    Page File: 908MB used, 3027MB available

    Windows Dir: C:\WINDOWS

    DirectX Version: DirectX 9.0c (4.09.0000.0904)

    DX Setup Parameters: Not found

    DxDiag Version: 5.03.2600.5512 32bit Unicode

测试结果：

问题描述

问题：写一段多线程代码，用来查找在三维空间内相交的线段对。线段的输入文件和输出结果文件将在命令行上指定。

输入格式：输入文件是一个文本文件，它的第一行将包含一个整数 N，表示文件内包含的线段数。后面的 N 行将包含线段的 4 个（可打印）字符名称和用来表示线段两个 (x,y,z) 端点的 6 个整数。其中的前 3 个数字是一个端点的坐标，后 3 个数字是另一个端点的坐标。求解此问题的程序只要能在 32 位平台上正确运行即可满足精度要求。

输出格式：使用某种人类可读的格式。列出所输入线段中的每一对相交线段。如果没有交点，则打印一条消息说明无交点。

有关本问题的详细情况，请进入本次线程挑战赛，获取更多信息。

对线段求交问题的分析和求解

有关此问题的参赛源代码，请点击这里下载。

串行算法

在网络上查找了一些线段相交的资料，很多都是二维线段相交的算法，从《计算几何实验：Balaban线段求交算法(测试版)》一文中了解到，目前二维直线相交的最优算法是Balaban提出的分治算法，而比较简单实用的是Bentley & Ottmann的扫描线算法。

扫描线算法实现起来相对比较简单，只需要将所有直线按X坐标排序，然后依次对X有重合的线段进行跨立测试。这个算法可原封不动的推广到三维。

在判断做跨立测试前先根据两条直线决定的立方体是否有重叠，进行部分过滤。如果立方体没有重叠，那么这两条直线肯定不相交。然后选择XY平面做跨立测试，如果是跨立的，可进一步加入三维Z坐标做判断。

x0 + x1 * t1 = x2 + x3 * t2

y0 + y1 * t1 = y2 + y3 * t2

z0 + z1 * t1 = z2 + z3 * t2

三维直线若相交，那么上面三方程组成的方程组就一定有解，如果是线段相交就要求解的范围为0 <= t1,t2 <= 1。 由于前面已经在XY平面做了跨立测试，所以我们只需要判定第三个方程是否成立即可。

Balaban算法由是分治算法，它利用归一化的端点坐标值对线段进行排序，所以归一化的端点取值范围是[0, 2N](N为端点数量)。排序完成后将这个值分为多个条带，按线段与条带边界相交的情况分别进行处理，但其向三维推广较扫描线算法复杂很多。

最终选择了相对简单的扫描线算法进行实现。

并行算法

首先使用TBB的parallel_sort将线段按起点的X坐标排序。

然后，对排序后的每一条线段L仅需要判断起点在其右边且小于L的终点的线段判断是否相交。这样每条线段的判断都是相对独立的读访问线段参数及相交判断，不需要任何同步。所以OpenMP的for循环即可很容易的并行化本算法，但记录结果需要同步，使用TBB的concurrent_vector可以很方便快速的实现。

// 并行查找相交直线

#pragma omp parallel for schedule(guided, 1)

for(int i = 0; i < nLine; ++i)

{

     const int nEndX = pLine[i].nX1;

     // 根据X的排序结果只查找起点落在pLine[i].nX0到pLine[i].nX1之间的直线

     for(int j = i + 1; j < nLine && pLine[j].nX0 <= nEndX; ++j)

     {

         ……

     }

}

优化工具

Hotspots检测

使用Intel Amplifier的Hotspots检测功能查找二分查找算法的热点函数，结果如下：

检测结果显示热点函数在XLSI_Solve内部，进一步深入发现大约8秒的时间用于定位是否可能相交，也就是绝大部分时间实际上都用于判断两条线段所决定的立方体是否重叠上，这个判断目前并不是最优的，只是使用了x坐标排序，yz坐标循环判断的方式，有更高效的方法可以大大缩短这个时间，例如使用分治法将直线划分到很多个立方体区域内，对每个立方体内部的线段及跨越多个立方体的线段分别处理。

Concurrency检测

使用Intel Amplifier的Concurrency检测功能查找可进行并行优化的代码，结果如下：

检测结果显示，加载数据部分是完全串行的，但由于占整个运行时间的比例较小，属于可以接受的范围，而进行线段相交判定的XLSI_Solve函数并行度较好，执行时间也比较长。

Locks and Waits检测

使用Intel Amplifier的Locks and Waits检测功能查找两种算法的锁和同步等待消耗，结果如下：

检测结果显示由于使用了concurrent_vector，导致有一定的同步开销可以通过优化提升性能。

其他优化

1.  在数据加载时保证线段两个端点X坐标的顺序X0 < X1以及计算部分数据减少运算。

2.  优化直线相交跨立测试部分，只是用乘法和加法运算。

性能测试

小数据量测试：

操作系统：    32bit的测试在32位XP下完成。

CPU：         Intel(R) Core(TM)2 CPU  5270  @ 1.40GHz

内存：         1G

时间单位：    秒

编译说明

Windows平台:

使用VS2008和Intel Parallel Studio

1. 用VS2008打开本项目.

2. 选择X64平台Relase编译.

3. 进入Bin目录执行文件为XLSI.exe.

Linux平台:

使用ICC和TBB

1. 上传压缩包种的Src和Linux两个目录到服务器上.

2. 进入XLSI/Linux目录 执行make

3. 进入XLSI/Bin目录 执行文件为XLSI.

其他：

主办方请使用Win32平台Release版本测试，谢谢！

优化结论

本解决方案实现的三维直线求交的算法还有很大优化余地。特别是在缩小判定范围上做得不够，复杂度比较高。通过将Balaban算法的分治思想推广到三维的情况可大大降低复杂度，提高执行性能。

如您需要就本文所涉及的问题与作者进行交流讨论，请发送邮件联系邓辉，邮件地址为 denghui0815@hotmail.com

致谢

感谢Clay Breshears所做的解答，感谢Mu，Pryce为本文章发表到ISN所做的工作，感谢Xia, JeffX P为我的解决方案进行了认真细致的翻译。

问题描述

在你为旅行准备行李时，重要的是你要注意不要在行李箱里放过多的东西，否则你可能会为因行李过重而付出额外的代价。这可能是来自航空公司的额外行李费用，或由于携带背包引起的肌肉酸痛。而且，当你装包时，控制总重量并不是你的唯一标准，你需要为你的旅行放入更有价值的物品。比如当你到澳大利亚度假时，如果你在包里塞满了羽毛，这不会有任何意义。背包问题的目的是要找到物品的最优选择，从而使这些物品的总价值最大，同时使总重量控制在限制范围内。

问题：写一个线程代码来找到能够形成最大总价值的物品清单，同时这些物品的总重量能够满足一个背包（容器）的限定容量。每个物品将有一个相关属性，包括容量（用重量表示）和价值（价格）。背包容量和要使用的物品清单会包含在命令行指定的输入文件内。装入的物品清单，装入的物品数量，总重量以及最终总价值将打印到一个输出文件：packinglist.out。

输入格式：第一行的文本文件将包含三个数：一个实数和两个整数。实数表示背包的容量，第一个整数表示每个可用物品的最大数目，这就是说，即使每个物品会在文件中列出一次，可能会有多个相同物品用来装包。第二个整数表示文件中物品的数目。随后的每一行由三项数据组成：表示物品名的唯一的13个字符长的字符串;表示物品重量的一个实数;以及表示物品价值的一个实数。在输入中不存在重量和价值相同的两个物品。

输出格式：使用易懂的一些格式。列出装入包中的每个物品以及这些物品的数量。同时需要包括所有装入包中物品的总重量和总价值。

有关本问题的详细情况，请进入本次线程挑战赛，获取更多信息。

对背包问题的分析和求解

有关此问题的参赛源代码，请点击这里下载。

串行算法

本题属于多重背包问题，多重背包可以转化为01背包进行求解。将物品分组1, 2, 4, 8..... 2^(k - 1), nCount - 2^(k + 1) + 1。由这些组可以组合成[0-nCount]的任意值。将减少转化后的物品数量。

01背包问题可以用动态规划和分支限界两种算法进行求解，当背包较大时动态规划并不适用，而且内存访问过于频繁，分支限界算法利用分支可能组合的最大价值与当前已经找到的最大价值的比较结果进行剪枝，如果物品的价值和重量比值都差异很小的时候分支限界算法可能会有较长的执行时间。

并行算法

动态规划是数据高度依赖的算法，所以并行相当的困难，根据测试的结果看线程同步的开销甚至让并行算法比串行算法还要慢。

分支限界算法的并行也存在类似的问题，最终采取了多个线程分别计算不同的分支从而达到并行加速的目的。

优化工具

根据测试结果最终选定压缩版本的WM算法提交，以下为ZWM算法的优化结果。

Hotspots检测

使用Intel Amplifier的Hotspots检测功能查找热点函数，结果如下：

检测结果显示主要的时间开销为XKnapsack_BB_Bound价值上限估算函数，通过检测结果优化了该函数，原采用同一物品以堆为单位进行估算，优化后按物品为单位进行估算，运行效率得到了一倍的提高。

Concurrency检测

使用Intel Amplifier的Concurrency检测功能查找可进行并行优化的代码，结果如下：

检测结果显示XKnapsack_BB_Bound价值上限估算函数具有良好的并行度。

 Locks and Waits检测

使用Intel Amplifier的Locks and Waits检测功能查找锁和同步等待消耗，结果如下：

检测结果显示算法几乎不存在同步和锁消耗。

其他优化

1. 使用内存映射加载数据。

2. 使用二叉堆获取价值上限最大的节点。

3. 使用内存缓冲，减少内存分配占用的时间。

性能测试

操作系统：    32bit的测试在32位XP下完成。

CPU：           Intel(R) Core(TM)2 CPU  5270  @ 1.40GHz

内存：           1G  

时间单位：  秒      最短DNA序列长度：32字节

编译说明

Windows平台:

使用VS2008和Intel Parallel Studio

1. 用VS2008打开本项目.

2. 选择Win32平台Release编译.

3. 进入Bin目录执行文件为XKnapsack.exe.

Linux平台:

使用ICC和TBB

1. 上传压缩包种的Src和Linux两个目录到服务器上.

2. 进入XKnapsack/Linux目录 执行make

3. 进入XKnapsack/Bin目录 执行文件为XKnapsack.

其他：

主办方请使用Win32平台Release版本测试，谢谢！

优化结论

高数据依赖的算法并行非常困难，如何在数据量很小的时候能够并行计算，使并行计算减少的时间远远大于同步的开销？我需要更多的时间去探索。

如您需要就本文所涉及的问题与作者进行交流讨论，请发送邮件联系邓辉，邮件地址为 denghui0815@hotmail.com

致谢

感谢Clay Breshears在论坛上所做的解答，感谢Mu，Pryce为本文章发表到ISN所做的工作，感谢Xia, JeffX P为此解决方案进行的认真细致的翻译。

问题描述

问题描述：写一个线程程序来搜索用字符串表示的 DNA 序列的数据库，来找到可以匹配的其他 DNA 序列。数据库和查询字符串由四个字符组成：'A', 'C', 'G'. 和 'T' 。对于每个输入的搜索查询字符串，输出必须报告任何输入 DNA 序列内的精确匹配位置。如果查询字符串与数据库内的多个序列匹配，必须报告每个结果;如果查询字符串与同一个数据库序列的多个位置匹配，必须报告完全匹配的那个最早出现的位置。这个问题（资料库档案，查询档案，输出结果）的文件名将在命令行上给出。

文件格式：输入数据库和查询档案将具有相同的格式。每个序列将以大于字符('>')开始，紧跟序列来源的描述，描述不超过 131 个字符。序列会在下一行开始，持续几行。每一行都将包含'A', 'C', 'G'. 和'T'集合的整 80 个字符，除了最后一行，可能会少于80个字符。在最后一行之后将是从下一个序列直至文件末尾的描述符，文件末尾将由描述符（">EOF" ）表示 。

对于包含在第二个输入文件的每个查询字符串，输出文件应打印查询序列的描述符和数据库序列的描述符，这个数据库序列包含一个匹配和此匹配在数据库序列内的位置。如果在任何数据库序列内，都没有找到查询序列字符串，应在查询描述符之后打印出一个相关消息来体现这个结果。

计时：总执行时间将用于计分。这允许输入数据库序列的编码或压缩在输入期间完成（如果你的算法采用这种转换）

对字符串匹配问题的分析和求解

有关此问题的参赛源代码，请点击这里下载。

串行算法

字符串匹配算法分为单模式匹配算法和多模式匹配算法。一个待匹配串为一个待匹配模式，单模式匹配算法一次只进行一个模式的匹配，多模式匹配算法可一次匹配多个模式，常见的单模式字符串匹配算法有Karp-Rabin（KR），Knuth-Morris-Pratt（KMP），Boyer-Moore （BM）等等，多模式算法有Aho Corasick（AC），Wu Manber（WM）等等。

通过一步步了解字符串匹配算法，依次实现了KMP算法，BM算法、WM算法，压缩DNA的WM算法。

其中KMP和BM算法都是利用模式本身包含的信息避免重复对一个字符进行多次比较。其中KMP利用前缀信息加速窗口移动，而BM利用后缀信息加速窗口移动。

WM算法，利用后缀的Hash值对模式进行分组，减少待匹配模式，窗口移动也类似于BM，不同的是它使用Hash值计算Shift表。

由于DNA只包含(A,C,G,T)4个字符，而WM用两个字符计算Hash值，导致冲突过多，效率下降，所以压缩4个字符到1个字节中可减少冲突，提高效率。

压缩后的WM算法仅仅支持长度大于等于8的模式，所以小于8的模式直接用顺序匹配。

并行算法

由于题目是在多个DNA序列中匹配多个模式，所以并行化比较容易，可以使用多个线程分别匹配不同的DNA序列。

单模式匹配算法：

     #pragma omp parallel for schedule(guided, 1)

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

     {

         XDNASequence& xDNADB = xDatabaseVec.at(i);

         for(j = 0; j < nPatternCnt; ++j)

         {

              XDNASequence& xDNAPattern = xPatternVec.at(j);

              pOutput[i * nPatternCnt + j] =

                   XStrMatch_BM( xDNADB.pSequence, xDNADB.nSequenceLen,

                   xDNAPattern.pSequence, xDNAPattern.nSequenceLen,

                   xDNAPattern.pExt);

         }

     }

根据Amplifier的检测结果进行了优化，将任务粒度减小，提高并行度。

     int nCount = nDatabaseCnt * nPatternCnt;

     #pragma omp parallel for schedule(guided, 1)

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

     {

         const int nIndexD = i / nPatternCnt;

         const int nIndexM = i % nPatternCnt;

         XDNASequence& xDNADB = xDatabaseVec.at(nIndexD);

         XDNASequence& xDNAPattern = xPatternVec.at(nIndexM);

         pOutput[i] = XStrMatch_BM( xDNADB.pSequence, xDNADB.nSequenceLen,

                                xDNAPattern.pSequence, xDNAPattern.nSequenceLen,

                                xDNAPattern.pExt);

     }

多模式匹配算法：

#pragma omp parallel for schedule(guided, 1)

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

    {

        XDNASequence& xDNADB = xDatabaseVec.at(i);

        XZWMSearch (pXWM, xDNADB.pSequence, xDNADB.nSequenceLen, pOutput + i * nPatternCnt);

    }

优化工具

根据测试结果最终选定压缩版本的WM算法提交，以下为ZWM算法的优化结果。

Hotspots检测

使用Intel Amplifier的Hotspots检测功能查找热点函数，结果如下： 

检测结果显示主要的时间开销为读取数据，读取及压缩数据与匹配的时间开销比例为8：1。

Concurrency检测

使用Intel Amplifier的Concurrency检测功能查找可进行并行优化的代码，结果如下：

检测结果显示算法的并行度很好， Read函数采用了分块读取数据，每个块的大小必须大于最大DNA序列长度10^6，所以当数据量较小，块数量不够时会导致部分CPU闲置。

 Locks and Waits检测

使用Intel Amplifier的Locks and Waits检测功能查找锁和同步等待消耗，结果如下：

检测结果显示算法几乎不存在同步和锁消耗。

其他优化

1.     使用内存映射结合OpenMp并行的分块加载DNA序列。

2.     使用concurrent_vector保存DNA数据。

3.     使用parallel_sort进行模式的排序。

性能测试

 操作系统：    32bit的测试在32位XP下完成。

 CPU：         Intel(R) Core(TM)2 CPU  5270  @ 1.40GHz

 内存：         1G

 时间单位：    秒      最短DNA序列长度：32字节

编译说明

Windows平台:

使用VS2008和Intel Parallel Studio

1. 用VS2008打开本项目.

2. 选择Win32平台Release编译.

3. 进入Bin目录执行文件为XStringMatch.exe.

Linux平台:

使用ICC和TBB

1. 上传压缩包种的Src和Linux两个目录到服务器上.

2. 进入XStringMatch/Linux目录 执行make

3. 进入XStringMatch/Bin目录 执行文件为XStringMatch.

其他：

主办方请使用Win32平台Release版本测试，谢谢！

优化结论

通过解决本题进一步了解了串匹配算法，串匹配算法可以说有数十种之多，但多数算法的基本原理都是利用已经比较出的结果，结合模式本身的信息，尽可能的滑动比较窗口。

TBB提供的concurrent_vector是一个高性能的、线程安全的并行vector类，在并行读取DNA序列时，各个线程需要把读完的DAN序列压入vector，存在并发访问，如果使用std::vector必须做同步，而concurrent_vector则不用同步，非常方便。

如您需要就本文所涉及的问题与作者进行交流讨论，请发送邮件联系邓辉，邮件地址为 denghui0815@hotmail.com

致谢

感谢Clay Breshears在论坛上所做的解答，感谢Mu，Pryce为本文章发表到ISN所做的工作，感谢Xia, JeffX P为此解决方案进行的认真细致的翻译。

问题描述

问题描述：写一个线程程序在一个线性存储且有序的唯一关键字集合中搜索给定关键字集合的所在位置。关键字是由15个字符组成的字符串，第一个输入文本文件包含有序关键字集合。第二个输入文本文件包含不定数量的关键字，这些关键字将在第一个文件中的关键字集合里进行查询。对于第二个输入文件中的每一个关键字在输出文件中都应该有对应的单行输出，输出信息包括关键字以及其在第一个文件中的下标，下标从0开始。如果待搜索关键字不在第一个文件中，那么将在输出文件中打印没有找到的信息。程序所涉及到的文件名（包括关键字集合文件，待搜索关键字集合文件，输出文件）将在命令行中给出。

文件格式：第一个输入文件的第一行是一个整数，代表文件中有序关键字集合的关键字数量（这里用N表示）。接下来存储的就是N行有序的关键字，每个关键字是15个字符的字符串。第二个文件包括待查询的不定数量的关键字集合，关键字同样是15字符的字符串，每行存储一个关键字。

输出文件应当与第二个输入文件有相同的输出行数。对于第二个文件中列出的每个关键字，在输出文件中都有对应的一行输出信息表明待搜索关键字以及在第一个文件中的下标或者未找到的信息。

有关本问题的详细情况，请进入本次线程挑战赛，获取更多信息。

对查找问题的分析和求解

串行算法

本题为查找算法题，可选的查找算法很多，有顺序查找、二分查找、HashMap等等。

顺序查找算法是将待查找的值依次与数组中每一个值比较，相等即查找成功，否则查找失败，顺序查找是O(N)的算法，不需要额外的空间。

二分查找算法只能在已排序的数据中查找，所以首先是将数据排序，然后取中间的值与待查找值进行比较，相等即查找成功。否则根据比较的结果在一半的数据中递归查找。二分查找是O(logN)的算法，不需要额外的空间。

HashMap查找算法通过Hash函数计算Hash值将数据分散到桶中，每个桶里的数据Hash值相同。不同值有相同Hash值我们称为冲突，冲突会导致桶中的数据增加。查找时利用Hash函数得到待查找值的Hash值，在这个Hash值限定桶中进行顺序查找，理论上该算法是O（1）的。如果数据集增大或者Hash函数不够好，冲突会增加，导致桶内数据增加，效率也会随之降低。如果所有数据的Hash值相同，则退化为顺序查找。

由于本题的输入是已经排序的字符串，所以首选当然是二分查找，但它是O(logN)的，理论上不及HashMap查找，但HashMap需要构建时间，性能与数据量也有关系。所以使用什么算法是需要根据数据量来调整的。

每个关键字为15字节，可以放入到__m128i中，于是定义XSearchItem结构表示关键字

// 关键字数据

typedef struct tagXSearchItem

{

     union

     {

         char cVal[16];

         uint16   nVal16[8];

         uint32   nVal32[4];

         uint64   nVal64[2];

         __m128i nVal128;

     };

     tagXSearchItem(__m128i nV128)  { nVal128 = nV128; }

}XSearchItem,*PXSEARCHITEM;

实现了三个版本的算法。

二分查找 ：见XSearch_Binary.cpp中的XSearch_Binary_Serial函数。

HashMap：  见XSearch_HashMap.cpp中的XSearch_HashMap_Serial函数。

concurrent_hash_map：见XSearch_HashMap_TBB.cpp中的XSearch_HashMap_TBB_

Serial函数。

并行算法

对应的实现了三种算法的并行版本。

二分查找 ：

使用多个线程，分别处理一部分待查关键字即可实现二分查找的并行算法。

见XSearch_Binary.cpp中的XSearch_Binary_Parallel函数。

HashMap：

在构造阶段，每个线程分别构造桶数量相同的HashMap，构造完毕后，使用多个线程进行桶的合并。然后使用多个线程，分别处理一部分待查关键字即可实现HashMap查找的并行算法。

见XSearch_HashMap.cpp中的XSearch_HashMap_Parallel函数。

concurrent_hash_map：

concurrent_hash_map本身就是支持并行的数据结构，所以我们只需开启多个线程同时向concurrent_hash_map插入数据，构造完concurrent_hash_map后使用多个线程，分别处理一部分待查关键字即可实现concurrent_hash_map查找的并行算法。

见XSearch_HashMap_TBB.cpp中的XSearch_HashMap_TBB_Parallel函数。

优化工具

Hotspots检测

使用Intel Amplifier的Hotspots检测功能查找二分查找算法的热点函数，结果如下：

 二分查找的时间开销基本上都在关键字比较函数XCompareItem中，最初的使用的字符串比较函数替换为汇编版本的比较函数，该函数每次将4个字节的数据通过bswap转化为一个int值后进行比较，大幅度的提高了程序性能。

使用Intel Amplifier的Hotspots检测功能查找HashMap算法的热点函数，结果如下：

 主要的时间开销都在函数XSearch_HashMap_Parallel内。

 Concurrency检测

使用Intel Amplifier的Concurrency检测功能查找可进行并行优化的代码，结果如下：

 根据检测结果可知，二分查找算法几乎实现了完全并行。

 检测结果显示在XSearch_HashMap_Parallel内存在较多的串行代码，进入函数内部可以以找到串行执行的代码行如下：

串行执行时间均为分配内存和释放内存开销。由于需要构造很多的HashMap所以内存需求较大，时间消耗也比较多，约为150ms。

 Locks and Waits检测

使用Intel Amplifier的Locks and Waits检测功能查找两种算法的锁和同步等待消耗，结果如下：

 检测结果显示两种算法不存在较严重的同步和锁消耗。

其他优化

1.     使用内存映射结合OpenMp并行的读取数据。

2.     使用_mm_loadu_si128加载每个关键字。

3.     统计每个分块数据的输出信息需要的空间大小，进而使用内存映射结合OpenMp并行的保存数据。

4.     使用汇编实现二分查找比较函数。

5.     使用XSearchItem结构的nVal64[2]判断关键字是否相同。

6.     根据查找数据和待查找数据的数据量自动选择二分查找和HashMap查找算法。

性能测试

小数据量测试：

操作系统：    32bit的测试在32位XP下完成。

CPU：         Intel(R) Core(TM)2 CPU  5270  @ 1.40GHz

内存：         1G

时间单位：    秒

测试数据:     DataCount_KeyCount

大数据测试：

操作系统：    Red Hat Enterprise Linux AS release 4 (Nahant Update 2)

CPU：         Intel(R) Core(TM)2 CPU  6320  @ 1.86GHz

内存：         4G

编译说明

Windows平台:

使用VS2008和Intel Parallel Studio

1. 用VS2008打开本项目.

2. 选择X64平台Relase编译.

3. 进入Bin目录执行文件为XSearch.exe.

Linux平台:

使用ICC和TBB

1. 上传压缩包种的Src和Linux两个目录到服务器上.

2. 进入XSearch/Linux目录 执行make

3. 进入XSearch/Bin目录 执行文件为XSearch.

其他：

主办方请使用Win32平台Release版本测试，需要使用Linux格式的输入文件。使用默认的Auto Parallel Mode【ap】运行模式，谢谢！

优化结论

通过解决本题进一步学习了查找算法，更深入的了解了二分查找和HashMap在多核系统上的优缺点、性能差异。

学习使用TBB提供的concurrent_hash_map，它是一个高性能的、线程安全的并行HashMap类，由于本题的数据是已经排序的，而且构造好HashMap后再进行查询，不存在并发的、反复的增加数据、查询数据。所以使用它来解答本题虽然很方便，但效率上不占优势。在实际的软件开发环境中强烈推荐使用。

同时在Linux下使用l_cc_p_10.1.015编译XSearch_HashMap_TBB.cpp是报了一个编译错误，时间关系没有继续查原因，不知是否存在Bug。 错误如下：

error: unknown opcode "pause;" -- __asm

如您需要就本文所涉及的问题与作者进行交流讨论，请发送邮件联系邓辉，邮件地址为 denghui0815@hotmail.com

致谢

感谢Clay Breshears所做的解答，感谢Mu，Pryce为本文章发表到ISN所做的工作，感谢Xia, JeffX P为我的解决方案进行了认真细致的翻译。

问题描述

可满足性问题研究的是取值为布尔值的析取子式的合取范式组成的表达式是否为TRUE的问题。要解决这个问题，也就是使得整个表达式为TRUE，你必须首先确定一组取值为TRUE或者FALSE的布尔变量是否存在。三元可满足性（3SAT）是可满足性问题的一种，它限制了析取子式只能有3个变量。以下是3SAT表达式的一个例子：

(X_1 | !X_2 | X_3) & (X_3 | X_2 | !X_1) & (X_2 | X_1 | !X_3) & (!X_1 | !X_2 | !X_3) “|”表示逻辑“或”（OR）， “＆”表示逻辑“与”（AND），“！”表示逻辑“非”（NOT）。当X_1和X_2为TRUE, X_3为FALSE时，此表达式为TRUE。

写一个线程程序，首先从一个文本文件中导入3SAT问题表达式实例，然后确定是否存在使得给定表达式为TRUE的布尔值赋值。

如果存在这样一组赋值，应该把结果打印到标准输出设备，同时将布尔变量的赋值输出到一个文本文件。如果赋值不存在，输出文件会被省略。输入和输出文件名应为应用程序执行命令行的第一和第二个参数。

文件格式：输入文件的第一行将包含两个整数：表达式中布尔变量的最大数量（这里用N表示）和文件中析取子式的数量（这里用K表示）。接下来的K行将包含ABS（ [ 1 ，N] ）中三个整数，三个整数之间以一个空格隔开。这些整数代表布尔变量的下标，负值表示对子式中布尔变量取反。

如果存在这样一组赋值，满足整个输入的表达式的值为TRUE，那么输出文件将包含N行。每一行表示N个变量中的第几个变量以及所赋的布尔值。每行格式： [ 1 ，N]中的一个整数，一个空格，表示TRUE或FALSE的字符 “T” 或 “F”。

有关本问题的详细情况，请进入本次线程挑战赛，获取更多信息。

对 3SAT 的分析和求解

有关此问题的参赛源代码，请点击这里下载。

串行算法

可满足性问题属于NP问题，可以使用局部搜索算法（GWSAT，

WALKSAT）和全局搜索算法（DPLL），局部搜索算法对于有解的问题，通常可以快速的找到解，但不能确定问题是否无解。全局搜索算法能够确定问题无解，但速度要远远低于局部搜索算法。

WALKSAT局部搜索的算法：

1，  随机的对每个变量赋值，统计未满足的表达式和已满足的表达式为真的子条件个数。

2，  选择一个变量。

选择方法有很多种，比如从未满足的表达式中随机选择一个表达式，从这个表达式中选择一个翻转后导致未满足的表达式变为满足的数量最大的。（优化的算法使用了随机策略，一定几率的任意返回这个表达式的任意子变量）。还有一些算法参考walksat + tabu，novelty，rnovelty。

3，  翻转该变量，更新未满足的表达式和已满足的表达式为真的子条件个数。

4，  如果所有表达式都已满足，输出解，否则回到2。

设定局部搜索算法变量翻转次数N，如果翻转了N次依然没有找到解，就认为该问题无解，N越大，将有解问题判定为无解的几率越小，但绝对不是零。

一种全局搜索算法：

1，  选择一个未赋值变量，该变量关联的未满足表达式最多。

2，  对该变量赋值T，

3，  如果变量赋值T，所有未满表达式都有未赋值的变量

A. 如果所有表达式都已满足，输出解，否则递归调用1.

4，  对该变量赋值F，

5，  如果变量赋值F，所有未满表达式都有未赋值的变量

B. 如果所有表达式都已满足，输出解，否则递归调用1.

由于不确定是否允许使用局部搜索算法，所以我同时实现了这两种算法，其中局部搜索算法根据Henry Kautz<kautz@cs.washington.edu>的程序walksat改编。效率非常高，能瞬间求出有250个变量的有解问题的解。全局搜索为自行设计的算法实现，跟成熟的DPLL算法相比有很大差距，目前求解75个变量的问题大概在10秒左右。

并行算法

对于局部搜索算法，可以开启多个线程各自搜索，一旦搜索到解，所有线程退出。使用tbb：：parallel_for可以很容易的实现，见CX3SATLocalSearchOperator类。

对于全局搜索算法，可以在递归调用环节进行任务分解，分别处理赋值T和赋值F。使用tbb：：task实现，见CX3SATWholeSearchTask类。

优化工具

以下给出局部搜索并行算法的性能优化检测结果。

Hotspots检测

 使用Intel Amplifier的Hotspots检测功能查找热点函数，结果如下：

主要的时间开销都在函数翻转变量X3SATAtomFlip_Local及选择变量X3SATPickBest_Local的函数内，优化这两个函数能得到最大的性能提升。

 Concurrency检测

使用Intel Amplifier的Concurrency检测功能查找可进行并行优化的代码，结果如下：

代码主要的函数X3SATAtomFlip_Local及X3SATPickBest_Local都有很高的并行度。

 Locks and Waits检测

使用Intel Amplifier的Locks and Waits检测功能查找锁和同步等待消耗，结果如下：

结果显示存在23ms的同步消耗，不存在较严重的同步和锁消耗。 

性能测试

操作系统：    32bit的测试在32位XP下完成。

64bit的测试在64位XP下完成。

CPU：           Intel(R) Core(TM)2 CPU  5270  @ 1.40GHz

内存：           1G

时间单位：  秒

 局部搜索算法结果：

 全局搜索算法结果：

编译说明

Windows平台:

使用VS2008和Intel Parallel Studio

1. 用VS2008打开本项目.

2. 选择X64平台Relase编译.

3. 进入Bin目录执行文件为X3SAT.exe.

Linux平台:

使用ICC和TBB

1.上传压缩包种的Src和Linux两个目录到服务器上.

2.进入X3SAT/Linux目录 执行make

3.进入X3SAT/Bin目录 执行文件为X3SAT.

其他：

请使用Win下的64bit Relase版本进行测试。

优化结论

通过这道竞赛题，我熟悉了3SAT问题的完全搜索算法和局部搜索算法，也通过blackcoffee(最后一支烟)的文章了解了这个问题从完全搜索，到引用N皇后问题的算法，采用局部搜索。然后是GSAT->GSAT+TABU->GWSAT ->WalkSAT-> WalkSAT+TABU

->NOVELTY和R-NOVELTY 的一步步发展。

由于时间关系，只实现了WalkSAT，也尝试了一下NOVELTY，效果没有想象中那么明显，最后还是回到了WalkSAT。

完全搜索算法，我没有太多的去了解，是自己摸索出来的算法，刚开始是按顺序对每个变量赋值，然后检查是否有子句不可能满足，如果有就进行剪枝。再深入一步，优先考虑关联表达式较多的变量可以将剪枝提前，从而缩小搜索范围。于是在加载的时候统计每个变量的关联的表达式数量，数量多的先赋值，效率提高不少。最后就是参考walksat，每一次都选择关联的不满足的表达式数量最多的变量进行赋值，就是最终的提交版本了。

值得一提的是测试结论，可以局部搜索算法在处理有解问题的时候，加速比很小，有时候比串行代码还要慢，原因在于题目只要求找一个解，而局部搜索算法又有随机性，所以串行代码在数据量CPU核很少的时候比并行算法还快。CPU的核越多，问题的变量越多，并行算法比串行算法的几率就越大。

如您需要就本文所涉及的问题与作者进行交流讨论，请发送邮件联系邓辉，邮件地址为 denghui0815@hotmail.com

致谢

感谢Clay Breshears所做的解答，感谢Henry Kautz开源的walksat-dist帮组我完成了3SAT问题的编码，感谢blackcoffee(最后一支烟)在瀚海星云发表的《一个经典问题的算法发展史》帮助我了解3SAT问题的发展历史，并最终选择了walksat算法进行并行改进。

问题描述

给出一组含有关键字的未排序字符串，这些关键字可视为整数的二进制表示，关键字内的各个位可以用来对这组字符串进行排序。这种排序方法被称为基数排序。
请编写一个用多线程实现基数排序算法的程序：对从输入文件读取的关键字进行排序，然后将排序后的关键字输出到另一个文件。输入文件名和输出文件名应为执行程序命令行的第一和第二个参数。
输入文件中的第一行是要排序的关键字总个数 (N)；后面紧跟 N 个关键字，每行一个；关键字是由 7 个可打印字符组成的字符串，不含空格 (ASCII 0x20)。文件中关键字的个数小于
2^31 – 1。排序后的输出结果必须保存在文本文件中，每行一个关键字；

计时：如果您在程序中加入计时代码来计算排序过程所用的时间并报告已用的时间，将用这个时间来计分；如果不加入计时代码，将使用整个执行时间（包括输入时间和输出时间）来计分。

有关本问题的详细情况，请进入本次线程挑战赛获取更多信息。

对基数排序的分析和求解

串行算法

“基数排序法”（radix sort）则是属于“分配式排序”（distribution sort），基数排序法又称“桶子法”（bucket sort）或bin
sort，顾名思义，它是透过键值的部份资讯，将要排序的元素分配至某些“桶”中，藉以达到排序的作用，基数排序法是属于稳定性的排序，其时间复杂度为O (nlog(r)m)，其中r为所采取的基数，而m为堆数，在某些时候，基数排序法的效率高于其它的比较性排序法。

基数排序的方式可以采用LSD（Least significant digital）或MSD（Most significant digital），LSD的排序方式由键值的最右边开始，而MSD则相反，由键值的最左边开始。

显然MSD更适合并行处理，我们只需要像快速排序那样按照指定的bit位为1的和为0的分开，让为0的在前面，为1的在后面就可以了，然后递归由高到低的处理每个bit位。

本问题需要排序的为7个字符，共7 * 8 = 56 bit，加上换行符共64bit刚好可以放入一个int64变量中。

下面给出不使用小数据排序展开优化的源码，使用展开的代码较长，就不放入文档中了。

//基数排序,返回分割点不使用展开优化

__inline uint64* XPartition64(uint64* pBeg, uint64* pEnd, uint64 nBitMask)

{

//判断如果少于一个数据无需排序

if(pBeg + 1 < pEnd)

{

uint64 *i = pBeg - 1, *j = pEnd;

while ((++i) < pEnd && (*i & nBitMask) == 0);

while ((--j) > pBeg && (*j & nBitMask));

while (i < j)

{

const uint64 t = *i; *i = *j; *j = t;

do ++i; while ((*i & nBitMask) == 0);

do --j; while ((*j & nBitMask));

}

return i;

}

else

{

return NULL;

}

};

//基数排序_串行版本

void XRadixSort64Serial(uint64* pBeg, uint64* pEnd, uint64 nBitMask)

{

uint64* pSplit = XPartition64(pBeg, pEnd, nBitMask);

if(pSplit != NULL && nBitMask != XRADIX_MASK_END)

{

XRadixSort64Serial(pBeg, pSplit, XRADIX_MASK_SHIFT_64(nBitMask));

XRadixSort64Serial(pSplit, pEnd, XRADIX_MASK_SHIFT_64(nBitMask));

}

}

代码跟快速排序的代码几乎一致，只是对比较方法及分割位置的处理有些不同，用红色字体标出。

并行算法

分裂式的算法，采用TBB的Task做并行优化是个不错的选择。一次分裂出两个Task，分裂出的Task可以并行处理，彼此之间没有共享数据，可以完全并行。

// 基数排序Task

class CXRadixSort64Task: public tbb::task

{

uint64 *m_pBeg,*m_pEnd,m_nBitMask;

BOOL m_bIsContinuation;

static uint32 ms_nCutOff32;

public:

CXRadixSort64Task( uint64* pBeg, uint64* pEnd, uint64 nBitMask) :

m_pBeg(pBeg), m_pEnd(pEnd), m_nBitMask(nBitMask), m_bIsContinuation(FALSE) {
}

tbb::task* execute()

{

tbb::task *pNextA = NULL, *pNextB = NULL;

if(m_pEnd - m_pBeg < ms_nCutOff32)

{ // 基数排序_串行版本

XRadixSort64Serial(m_pBeg, m_pEnd, m_nBitMask);

}

else

{

if( !m_bIsContinuation )

{ // 移动数据并得到分割点

uint64* pSplit = XPartition64(m_pBeg, m_pEnd, m_nBitMask);

if(pSplit != NULL)

{ // 分裂新的Task

pNextA = new( allocate_child() ) CXRadixSort64Task(m_pBeg, pSplit,

XRADIX_MASK_SHIFT_64(m_nBitMask));

pNextB = new( allocate_child() ) CXRadixSort64Task(pSplit, m_pEnd,

XRADIX_MASK_SHIFT_64(m_nBitMask));

m_bIsContinuation = TRUE;

recycle_as_continuation();

set_ref_count(2);

spawn(*pNextB);

}

}

}

return pNextA;

}

static void SetCutOff(uint32 nCutOff)

{

if(nCutOff < 1024)

ms_nCutOff32 = 1024;

else if(nCutOff > XRADIXSORT_CUTOFF)

ms_nCutOff32 = XRADIXSORT_CUTOFF;

else

ms_nCutOff32 = nCutOff >> 10 << 10;

}

};

// 基数排序_并行版本

void XRadixSort64Parallel(uint64* pBeg, uint64* pEnd, uint64 nBitMask)

{

// 计算CUTOFF值

uint32 nSize = (uint32)(pEnd - pBeg) / task_scheduler_init::default_num_threads()
/ 4;

CXRadixSort64Task::SetCutOff(nSize);

CXRadixSort64Task& xtask = *new(tbb::task::allocate_root())

CXRadixSort64Task(pBeg, pEnd, nBitMask);

tbb::task::spawn_root_and_wait(xtask);

}

在Task处理前先判断数据量的大小，如果小于ms_nCutOff32个数据可直接调用串行算法，减少Task的数量，降低TBB维护Task的开销。ms_nCutOff32的大小根据待排序数组的大小进行动态调整，最大为64k。

优化工具

Hotspots检测

使用Intel Amplifier的Hotspots检测功能查找热点函数，结果如下：

主要的时间开销都在函数XPartition64内，优化该函数能得到最大的性能提升。

Concurrency检测

使用Intel Amplifier的Concurrency检测功能查找可进行并行优化的代码，结果如下：

XLoadData和XSaveData使用了内存映射，同时使用OpenMp做了并行优化，由于比赛不统计输入输出的时间所以这部分代码没有做太多优化。

另外在排序刚开始的时候，XPartition64存在串行执行的部分，原因在于第1层调用只有1个Task可以执行，第2层调用只有2个Task可以执行，第3层调用只有4个Task可以执行，第n层调用只有2
^ n个Task可以执行.测试平台为16核系统，至少要到第5层调用16个核才能开始完全并行，所以这部分串行执行的时间与核的数量成正比，这部分串行执行时间，任然是需要进行优化的。这样就需要在前期执行时使用并行版本的XPartition64函数。由于时间有限就不再做这部分优化了。

Locks and Waits检测

使用Intel Amplifier的Locks and Waits检测功能查找锁和同步等待消耗，结果如下

结果显示存在136ms的同步消耗，不存在较严重的同步和锁消耗。

其他优化

1. 在32位平台下int64的运算的开销较大，在32位平台上可以分别处理高32bit和低32bit提高效率。见函数XPartition32H和XPartition32L。
2. 可见字符的高bit位均为零，可以利用这个规律对数据进行压缩，在数据加载的时候将数据压缩到49个比特位，后来看到haojn的提问及Clay Breshears的解答，否定了压缩方案，因为数据压缩的开销比较大。但是可以采取另外一种方案来加速，在右移动BitMask的时候，直接跳过每个字节的高位，具体见XRADIX_MASK_SHIFT_32和XRADIX_MASK_SHIFT_64宏函数。
3. 对较少的数据（2个，3个，4个）的排序展开。分别为XPartition64_2，XPartition64_3，XPartition64_4减少比较和内存搬运的次数，提高效率。
4. 在数据加载和保存的时候利用OpenMp进行并行优化。

性能测试

小数据量测试：

操作系统： 32bit的测试在32位XP下完成。
64bit的测试在64位XP下完成。
CPU： Intel(R) Core(TM)2 CPU 5270 @ 1.40GHz
内存： 1G
时间单位： 秒

大数据测试：

操作系统： Red Hat Enterprise Linux AS release 4 (Nahant Update 2)
CPU： Intel(R) Core(TM)2 CPU 6320 @ 1.86GHz
内存： 4G
测试数据: 250M条数据
测试结果： 36.790519 seconds!

编译说明

Windows平台:

使用VS2008和Intel Parallel Studio
1. 用VS2008打开本项目.
2. 选择X64平台Relase编译.
3. 进入Bin目录执行文件为XRadixSort.exe.

Linux平台:
使用ICC和TBB
1. 上传压缩包种的Src和Linux两个目录到服务器上.
2. 进入XRadixSort/Linux目录 执行make
3. 进入XRadixSort/Bin目录 执行文件为XRadixSort.

其他：

如果不允许在加载数据时改变字节序，请注释XRadixSortPubDef.h第53行的X_SWAP_ON_READ宏定义。

优化结论

通过使用Intel Parallel Studio集成了编译器，TBB，IPP，OpenMp以及Amplifier和Inspector，通过使用这些工具我完成了基数排序的并行优化，虽然这个并行优化还没有做到极限，但是已经达到了我预期的效果。
Amplifier能够简单快速的检测到多线程程序的并行性能缺陷，找出需要优化的代码，是并行优化不可或缺的优化工具。
Inspecto也能对程序的内存错误及线程错误进行检测，能很方便的检测多线程程序的常见错误，特别同步方面的错误。是多线程程序调试的极佳选择。

致谢

感谢Clay Breshears所做的解答，感谢Mu，Pryce和Xia, JeffX P友好的通知我参加比赛，感谢haojn在论坛上的讨论的回复，让我修改了原来的bit压缩处理方案否则我的解决方案可能不被认可。

问题：写一个分析程序判断 6x6 的数独(Sudoku)谜题是否有唯一解。正确的解应该将数字 1-6 不重复的放到每一行每一列。同样的，不相重叠的
2x3 子块(2行，3列)必须包含这六个整数的一个唯一的实例。例如：

2 3 1 | 4 5 6

6 5 4 | 3 2 1

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

1 4 3 | 5 6 2

5 6 2 | 1 3 4

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

3 1 6 | 2 4 5

4 2 5 | 6 1 3

输入文件描述：当程序开始执行时，将输入文件的名字送入，通常是以命令行参数的形式。输入文件会包含一定数量的行，每行有 36 个非空子符。每行代表了在一个可能的
6×6 数独(Sudoku)谜题的初始状态下，全部字符的逐行排列。迷题初始状态中的空格将由星号字符代替。文件的结尾表示输入的结束。

输出：输出要标准化。应该指出每一个输入谜题是有唯一解，无解还是有多解。

一次输入 3 个谜题的输入示例：

*314*******1**356**621**3*******561*

***4****41*2*4321**6534*5*16****6***

5******5******5******5******5******5

(第一行对应了上面已解决的那个谜题在初始状态下的字符排列)

输出举例：

谜题 # 1 有唯一解

谜题 # 2 无解

谜题 # 3 有多解

计时：以时钟时间(Wall-clock time)为准(包括输入输出时间，即I/O时间)

算法分析：

数独由m x n 个 m x n 的子块，形成m x n x m x n = 36的栅格，(本题的m为2，n为3)，根据规则单元格中可填写的数字为 1到m
x n，同时每个单元格Cell[i,j]必须遵守以下三个规则：

1. Cell[i,j]值在第i行是唯一的。

2. Cell[i,j]值在第j行是唯一的。

3. Cell[i,j]值在它所属的子块中是唯一的。

当每个Cell[i,j]都存在满足以上三个规则的值，我们便认为该数独有解。

换而言之如果两个单元格满足以下条件则这两个单元格存在关联关系,不能填入相同的值。

1. 单元格的横坐标相同。

2. 单元格的纵坐标相同。

3. 单元格所在子块相同。

与Cell[i,j]存在互斥关系的单元格一共有m x n x 3 - m – n - 1 个。

栅格的每个单元格用一个int值表示，初始填为&lt; XGRID_BSIZE) – 1【低XGRID_BSIZ个bit的值为1】，表示该单元格可以填的值为[1,
XGRID_BSIZE]。 当一个单元格填入值t，就把它的关联单元格第t个bit置为0，表示该这些关联单元格不能填入t。再将这个填入值t的单元格高bit置为1【或上XFILLEDMASK】。例如：

单元格的值为 0x0003 表示该单元格填入1和2是合法的

单元格的值为 0x0005 表示该单元格填入1和3是合法的

单元格的值为 0x8008 表示该单元格一填入4。

加载迷题的时候，直接对有初始值的单元格进行填值，填值前对合法性进行检查，如果不合法直接返回无解。

迷题加载完成后，对所有未填值的单元格进行检测，找到一个可能性最少的【为1的bit位最少的单元格】单元格Cell[i,j]进行尝试填入合法的值【这样做可以降低堆栈的深度，减少分支的数量。】，如果在处理该Cell[i,j]的关联单元格时发现该关联单元格的值变为为0，表示该关联单元格没有了合法值，对Cell[i,j]尝试填入其他合法值。当所有单元格都填值完成，表示找到了该迷题的一组解。使用简单的递归调用即可完成求解。为追求效率，可以将递归展开。

首先定义一些宏、类型及结构。

// 填值失败

#define XFILL_INVALID 0x7FFFFFFF

// 已填值标记

#define XFILLEDMASK 0x8000

// 每个小块的宽度

#define XGRID_BW 3

// 每个小块的高度

#define XGRID_BH 2

// 每个小块的大小

#define XGRID_BSIZE (XGRID_BW * XGRID_BH)

// 整个网格的大小

#define XGRID_AREA (XGRID_BSIZE * XGRID_BSIZE)

// 整个网格的大小SSE对齐

#define XGRID_AREASSE ((XGRID_AREA + 7) &gt;&gt; 3 &lt;&lt;
3)

// 每个单元格关联的单元格数量

#define XGRID_MUTUALITY (XGRID_BSIZE * 3 - XGRID_BW - XGRID_BH - 1)

// 每个单元格关联的单元格数量SSE对齐

#define XGRID_MUTUALITYSSE ((XGRID_MUTUALITY + 7) &gt;&gt; 3 &lt;&lt;
3)

// 修改关联单元格的条件

#define XGRID_CHANGE_MUTUALITY_SIZE (XGRID_AREA * 30 / 100)

// 堆栈的最大深度

#define XGRID_STACK_SIZE (XGRID_AREA - XGRID_CHANGE_MUTUALITY_SIZE)

// 当数独的子块大于等于9的时候可以动态清除关联以提高效率

#if (XGRID_BSIZE &gt;= 9)

#define XGRID_MUTUALITYSSE_CLEAR

#endif

// 用于保存单元格的值

typedef int XCells[XGRID_AREASSE];

// 用于保存网格的数据结构

typedef struct tagXGrid

{

__declspec(align(16)) XCells xCells; // 单元格的值

#ifdef XGRID_MUTUALITYSSE_CLEAR

// 单元格的关联单元格索引数组

__declspec(align(16)) uint8 pMutuality[XGRID_AREA][XGRID_MUTUALITYSSE];

// 单元格的关联单元格数量

__declspec(align(16)) uint8 nMutuality[XGRID_AREA];

#endif

// 已经填充的单元格位置

__declspec(align(16)) int pFilledPos[XGRID_AREA];

// 已填充的单元格个数

int nFilled;

// 运行模式和填充方案的数量

int *pRunMode,*pTotal;

}XGrid;

XGrid结构用于表示整个栅格。

初始化部分：

1，初始化PopCnt数组 g_xPopCnt，用于寻找填值方案最少的单元格，用查表法获取bit位为1的个数。

g_xPopCnt[0] = 0;

g_xPopCnt[1] = 1;

g_xPopCnt[2] = 1;

g_xPopCnt[3] = 2;

for(i = 0x04; i &lt; 0x10; ++i) g_xPopCnt[i] = g_xPopCnt[i &gt;&gt;
2] + g_xPopCnt[i &amp; 0x03];

for(i = 0x10; i &lt; 0x100; ++i) g_xPopCnt[i] = g_xPopCnt[i &gt;&gt;
4] + g_xPopCnt[i &amp; 0x0F];

#pragma omp parallel for

for(i = 0x100; i &lt; XFILLEDMASK; ++i) g_xPopCnt[i] = g_xPopCnt[i &gt;&gt;
8] + g_xPopCnt[i &amp; 0xFF];

#pragma omp parallel for

for(i = XFILLEDMASK; i &lt; 0x10000; ++i) g_xPopCnt[i] = 0xFF;

2，初始化每个单元格的关联单元格数组。

// 计算每个单元格的关联单元格数组

for(i = 0; i &lt; XGRID_AREA; ++i)

{

g_nMutuality[i] = 0;

for(j = 0; j &lt; XGRID_AREA; ++j)

{

if(i == j) continue;

// 如果两个单元格满足以下条件则这两个单元格存在关联关系

// 1. 单元格的横坐标相同

// 2. 单元格的纵坐标相同

// 3. 单元格所在块的横坐标相同且单元格所在块的纵坐标相同[两个单元格在同一个块中]

if( ( i % XGRID_BSIZE == j % XGRID_BSIZE ) || ( i / XGRID_BSIZE == j / XGRID_BSIZE
) ||

( ( i / XGRID_BSIZE / XGRID_BH == j / XGRID_BSIZE / XGRID_BH ) &amp;&amp;

( ( i % XGRID_BSIZE ) / XGRID_BW ) == ( ( j % XGRID_BSIZE ) / XGRID_BW ) )
)

{

g_xMutuality[i][g_nMutuality[i]++] = j;

}

}

for(j = XGRID_MUTUALITY; j &lt; XGRID_MUTUALITYSSE; ++j) g_xMutuality[i][j]
= XGRID_AREA;

}

单元格填值部分：

1，填充单元格

前提为nPos位置的单元格置上nMask表示的值是合法的。首先将pCells[nPos]的值改为nMask + XFILLEDMASK，表示该单元格填上nMask表示的值，然后处理该单元格的关联单元格，去掉该单元格填充nMask的可能性，当某个关联单元格清除后仅剩下一种可能性则继续递归调用XFillCell填充掉该单元格，最后将填充的单元格位置保存到pGrid-&gt;pFilledPos中

__inline int XFillCell(XGrid* pGrid, XCells pCells, int nPos, int nMask)

{

int nFilled = pGrid-&gt;nFilled;

for(;;)

{

#ifdef XGRID_MUTUALITYSSE_CLEAR

uint8* const pMutuality = pGrid-&gt;pMutuality[nPos];

const uint8 nMutuality = pGrid-&gt;nMutuality[nPos];

#else

uint8* const pMutuality = g_xMutuality[nPos];

const uint8 nMutuality = g_nMutuality[nPos];

#endif

pCells[nPos] = nMask + XFILLEDMASK;

pGrid-&gt;pFilledPos[nFilled++] = nPos;

nPos = -1;

#pragma unroll(16)

for(int i = 0; i &lt; nMutuality; ++i)

{

const uint8 nTmp = pMutuality[i];

// 去掉该单元格填充nMask的可能性

pCells[nTmp] &amp;= ~nMask;

// 如果单元格没有可选择的填值方案返回失败

if(pCells[nTmp] == 0) return XFILL_INVALID;

// 判断该单元格是否只有一种填值可能,如果是将调用XFillCell给该单元格填值

if(g_xPopCnt[pCells[nTmp]] == 1) nPos = nTmp;

}

if(nPos &lt; 0) break;

nMask = pCells[nPos];

}

pGrid-&gt;nFilled = nFilled;

return pGrid-&gt;nFilled;

}

迷题加载部分：

1，加载时填充单元格，与XFillCell不同，迷题加载的时候需要判断填值的合法性。

__inline int XFillCellLoad(XGrid* pGrid, XCells pCells, int nPos, int nMask)

{

int nNewPos = -1;

#ifdef XGRID_MUTUALITYSSE_CLEAR

uint8* const pMutuality = pGrid-&gt;pMutuality[nPos];

const uint8 nMutuality = pGrid-&gt;nMutuality[nPos];

#else

uint8* const pMutuality = g_xMutuality[nPos];

const uint8 nMutuality = g_nMutuality[nPos];

#endif

// 如果该单元格已经填充了nMask 直接返回

if(pCells[nPos] == nMask + XFILLEDMASK) return pGrid-&gt;nFilled;

// 判断当前单元格能填nMask表示的值

if((pCells[nPos] &amp; nMask) == 0) return XFILL_INVALID;

// 为第nPos个单元格填上nMask表示的值

pCells[nPos] = nMask + XFILLEDMASK;

for(int i = 0; i &lt; nMutuality; ++i)

{

const uint8 nTmp = pMutuality[i];

// 去掉该单元格填充nMask的可能性

pCells[nTmp] &amp;= ~nMask;

// 如果单元格没有可选择的填值方案返回失败

if(pCells[nTmp] == 0) return XFILL_INVALID;

// 判断该单元格是否只有一种填值可能,如果是将调用XFillCell给该单元格填值

if(g_xPopCnt[pCells[nTmp]] == 1) nNewPos = nTmp;

}

// 记录当前填充的单元格

pGrid-&gt;pFilledPos[pGrid-&gt;nFilled++] = nPos;

if(nNewPos &gt;= 0)

{

if(XFillCell(pGrid, pCells, nNewPos, pCells[nNewPos]) == XFILL_INVALID)

{

// 恢复已经填值的单元格

--pGrid-&gt;nFilled;

return XFILL_INVALID;

}

}

return pGrid-&gt;nFilled;

}

2，加载迷题，将pInupt表示的迷题加载到pGrid中。

// 加载测试数据

__inline int XLoadGrid(XGrid* pGrid, const char* pInput)

{

int nPos = 0;

int nMask = (1 &lt;&lt; XGRID_BSIZE) - 1;

#ifdef XGRID_MUTUALITYSSE_CLEAR

XMEMCOPY(pGrid-&gt;pMutuality, g_xMutuality, sizeof(g_xMutuality));

XMEMCOPY(pGrid-&gt;nMutuality, g_nMutuality, sizeof(g_nMutuality));

#endif

for(nPos = 0; nPos &lt; XGRID_AREA; ++nPos) pGrid-&gt;xCells[nPos]
= nMask;

for(nPos = 0; nPos &lt; XGRID_AREA; ++nPos)

{

if(pInput[nPos] &gt;= '1' &amp;&amp; pInput[nPos] &lt;= '0'
+ XGRID_BSIZE)

{ // 填充nPos的值为1 &lt;&lt; ( pInput[nPos] - '1' )

if(XFillCellLoad(pGrid, pGrid-&gt;xCells, nPos, 1 &lt;&lt; ( pInput[nPos]
- '1' )) == XFILL_INVALID)

{

return XFILL_INVALID;

}

}

}

#ifdef XGRID_MUTUALITYSSE_CLEAR

// [XGRID_BSIZE&gt;=9且需要查找所有情况时清除关联可加速]

for(int i = 0; i &lt; pGrid-&gt;nFilled; ++i)

{

XRemoveMutuality(pGrid, pGrid-&gt;pFilledPos[i]);

}

#endif

return XGRID_AREA - pGrid-&gt;nFilled;

}

迷题寻解部分:

1，查找可填的数字最少的单元格

__inline int XFindMinFeasibilityPos(XCells pCells)

{

int nMinCnt = 0xFF;

int nMinPos = -1;

// 在所有未填值的单元格中查找可填值方案最少的单元格

for(int i = 0; i &lt; XGRID_AREA &amp;&amp; nMinCnt &gt; 1;
++i)

{

if(g_xPopCnt[pCells[i]] &lt; nMinCnt)

{

nMinPos = i;

nMinCnt = g_xPopCnt[pCells[i]];

}

}

return nMinPos;

}

2，迷题求解，将递归展开。

__inline void XFillCellStack(XGrid* pGrid)

{

__declspec(align(16)) XCells xCellsStack[XGRID_AREA + 1];

__declspec(align(16)) int nMinPosStack[XGRID_AREA];

__declspec(align(16)) int nCurValStack[XGRID_AREA];

__declspec(align(16)) int nFilledStack[XGRID_AREA];

int nIndex = 0;

XMEMCOPY(xCellsStack[0], pGrid-&gt;xCells, sizeof(xCellsStack[0]));

// 查找当前填值可能性最少的单元格

nMinPosStack[nIndex] = XFindMinFeasibilityPos(xCellsStack[nIndex]);

nCurValStack[nIndex] = xCellsStack[nIndex][nMinPosStack[nIndex]];

nFilledStack[nIndex] = pGrid-&gt;nFilled;

while( (*pGrid-&gt;pRunMode &amp; XRUN_FIND_FLAG) &amp;&amp;
nIndex &gt;= 0 )

{

nFilledStack[nIndex + 1] = XFILL_INVALID;

// 尝试填充当前单元格

while(nFilledStack[nIndex + 1] == XFILL_INVALID &amp;&amp; nCurValStack[nIndex])

{

XMEMCOPY(xCellsStack[nIndex + 1], xCellsStack[nIndex], sizeof(xCellsStack[0]));

unsigned int nMask = nCurValStack[nIndex] &amp; -nCurValStack[nIndex];

nCurValStack[nIndex] -= nMask;

nFilledStack[nIndex + 1] = XFillCell(pGrid, xCellsStack[nIndex + 1], nMinPosStack[nIndex],
nMask);

}

if(nFilledStack[nIndex + 1] &gt; XGRID_AREA)

{ // 没有合法的填充值

pGrid-&gt;nFilled = nFilledStack[--nIndex];

}

else if(nFilledStack[nIndex + 1] != XGRID_AREA)

{ // 是合法的填充值, 还存在未填值的单元格

++nIndex;

// 查找当前填值可能性最少的单元格

nMinPosStack[nIndex] = XFindMinFeasibilityPos(xCellsStack[nIndex]);

nCurValStack[nIndex] = xCellsStack[nIndex][nMinPosStack[nIndex]];

}

else

{ // 所有单元格均已填值

XAddSolution(pGrid-&gt;pRunMode, pGrid-&gt;pTotal, xCellsStack[nIndex
+ 1]);

pGrid-&gt;nFilled = nFilledStack[nIndex];

}

}

}

3，迷题求解。

// 对pInput表示的迷题求解

int XFindGrid(int nRunMode, const char* pInput)

{

int nTotal = 0;

XGrid xGrid = {0};

xGrid.pRunMode = &amp;nRunMode;

xGrid.pTotal = &amp;nTotal;

// 加载网格数据

switch(XLoadGrid(&amp;xGrid, pInput))

{

case 0:

nTotal = 1;

break;

case XFILL_INVALID:

break;

default:

// 填充单元格

XFillCellStack(&amp;xGrid);

}

return nTotal;

}

并行优化：

串行模式

for(int i = 0; i &lt; nCount; ++i)

{

pTotal[i] = XFindGrid(nRunMode, pInput + i * nLineSize);

}

使用OpenMP优化

#pragma omp parallel for schedule(guided, 1)

for(int i = 0; i &lt; nCount; ++i)

{

pTotal[i] = XFindGrid(nRunMode, pInput + i * nLineSize);

}

使用TBB优化

class CXSudokuTask

{

int m_nRunMode;

int m_nLineSize;

const char* m_pInput;

int* m_pTotal;

public:

CXSudokuTask(int nRunMode, int nLineSize, int* pTotal, const char* pInput)
:

m_nRunMode(nRunMode), m_nLineSize(nLineSize),

m_pTotal(pTotal),m_pInput(pInput){ }

void operator () (const blocked_range&lt;size_t&gt; &amp; r) const

{

for (size_t i = r.begin(); i != r.end(); ++ i)

{

m_pTotal[i] = XFindGrid(m_nRunMode, m_pInput + i * m_nLineSize);

}

}

};

parallel_for(blocked_range&lt;size_t&gt;(0, nCount, max(1, nCount/32)),

CXSudokuTask(nRunMode, nLineSize, pTotal, pInput));

编译说明:

Windows平台:

使用ICC编译.不使用PGO【使用PGO后发现效率降低】

Linux平台:

使用Icpc编译

1.上传压缩包种的Src和Linux两个目录到服务器上.

2.进入Linux目录执行make

3.进入Bin目录 执行文件为XSoduku.

其他:

如果输出结果需要使用英文 请打开XSudoku.h第86行的XUSE_ENGLISH宏定义,默认使用汉语.

需要使用Intel编译器，TBB，请下载并正确安装。

点击下载源码

测试结果:

测试平台：

Time of this report: 4/9/2009, 14:16:02

Machine name: X-DELL

Operating System: Windows XP Professional (5.1, Build 2600) Service Pack 3

(2600.xpsp_sp3_gdr.080814-1236)

Language: Chinese (Regional Setting: Chinese)

System Manufacturer: Dell Inc.

System Model: Vostro 1400

BIOS: Phoenix ROM BIOS PLUS Version 1.10 A03

Processor: Intel(R) Core(TM)2 Duo CPU T5270 @ 1.40GHz (2 CPUs), ~550MHz

Memory: 1014MB RAM

Page File: 812MB used, 1628MB available

Windows Dir: C:\WINDOWS

DirectX Version: DirectX 9.0c (4.09.0000.0904)

DX Setup Parameters: Not found

DxDiag Version: 5.03.0001.0904 32bit Unicode

测试数据为100k个迷题。

使用串行模式测试

XSudoku.exe d100k.in os &gt; ret.txt

计算时间:0.411790秒

输出时间:0.032550秒

总时间:0.444407秒

使用OpenMP并行模式测试

Sudoku.exe d100k.in opo &gt; ret.txt

计算时间:0.209383秒

输出时间:0.034386秒

总时间:0.243842秒

使用TBB并行模式测试

XSudoku.exe d100k.in opt &gt; ret.txt

计算时间:0.216393秒

输出时间:0.035294秒

总时间:0.251751秒

函数性能分析:

根据Vtune采集的数据分析:
目前时间开销最大的是XFillCell该函数功能是为某个单元格填值.Debug版本CPI为0.869.效率比较理想
其次是XFillCellLoad该函数功能是按输入的数据为某个单元格填值.Debug版本CPI为0.70.效率比较理想.

根据Thread Profiler采集数据的分析: 算法并行的时间达到94%,比较完美.