标签：blog io os ar 使用 for sp 数据 div
从接触 Golang 开始，断断续续已有差不多一年左右的时间了，都是业余自己学学看看，尚主要限于语法及语言特性，还没有用它写过实际的项目。
关于 Golang 的语法及语言特性，网上有很多资源可以学习。后面某个时间，我也许会写一篇粗浅的文章，来比较一下 Golang 和 C++、Delphi 甚至 C# 等语言语法方面的特性。
我算是个急性子的人（当然，现在好一些了），于是作为码农，显而易见会对“效率”比较敏感。这里的效率不单单指编译器生成的机器码优化程度，也包括编译器的编译速度，所以我对 C++ 兴趣不算大，虽然它是我平时的工作语言。
言归正传。
分别用 Golang、C++、Delphi 写了四个小例子，包括普通的应用场景、字符串（串接）操作及数据密集计算（当然也会涉及到譬如库函数的优化等）。我的电脑软硬件环境为：Win7 64bit，Xeon E3-1230（8核），16G RAM。Golang 版本是 1.3.1 Windows/386，VC 则用的 VS 2012，而 Delphi 则用的 XE6 Update1。VC 和 Delphi 编译设置为 Win32 & Release，Golang 则使用默认配置。
首先是计算 π 的例子，代码分别如下。
Golang：
package main
import (
"fmt"
"time"
)
const cNumMax = 999999999
func main() {
sign := 1.0
pi := 0.0
t1 := time.Now()
for i := 1; i < cNumMax+2; i += 2 {
pi += (1.0 / float64(i)) * sign
sign = -sign
}
pi *= 4
t2 := time.Now()
fmt.Printf("PI = %f; Time = %d\n", pi, t2.Sub(t1)/time.Millisecond)
}
C++：
#include "stdafx.h"
#include <stdio.h>
#include <time.h>
int _tmain(int argc, _TCHAR* argv[])
{
const int cNumMax = 999999999;
double sign = 1.0;
double pi = 0;
clock_t t1 = clock();
for (int i = 1; i < cNumMax + 2; i += 2)
{
pi += (1.0f / (double)i) * sign;
sign = -sign;
}
pi *= 4;
clock_t t2 = clock();
printf("PI = %lf; Time = %d\n", pi, t2 - t1);
return 0;
}
Delphi：
program PiCalcer;
{$APPTYPE CONSOLE}
{$R *.res}
uses
System.SysUtils, System.DateUtils;
const
cNumMax = 999999999;
var
Sign: Double = 1.0;
Pi : Double = 0.0;
I : Integer;
T1 : Double;
T2 : Double;
S : string;
begin
T1 := Now;
I := 1;
while I < cNumMax + 2 do
begin
Pi := Pi + (1.0 / I) * Sign;
Sign := -Sign;
I := I + 2;
end;
Pi := Pi * 4;
T2 := Now;
S := Format(‘PI = %.6f; Time = %d‘, [Pi, MilliSecondsBetween(T2, T1)]);
Writeln(S);
Readln;
end.
分别执行 10 次，结果如下（单位：毫秒）：
Golang：2038 2028 2036 2024 2034 2015 2034 2018 2024 2018，平均：2026.9；
C++ ：2041 2052 2062 2036 2033 2049 2039 2026 2037 2038，平均：2041.3；
Delphi ：2594 2572 2574 2584 2574 2564 2575 2575 2571 2563，平均：2574.6。
结果居然很不错，比 VC 还快，而 Delphi，大家都懂，优化向来不是它的“强项”。
然后是个质数生成例子。
Golang：
package main
import (
"fmt"
"time"
)
const cNumMax = 10000000
func main() {
t1 := time.Now()
var nums [cNumMax + 1]int
var i, j int
for i = 2; i < cNumMax+1; i++ {
nums[i] = i
}
for i = 2; i < cNumMax+1; i++ {
j = 2
for j*i < cNumMax+1 {
nums[j*i] = 0
j++
}
}
cnt := 0
for i = 2; i < cNumMax+1; i++ {
if nums[i] != 0 {
cnt++
}
}
t2 := time.Now()
fmt.Println("Time:", t2.Sub(t1), " Count:", cnt)
}
C++：
#include "stdafx.h"
#include <stdlib.h>
#include <time.h>
const int cNumMax = 10000000;
int _tmain(int argc, _TCHAR* argv[])
{
clock_t t1 = clock();
int *nums = (int*)malloc(sizeof(int) * (cNumMax + 1));
int i;
for (i = 2; i < cNumMax + 1; i++)
{
nums[i] = i;
}
int j;
for (i = 2; i < cNumMax + 1; i++)
{
j = 2;
while (j * i < cNumMax + 1)
{
nums[j * i] = 0;
j++;
}
}
int cnt = 0;
for (i = 2; i < cNumMax + 1; i++)
{
if (nums[i] != 0)
{
cnt++;
}
}
free(nums);
clock_t t2 = clock();
printf("Time: %dms; Count: %d\n", t2 - t1, cnt);
}
Delphi：
program PrimeSieve;
{$APPTYPE CONSOLE}
{$R *.res}
uses
System.SysUtils, System.DateUtils;
const
cNumMax = 10000000;
var
T1, T2: Double;
I, J : Integer;
Cnt : Integer;
Nums : array of Integer;
begin
T1 := Now;
SetLength(Nums, cNumMax + 1);
for I := 2 to cNumMax do
Nums[I] := I;
for I := 2 to cNumMax do
begin
J := 2;
while J * I < cNumMax + 1 do
begin
Nums[J * I] := 0;
Inc(J);
end;
end;
Cnt := 0;
for I := 2 to cNumMax do
begin
if Nums[I] <> 0 then
Inc(Cnt);
end;
SetLength(Nums, 0);
T2 := Now;
Writeln(Format(‘Cnt = %d; Time = %d‘, [Cnt, MilliSecondsBetween(T2, T1)]));
Readln;
end.
同样分别执行 10 次，结果如下（单位：毫秒）：
Golang：959 957 959 953 961 951 948 956 956 956，平均：955.6；
C++ ：965 965 967 953 961 964 963 960 956 956，平均：961；
Delphi ： 973 976 973 982 981 970 977 979 971 977，平均：975.9；
仍然，Golang 看上去最快，而 Delphi 则很正常地居末。
所以我忍不住想要来一个能展现 Delphi 优点的例子，这个例子几乎毫无疑问，和字符串操作（及内存管理器）相关，所以有如下字符串串接的示例（其中涉及到了譬如 IntToStr / itoa 这样的函数调用，我自己实现了个 C++ 版的 IntToStr）。
Golang：
package main
import (
"bytes"
"fmt"
"strconv"
"time"
)
const cNumMax = 1000000
// bytes.Buffer(7.2.6)
func testViaBuffer() string {
var buf bytes.Buffer
for i := 0; i < cNumMax; i++ {
buf.WriteString(strconv.Itoa(i))
}
return buf.String()
}
// +=
func testViaNormal() string {
var ret string
for i := 0; i < cNumMax; i++ {
ret += strconv.Itoa(i)
}
return ret
}
func main() {
fmt.Println("Test via bytes.Buffer...")
t1 := time.Now()
s := testViaBuffer()
t2 := time.Now()
fmt.Printf("Result: %s...(Length = %d); Time: %dms\n\n", s[2000:2005], len(s), t2.Sub(t1)/time.Millisecond)
fmt.Println("Test via normal way...")
t1 = time.Now()
s = testViaNormal()
t2 = time.Now()
fmt.Printf("Result: %s...(Length = %d); Time: %dms\n", s[2000:2005], len(s), t2.Sub(t1)/time.Millisecond)
}
C++：
#include "stdafx.h"
#include <time.h>
#include <stdarg.h>
#include <string>
#include <iostream>
using namespace std;
const int cNumMax = 1000000;
wstring FormatV(const wchar_t* pwcFormat, va_list argList)
{
wstring ws;
int nLen = _vscwprintf(pwcFormat, argList);
if (nLen > 0)
{
ws.resize(nLen);
vswprintf_s(&ws[0], nLen + 1, pwcFormat, argList);
}
return ws;
}
wstring __cdecl Format(const wchar_t* pwcFormat, ...)
{
va_list argList;
va_start(argList, pwcFormat);
wstring ws = FormatV(pwcFormat, argList);
va_end(argList);
return ws;
}
string FormatVA(const char* pcFormat, va_list argList)
{
string s;
int nLen = _vscprintf(pcFormat, argList);
if (nLen > 0)
{
s.resize(nLen);
vsprintf_s(&s[0], nLen + 1, pcFormat, argList);
}
return s;
}
string __cdecl FormatA(const char* pcFormat, ...)
{
va_list argList;
va_start(argList, pcFormat);
string s = FormatVA(pcFormat, argList);
va_end(argList);
return s;
}
wstring IntToStr(int nValue)
{
return Format(L"%d", nValue);
}
string IntToStrA(int nValue)
{
return FormatA("%d", nValue);
}
wstring testW()
{
wstring ret = L"";
for (int i = 0; i < cNumMax; i++)
{
ret += IntToStr(i);
}
return ret;
}
string test()
{
string ret = "";
for (int i = 0; i < cNumMax; i++)
{
ret += IntToStrA(i);
}
return ret;
}
int _tmain(int argc, _TCHAR* argv[])
{
cout << "Starting test with a loop num of " << cNumMax << endl;
clock_t t1 = clock();
string s = test();
clock_t t2 = clock();
cout << "Result: " << s.substr(2000, 5) << "..." << "; Size: " << s.size() << "; Time: " << t2 - t1 << "ms" << endl;
cout << endl;
cout << "Starting test for WSTRING with a loop num of " << cNumMax << endl;
t1 = clock();
wstring ws = testW();
t2 = clock();
wcout << "Result: " << ws.substr(2000, 5) << "..." << "; Size: " << ws.size() << "; Time: " << t2 - t1 << "ms" << endl;
return 0;
}
Delphi：
program StrPerformanceTest;
{$APPTYPE CONSOLE}
{$R *.res}
uses
System.SysUtils, System.DateUtils;
const
cNumMax = 1000000;
function TestViaStringBuilder: string;
var
SB: TStringBuilder;
I : Integer;
begin
SB := TStringBuilder.Create;
for I := 0 to cNumMax - 1 do
SB.Append(IntToStr(I));
Result := SB.ToString;
FreeAndNil(SB);
end;
function TestViaNormal: string;
var
I : Integer;
begin
Result := ‘‘;
for I := 0 to cNumMax - 1 do
Result := Result + IntToStr(I);
end;
var
T1: Double;
T2: Double;
S : string;
begin
Writeln(‘Starting test with a loop num of ‘, cNumMax, ‘...‘);
T1 := Now;
S := TestViaStringBuilder;
T2 := Now;
Writeln(Format(‘Test via TStringBuilder result: %s...(Length = %d); Time: %dms‘, [Copy(S, 2001, 5), Length(S), MilliSecondsBetween(T2, T1)]));
T1 := Now;
S := TestViaNormal;
T2 := Now;
Writeln(Format(‘Test via normal-way(+=) result: %s...(Length = %d); Time: %dms‘, [Copy(S, 2001, 5), Length(S), MilliSecondsBetween(T2, T1)]));
Readln;
end.
分别执行 10 次（单位：毫秒）。悲剧的是，Golang 里的字符串 += 操作实在太慢了，我实在不想等下去，所以只给出了其官方推荐的使用 bytes.Buffer 的结果。而在这个例子中，Delphi 使用 TStringBuilder 并未显示出什么优化（FastMM 实在太强悍了！），所以我也只给出了普通的串接结果（AnsiString 和 string 都是 Delphi 的原生类型，效率上应没有什么差别，所以这里只测试了 string）。
Golang ：141 148 134 119 133 123 145 127 122 132，平均：132.4；
C++（std::string） ：384 400 384 385 389 391 389 384 390 383，平均：387.9；
C++（std::wstring） ：519 521 522 521 519 522 518 519 518 518，平均：519.7；
Delphi（string） ：41 41 41 41 41 41 41 41 44 41，平均：41.3；
果然，Delphi 大幅领先，当然这主要归功于 FastMM，这个开源的 Pascal 家族的内存管理器实在太强大了！
当然这个测试对 C++ 并不公平，因为 Golang 的写法并非普通的串接，只是我不知道 STL 或 Boost 里有无类似 StringBuilder 这样的利器呢？
最后是个数据密集计算型的例子，结果如下（单位：毫秒）。
Golang：
package main
import (
"fmt"
"time"
)
const cSize int = 30
type mymatrix [cSize][cSize]int
func mkmatrix(rows, cols int, mx *mymatrix) {
rows--
cols--
count := 1
for r := 0; r <= rows; r++ {
for c := 0; c <= cols; c++ {
mx[r][c] = count
count++
}
}
}
func multmatrix(rows, cols int, m1, m2 *mymatrix, mm *mymatrix) {
rows--
cols--
for i := 0; i <= rows; i++ {
for j := 0; j <= cols; j++ {
val := 0
for k := 0; k <= cols; k++ {
val += m1[i][k] * m2[k][j]
mm[i][j] = val
}
}
}
}
func main() {
var m1, m2, mm mymatrix
mkmatrix(cSize, cSize, &m1)
mkmatrix(cSize, cSize, &m2)
t0 := time.Now()
for i := 0; i <= 100000; i++ {
multmatrix(cSize, cSize, &m1, &m2, &mm)
}
t := time.Since(t0)
fmt.Println(mm[0][0], mm[2][3], mm[3][2], mm[4][4], mm[29][29])
fmt.Println("tick = ", t)
}
C++：
#include "stdafx.h"
#include <time.h>
#include <iostream>
using namespace std;
const int MATRIX_SIZE = 30;
int Matrix[MATRIX_SIZE][MATRIX_SIZE];
void MakeMatrix(int rows, int cols, int mx[MATRIX_SIZE][MATRIX_SIZE])
{
rows--;
cols--;
int count = 1;
for (int r = 0; r <= rows; r++)
{
for (int c = 0; c <= cols; c++)
{
mx[r][c] = count;
count++;
}
}
}
void MatrixMult(int rows, int cols, const int m1[MATRIX_SIZE][MATRIX_SIZE], const int m2[MATRIX_SIZE][MATRIX_SIZE], int mx[MATRIX_SIZE][MATRIX_SIZE])
{
rows--;
cols--;
int val;
for (int i = 0; i <= rows; i++)
{
for (int j = 0; j <= cols; j++)
{
val = 0;
for (int k = 0; k <= cols; k++)
{
val += m1[i][k] * m2[k][j];
mx[i][j] = val;
}
}
}
}
int _tmain(int argc, _TCHAR* argv[])
{
int num = 100000;
int m1[MATRIX_SIZE][MATRIX_SIZE], m2[MATRIX_SIZE][MATRIX_SIZE], mx[MATRIX_SIZE][MATRIX_SIZE];
MakeMatrix(MATRIX_SIZE, MATRIX_SIZE, m1);
MakeMatrix(MATRIX_SIZE, MATRIX_SIZE, m2);
clock_t t1 = clock();
for (int i = 0; i <= num; i++)
{
MatrixMult(MATRIX_SIZE, MATRIX_SIZE, m1, m2, mx);
}
clock_t t2 = clock();
cout << mx[0][0] << " " << mx[2][3] << " " << mx[3][2] << " " << mx[4][4] << endl;
cout << t2 - t1 << " ms" << endl;
return 0;
}
Delphi：
program Project1;
{$APPTYPE CONSOLE}
{$R *.res}
uses
System.SysUtils, System.DateUtils;
const
cSize = 30;
type
TMatrix = array[0..cSize - 1, 0..cSize - 1] of Integer;
procedure MakeMatrix(Rows, Cols: Integer; var Mx: TMatrix);
var
R, C, Count: Integer;
begin
Dec(Rows);
Dec(Cols);
Count := 1;
for R := 0 to Rows do
for C := 0 to Cols do
begin
Mx[R, C] := Count;
Inc(Count);
end;
end;
procedure MatrixMult(Rows, Cols: Integer; const M1, M2: TMatrix; var Mx: TMatrix); inline;
var
I, J, K, Val: Integer;
begin
Dec(Rows);
Dec(Cols);
for I := 0 to Rows do
for J := 0 to Cols do
begin
Val := 0;
for K := 0 to Cols do
Inc(Val, M1[I, K] * M2[K, J]);
Mx[I, J] := Val;
end;
end;
var
Num, I : Integer;
M1, M2, Mx: TMatrix;
T1, T2 : Double;
begin
Num := 100000;
MakeMatrix(cSize, cSize, M1);
MakeMatrix(cSize, cSize, M2);
T1 := Now;
for I := 0 to Num do
MatrixMult(cSize, cSize, M1, M2, Mx);
T2 := Now;
WriteLn(Mx[0, 0], ‘ ‘, Mx[2, 3], ‘ ‘, Mx[3, 2], ‘ ‘, Mx[4, 4], ‘ ‘, mx[29, 29]);
WriteLn(‘ C = ‘, MilliSecondsBetween(T2, T1), ‘ ms‘);
end.
分别执行 10 次后结果如下（单位：毫秒）。
Golang：8757 8790 8713 8748 8737 8744 8752 8752 8746 8754，平均：8749.3；
C++ ：1723 1735 1714 1707 1713 1725 1708 1723 1720 1725，平均：1719.3；
Delphi ：2384 2362 2359 2389 2362 2351 2340 2352 2356 2352，平均：2360.7；
在这样的密集运算例子里，Golang 的表现实在很差，Golang 的编译器优化很有很长的路。而 Delphi 则不出意外，不温不火，勉强也还算能接受吧。
至此，或许大致可以这样初步评断，Golang 在大部分应用场景下在效率方面是满足要求的，而若涉及到密集运算，当前比较好的方法应该是要通过 CGo 了。考虑到 Golang 强大的 goroutine 和 channel、丰富的标准库（譬如网络方面）、精简的语法和非常快速的编译速度（几乎媲美 Delphi），后端开发尝试下 Golang 应是比较可行的，而也确实有不少早已用 Golang 作后端开发的项目实例了。
注：关于 Golang 的语言语法及并行方面的特性，过段时间再浅叙。
标签：blog io os ar 使用 for sp 数据 div
原文地址：http://www.cnblogs.com/ecofast/p/4043873.html
