中文 » 博客征文专栏

Metro Web应用开发中页面通信问题解决方法

Dawei Cheng 程大伟 (Intel) — Tue, 15 May 2012 12:20:13 +0000

最近在开发Win8应用，遇到Win8 native context和web context 通信的问题，这里将相应的方法分析一下。Win8的介绍和详细信息可以在MSDN上面获得，也可以参考本人介绍开发者预览版时的系列博客

Win8 应用开发介绍（一） Win8新特性\
Win8 应用开发介绍（二） Win8应用为王\
Win8 应用开发介绍（三） Win8开发者工具\
Win8 应用开发介绍（四） Win8应用开发步骤\
Win8 应用开发介绍（五） Win8硬件支持和安全性\
Win8 应用开发介绍（六） Win8伴你随行\

1. 问题描述

Win8可是使用HTML, JavaScript方式来开发Metro Style App。那么传统的HTML网页中，加载web端的JavaScript文件采用的代码方式仍然可以使用吗？如：

src=file:///****.html 或者src=http://****.html 是需要加载web context 的页面，在相应的html文件中可以自由加载remote URL的内容。

在页面中的关系图如下：

通信

现在的问题出现了，Web Context如何和Local Context通信了。Win8 IE全面支持了HTML5，在HTML5中可以使用HTML5 postMessage method在不通的页面中进行通信。

假设我们在Local Context中新建一个button，代码如下：

在JavaScript中，添加ZoomOut函数：

在Web Context中，添加receiveMessage(event) 参考代码如下：

function receiveMessage(event) { switch (event.data.method) { ...... case 'zoomout': var currentZoom = map.getZoom(); map.setView({ zoom: currentZoom - 1 }); break; } }

本篇完。
参考文章：http://alastaira.wordpress.com/2011/09/26/creating-a-windows-8-metro-slippy-map-application/

C#多线程参数传递

hlaite — Mon, 07 May 2012 10:23:30 +0000

C#多线程参数传递

查看评论

在多线程或单线程任务中,让线程带传入参数一直是个麻烦的问题,通常有种方法就是以类,对像的变量来传参数,这种方法理解上很简单不过在某些场合使用很麻烦,这里就不介绍了,我们主要介绍一种.NET2.0中新增加的带参数运行线程的方法,示例程序如下:

ParameterizedThreadStart ParStart = new ParameterizedThreadStart(ThreadMethod);
Thread myThread = new Thread(ParStart);
object o = “hello”;
myThread.Start(o);

ThreadMethod如下:
public void ThreadMethod(object ParObject)
{
//程序代码
}

如果是多参数的话可以以数组或动态列表等方式装相入 object,然后使用时拆箱即可

这样是不是简单多了哈,,,
———————————————————————————–
[转]个人认为，还是为线程创建一个单独的类，在类的初始化函数里头为类里头的变量赋值，来达到传入参数比较简单。下面有些方法是有问题的，不过我已经达到了目的就懒得去排错了，哪位朋友看出问题了提醒一下啊。呵呵…

方法一：
在VS2003中，也不能直接访问，参看
一般来说，直接在子线程中对窗体上的控件操作是会出现异常，这是由于子线程和运行窗体的线程是不同的空间，因此想要在子线程来操作窗体上的控件，是不可能简单的通过控件对象名来操作，但不是说不能进行操作，微软提供了Invoke的方法，其作用就是让子线程告诉窗体线程来完成相应的控件操作。

现在用一个用线程控制的进程条来说明，大致的步骤如下：

1．创建Invoke函数，大致如下：
///
/// Delegate function be invoked by main thread
///

private void InvokeFun()
{
if(prgBar.Value< 100)
prgBar.Value = prgBar.Value + 1;
}

2．子线程入口函数：
///
/// Thread function interface
///

private void ThreadFun()
{
// Create invoke method by specific function
MethodInvoker mi = new MethodInvoker(this.InvokeFun);

for(int i=0; i<100; i++)
{
this.BeginInvoke(mi);
Thread.Sleep(100);
}
}

3.创建子线程：
Thread thdProcess = new Thread(new ThreadStart(ThreadFun));
thdProcess.Start();

备注：
using System.Threading;
private System.Windows.Forms.ProgressBar prgBar;

方法二：
加入该句：Control.CheckForIllegalCrossThreadCalls = False 取消线线程安全保护模式！

方法三：带参数
使用类、类的方法或类的属性都可以向线程传递参数：
public class UrlDownloader
{
string url;

public UrlDownloader (string url)
{
this.url = url;
}

public void Download()
{
WebClient wc = new WebClient();
Console.WriteLine(“Downloading ” + url);
byte[] buffer = wc.DownloadData (url);
string download = Encoding.ASCII.GetString(buffer);
Console.WriteLine(download);
Console.WriteLine(“Download successful.”);

//这里你可以将download进行保存等处理……
}
}

[... 在另一个类中使用它们...]

UrlDownloader downloader = new UrlDownloader (yourUrl);
new Thread (new ThreadStart (downloader.Download)).Start();

注意参数是如何传递的。

方法四：带参数
ThreadStart starter = delegate { Download(yourUrl); };
new Thread(starter).Start();

//使用线程�
WaitCallback callback = delegate (object state) { Download ((string)state); };
ThreadPool.QueueUserWorkItem (callback, yourUrl);

方法五：带参数
Thread t = new Thread (new ParameterizedThreadStart(DownloadUrl));
t.Start (myUrl);
static void DownloadUrl(object url)
{
// ….
}
—————————————————————————-

—————————————————————————-
C#线程调用带参数的方法
之前做了一个小的应用程序，用的是c#语言，在做的过程中遇到了一个困难，就是不如调用带参数的线程，经过查找网上的资料，找到了简单的解决方案。
在以前的学习中，我们经常碰到的是没有带参数的线程，所以当遇到必须用到参数的线程时就会手足无措，现在我们用的这种解决问题的方法，实际上的原理是：将线程执行的方法和参数都封装到一个类里面。通过实例化该类，方法就可以调用属性来实现间接的类型安全地传递参数。看如下代码：

using System;
using System.Threading;

//ThreadWithState 类里包含了将要执行的任务以及执行任务的方法
public class ThreadWithState {
//要用到的属性，也就是我们要传递的参数
private string boilerplate;
private int value;

//包含参数的构造函数
public ThreadWithState(string text, int number)
{
boilerplate = text;
value = number;
}

//要丢给线程执行的方法，本处无返回类型就是为了能让ThreadStart来调用
public void ThreadProc()
{
//这里就是要执行的任务,本处只显示一下传入的参数
Console.WriteLine(boilerplate, value);
}
}
－－－－－－－－－－－－－－－分隔线－－－－－－－－－－－－－－－
//用来调用上面方法的类，是本例执行的入口
public class Example {
public static void Main()
{
//实例化ThreadWithState类，为线程提供参数
ThreadWithState tws = new ThreadWithState(
“This report displays the number {0}.”, 42);

// 创建执行任务的线程，并执行
Thread t = new Thread(new ThreadStart(tws.ThreadProc));
t.Start();
Console.WriteLine(“Main thread does some work, then waits.”);
t.Join();
Console.WriteLine(
“Independent task has completed; main thread ends.”);
}
}
从上面的例子就能很清楚的得到我们想要的结果，注意这句代码的用法：
Thread t = new Thread(new ThreadStart(tws.ThreadProc));

显式算法和隐式算法的并行化比较

xianjianqi — Mon, 07 May 2012 10:22:57 +0000

１显式算法
显式算法基本假定为：在一微小时间段内，模型任意点速度、加速度为常数。ABAQU S软件 Explicit 模块应用中心差分法对运动方程进行显式时间积分，
运动方程的解为
¨ｕ（ｉ）＝Ｍ－１·（Ｆ（ｉ）－Ｉ（ｉ））（１）
式中：Ｍ为集中质量矩阵；Ｆ为外荷载向量；Ｉ为单元内力向量。
由于显式算法中不需要对刚度矩阵求逆，集中质量矩阵为对角矩阵，求逆简便，使显式算法并行计算数据传输量较小；且显式算法刚度矩阵大小与自由度数成线性关系，因此显式算法用于自由度数庞大的数值计算时具有很大优势。

2 隐式算法
隐式算法含义为：ｔ＋Δｔ时刻状态不仅与ｔ时刻状态有关，且与ｔ＋Δｔ时刻某些量有关。ＡＢＡＱＵＳ软件Ｓｔａｎｄａｒｄ应用Ｈｉｌｂｅｒ－Ｈｕｇｈｅｓ－Ｔａｙｌｏｒ隐式算法、Ｎｅｗｔｏｎ－Ｒａｐｈｓｏｎ迭代法进行动力方程求解［１０］。运动方程解为
Δｕ（ｉ＋１）＝Δｕ（ｉ）＋Ｋt－１ ·（Ｆ（ｉ）－Ｉ（ｉ））（２）
式中：Ｋｔ为当前切线刚度矩阵：Δｕ为位移增量。

求解方程位移增量Δｕ（ｉ＋１）时，必须对刚度矩阵Ｋ求逆。当自由度数非常庞大时，这项计算消耗资源。对Ｋ矩阵的求逆计算，计算机之间数据传输量非常大，随着自由度数增加，刚度矩阵Ｋ大小成指数增长。因此，隐式算法用于自由度数庞大的数值计算时，优势不明显，甚至会降低计算效率。

根据地铁地下结构抗震研究需要，对有限元并行计算显式算法和隐式算法计算精度和效率进行比较，
主要结论如下：
（１）有限元并行计算中心差分显式算法与Ｈｉｌｂｅｒ－Ｈｕｇｈｅｓ－Ｔａｙｌｏｒ隐式算法计算精度相当，显式算法计算效率远高于隐式算法。
（２）黏弹性人工边界在显式算法和隐式算法中，都能起到很好的模拟效果。
（３）显式算法和隐式算法计算相对位移、相对速度时程基本一致，两种算法峰值应力差在９％以内。
（４）地铁地下结构抗震分析中，对于自由度很大的三维结构，并行计算显式算法计算效率较高；而对于自由度较小的二维结构，并行计算隐式算法计算效率较高。
（５）显式算法适合多处理器并行运算，对庞大自由度的地下结构三维非线性抗震分析，具有较好的并行计算效率。对于ＣＰＵ具体使用数和计算模型自由度的关系，尚需进一步研究。

Android 多线程编程

blogercn — Mon, 07 May 2012 10:21:36 +0000

android的应用程序支持多线程，多线程编程为我们充分利用系统资源提供了便利，同时也为设计复杂UI和耗时操作提供了途径，提升了安卓用户的使用体验。Android的多线程和JAVA没有多大变化，唯一的变化大概在于无法直接使用CANVAS修改屏幕元素，当然安卓为我们提供了surfaceview类来实现多线程中通过画布canvas修改屏幕。这为设计UI和开发游戏带来了方便。因此，研究和使用多线程编程，对我们深入学习安卓编程有着十分重要的作用。

线程的方法比较多，常用的有：

start()；

run()；

sleep()；

stop()；

destroy()；

join();

suspend()；

resume()；

yield()；
wait()；
notify()；

线程启动一定要使用start方法,线程操作使用run方法，线程休眠使用sleep方法，线程停止使用stop,线程销毁使用destroy方法,线程同步使用JOIN方法，前面三种最常用，一般来说这三种就可以满足大部分线程使用需求，run结束时线程自动死亡，stop,destroy虽然也能停止线程，但不推荐使用，,前者会产生异常，后者是强制终止，不会释放锁，一般会在RUN里设置一个状态信号来等其自动结束，这里使用volatile boolean bThreadRun。后面是暂停，继续，挂起，由于会产生死锁问题，很少使用。大部分情况会使用wait和notify替代；

这里我使用一个线程来计算变量并更新窗口标题。主要代码如下：使用eclipse创建一个项目。为Activity添加onStart，onPause, onStop等方法，Activity是我们最常使用的一个类，也是android的核心类，为应用程序管理并显示一个屏幕，开发的人不应该对其陌生。Activity活动主要的方法有，onCreate，onStart，onStop，onPause，onResume， onRestart，onDestroy，onRestoreInstanceState，onSaveInstanceState，一般的执行顺序是，onCreate，onStart，onResume，当窗口不是最顶层时，执行onPause，onstop,为顶层时，执行onRestart，onResume，一直循环，直到onDestroy.如果保存窗口，重载onSaveInstanceState，并在进入时重载onRestoreInstanceState。这里我在Activity的方法onStart里创建线程：

01.MyThread myThread = new MyThread();
02. myThread.start();

在下面添加MyThread的实现代码：

01.public class MyThread extends Thread {
02. // 声明字符串变量
03. public MyThread() {
04. }
05.
06. @Override
07. public void start() {
08. super.start();
09. }
10.
11. // 线程的主要工作方法
12. @Override
13. public void run() {
14. while (true) {
15. try {
16. sleep(5000);
17. if (c > ((1 << 31) - 1)) {
18. c = 0;
19. } else {
20. c++;
21. }
22. Message message = new Message();
23. message.what = 1;
24. mHandler.sendMessage(message);
25. } catch (InterruptedException ex) {
26. }
27. }
28. }
29.
30. }

实现updatetitle方法：

01.public void updateTitle() {
02. setTitle("test thread " + c);
03. }

这里没有使用updatetitle直接更新窗口，而是使用handler,这是因为直接使用是不安全的，会造成线程重启等问题。Android 引进了Handler 这个特殊的类，用它作为Runnable和Activity交互的桥梁，所以我们只能在run方法中发送Message,而在Handler里，通过不同的Message执行不同的任务。为程序添加handler；

01.private Handler mHandler = new Handler() {
02. public void handleMessage(Message msg) {
03. switch (msg.what) {
04. case 1:
05. updateTitle();
06. break;
07. }
08. };
09. };

最后完整的代码如下，使用线程处理数据，并把数据显示在窗口上：

01.package com.test;
02.
03.import android.app.Activity;
04.import android.os.Bundle;
05.import java.lang.Thread;
06.import android.os.Message;
07.import android.os.Handler;
08.import android.graphics.Color;
09.
10.public class TestThreadActivity extends Activity {
11. int c = Color.BLUE;
12. MyThread myThread;
13. volatile boolean bThreadRun = false;
14.
15. /** Called when the activity is first created. */
16. @Override
17. public void onCreate(Bundle savedInstanceState) {
18. super.onCreate(savedInstanceState);
19. setContentView(R.layout.main);
20. }
21.
22. @Override
23. protected void onRestoreInstanceState(android.os.Bundle savedInstanceState) {
24. super.onRestoreInstanceState(savedInstanceState);
25. }
26.
27. @Override
28. protected void onSaveInstanceState(android.os.Bundle outState) {
29. super.onSaveInstanceState(outState);
30. }
31.
32. @Override
33. protected void onStart() {
34. super.onStart();
35. myThread = new MyThread();
36. myThread.start();
37. bThreadRun = true;
38. }
39.
40. @Override
41. protected void onRestart() {
42. super.onRestart();
43. }
44.
45. @Override
46. protected void onResume() {
47. super.onResume();
48. }
49.
50. @Override
51. protected void onPause() {
52. super.onPause();
53. bThreadRun = false;
54. // myThread.stop();
55. }
56.
57. @Override
58. protected void onStop() {
59. super.onStop();
60. onPause();
61. }
62.
63. @Override
64. protected void onDestroy() {
65. super.onDestroy();
66. // myThread.destroy();
67. }
68.
69. private Handler mHandler = new Handler() {
70. public void handleMessage(Message msg) {
71. switch (msg.what) {
72. case 1:
73. updateTitle();
74. break;
75. }
76. };
77. };
78.
79. public void updateTitle() {
80. setTitle("test thread " + c);
81. setTitleColor(c);
82. }
83.
84. public class MyThread extends Thread {
85. // 声明字符串变量
86. public MyThread() {
87. }
88.
89. @Override
90. public void start() {
91. super.start();
92. }
93.
94. // 线程的主要工作方法
95. @Override
96. public void run() {
97. while (bThreadRun) {
98. try {
99. sleep(100);
100. if (c > ((1 << 16) - 1)) {
101. c = 0;
102. } else {
103. c += 100;
104. }
105. Message message = new Message();
106. message.what = 1;
107. mHandler.sendMessage(message);
108. } catch (InterruptedException ex) {
109. }
110. }
111. }
112.
113. }
114.
115.}

线程还有另外一种常用的方法是编写Runnable接口，这里对代码做一些修改，使用线程实现对主窗口重绘，全部代码如下：

01.package com.test;
02.
03.import android.app.Activity;
04.import android.content.Context;
05.import android.os.Bundle;
06.import java.lang.Thread;
07.import android.view.View;
08.import android.graphics.Canvas;
09.import android.graphics.Color;
10.import android.graphics.Paint;
11.import android.graphics.Paint.Style;
12.import android.graphics.Rect;
13.
14.public class TestThreadActivity extends Activity {
15. int c = Color.BLUE;
16. MyThread myThread;
17. volatile boolean bThreadRun = false;
18. MyView mv;
19.
20. /** Called when the activity is first created. */
21. @Override
22. public void onCreate(Bundle savedInstanceState) {
23. super.onCreate(savedInstanceState);
24. // setContentView(R.layout.main);
25. mv = new MyView(this);
26. setContentView(mv);
27. }
28.
29. public class MyView extends View {
30. MyView(Context context) {
31. super(context);
32. }
33.
34. @Override
35. protected void onDraw(Canvas canvas) {
36. // TODO Auto-generated method stub
37. super.onDraw(canvas);
38.
39. // 首先定义一个paint
40. Paint paint = new Paint();
41.
42. // 绘制矩形区域-实心矩形
43. // 设置颜色
44. paint.setColor(c);
45. // 设置样式-填充
46. paint.setStyle(Style.FILL);
47. // 绘制一个矩形
48. canvas.drawRect(new Rect(0, 0, getWidth(), getHeight()), paint);
49. }
50.
51. }
52.
53. @Override
54. protected void onRestoreInstanceState(android.os.Bundle savedInstanceState) {
55. super.onRestoreInstanceState(savedInstanceState);
56. }
57.
58. @Override
59. protected void onSaveInstanceState(android.os.Bundle outState) {
60. super.onSaveInstanceState(outState);
61. }
62.
63. @Override
64. protected void onStart() {
65. super.onStart();
66. //myThread = new MyThread();
67. //myThread.start();
68. new Thread (new MyThread()).start();
69. bThreadRun = true;
70. }
71.
72. @Override
73. protected void onRestart() {
74. super.onRestart();
75. }
76.
77. @Override
78. protected void onResume() {
79. super.onResume();
80. }
81.
82. @Override
83. protected void onPause() {
84. super.onPause();
85. bThreadRun = false;
86. // myThread.stop();
87. }
88.
89. @Override
90. protected void onStop() {
91. super.onStop();
92. onPause();
93. }
94.
95. @Override
96. protected void onDestroy() {
97. super.onDestroy();
98. // myThread.destroy();
99. }
100.
101. public class MyThread implements Runnable{
102. // 线程的主要工作方法
103. @Override
104. public void run() {
105. while (bThreadRun) {
106. try {
107. Thread.sleep(500);
108. if (c > ((1 << 31) - 1)) {
109. c = 0;
110. } else {
111. c += 100;
112. }
113. mv.postInvalidate();
114. } catch(InterruptedException e){
115. }
116. }
117. }
118.
119. }
120.
121.}

关于core_uses_pid 标志对多线程程序无用的调查

cobps — Mon, 07 May 2012 10:20:42 +0000

一、案例的起因

在工作的过程中，发现在RHEL5.6系统下，运行进程，一旦应用线程，出core后，总会带着进程ID。即使在系统中设置core_uses_pid=0，也是不行的。

这样的话如果应用系统出现core文件，那么会是悲剧性的。磁盘空间被占满等情形都会出现的。

如何让我们的core_file的名字保持唯一或者有限个数呢？

二、资料的查询与分析

在网上“https://bugzilla.kernel.org”发现了这个bug的存在，简要信息如下：

Bug 6312 - core_uses_pid=0 not always honored

Status:

REJECTED WILL_NOT_FIX

Reported:

2006-03-30 15:10 by David M. Lee

Status:REJECTED WILL_NOT_FIX

Reported:2006-03-30 15:10 by David M. Lee

Product:Other

Modified:2007-01-31 01:03 (History)

Component:Other

Kernel Version:2.6.15.2

Version:2.5

Tree:Mainline

Platform:i386 Linux

Regression:---

Importance:P2 normal

Assigned To:other_other@kernel-bugs.osdl.org

URL:
Depends on:
Blocks:
Show dependency tree / graph
详细信息参见：https://bugzilla.kernel.org/show_bug.cgi?id=6312

从该信息中获知，产生core文件时，名字是由函数format_corename来执行的。所以，针对内核源码“linux-2.6.27.62 和linux-3.2.7”做了分析。发现在3.2.7版本的内核中修复了改BUG。

经过对该函数的分析，发现我们之所以出现问题，就是由于参数nr_threads引起的，而这个参数的含义就是使用该资源的线程个数，该值是被内敛函数“zap_threads”来设置的。

而这段代码基本上是不可避免的都要走到的。我们如何跳过这段代码呢？如何让nr_threads不起作用呢？
/*Backward compatibility with core_uses_pid:

*

* If core_pattern does not include a %p (as isthe default)

* and core_uses_pid is set, then .%pid will beappended to

* the filename. Do not do this for pipedcommands. */

if(!ispipe && !pid_in_pattern

&& (core_uses_pid || nr_threads)) {

rc= snprintf(out_ptr, out_end - out_ptr,

".%d", task_tgid_vnr(current));

if(rc > out_end - out_ptr)

gotoout;

out_ptr+= rc;

}

Fork为何会遵循core_uses_pid的设置呢？参见zap_threads中的解释。

*fork:

* None of sub-threads can fork afterzap_process(leader). All

* processes which were created before thispoint should be

* visible to zap_threads() becausecopy_process() adds the new

* process to the tail of init_task.tasks list,and lock/unlock

* of ->siglock provides a memory barrier.

从函数实现中我们可以发现如下代码。

if (rc > out_end - out_ptr)

goto out;

这个是表示的core文件名字的长度，那么最大长度CORENAME_MAX_SIZE是多大呢？

在binfmts.h中定义：#defineCORENAME_MAX_SIZE 128

所以，我们采用边界值越界跳出上面那段让人头疼的代码。

测试的设置方法如下：设置文件名字长度core+123字符的形式定向到/proc/sys/kernel/core_pattern中。

[root@tcore]$echo"core123456789101234567891012345678910123456789101234567891012345678910123456789101234567891012345678910123456789101234567891012345678910123"> /proc/sys/kernel/core_pattern

测试程序：

#include
#include
#include
#include
#include

#define NUM 3

void *thread_run()
{
printf("hello, I am thread[%llu]\n", pthread_self());
sleep(3);
abort();
return NULL;
}

int thread_pool_run()
{
int i;
pthread_t th[NUM];

for(i=0; i printf("thread create\n");
pthread_create(&th[i], NULL, thread_run, NULL);
}
for(i=0; i pthread_join(th[i], NULL);
printf("thread exit\n");
}
return 0;
}

int main()
{
int stat;
pid_t pid;

if((pid = fork()) < 0){
printf("fork error\n");
}else if(pid == 0){
printf("fork successful\n");
stat = thread_pool_run();
exit(stat);
}

pause();
return 0;
}

执行结果：

达到目的了。

OpenMP 概述

xwebsite — Mon, 07 May 2012 10:19:20 +0000

根据计算平台和规模的不同，并行计算可以分为两种：第一种是基于单一计算机系统的多核处理器或多处理器进行多线程并行计算，采用共享存储的方式，主要的标准有OpenMP，如下左图所示；第二种就是基于多台计算机组件的集群（Cluster）计算系统进行并行计算，采用消息传递方式，主要的标准有MPI，如下右图所示。本文将主要介绍多线程方式的并行计算。

首先来了解一下单核处理器上程序运行方式，系统中包括操作系统和应用程序等都以进程（Process）形式存在，当程序结束时这个进程也就跟着消亡。每个进程中至少包含一个线程（Thread），一个线程用于完成程序的某个功能，一个程序中一般都包含多个线程，所有的这些线程在系统中都成队列形式。对于一个核心的处理器来说，某一时刻，它只能处理一个线程。这个线程处理之后就处理下一个线程，依次循环处理。由于CPU的主频都非常高，如Intel的奔四可到3GHz，所以每个线程处理的时间都非常短，以致我们并不会察觉。但是它们实际上是以串行的形式在CPU上运行。所以在物理上，对于单核处理器来说，是无法实现物理上的并行。在单核处理器上，即使使用多线程来分发程序，但实际上还是以单线程的形式在运行。
如果将执行核增加一个，那么在同一时刻，将会有两个线程在运行，这样将会在一定程度上提供计算机的运行速度，但对于某些单线程的程序过程来说，实际情况并没用得到改善。至于系统中的线程怎么分发到两个核上，这就是操作系统的任务了。很多应用程序都不止包含一个线程，一般都包含有多个线程，如用Spy++工具查看系统所有的线程，如下图所示：

这多个线程如果在一个执行核上运行，它们呈一个队列来执行。如果在两个执行核上运行的话，它们将呈两队来执行。如果某个程序中包括有四个线程，而这四个线程又分别在两个核上执行，那么执行该程序将节约一半的时间。但如果该程序是单线程，无论是单核还是多核，运行该程序所需的时间都将是一样的。所以，以前有人在某单线程程序中将一些程序分开放在两个线程中分别执行，效率得到了提高，节约将近一倍的时间，其原因就在此。

OpenMP提供的就是一个多线程编程标准，现在.Net平台也提供了并行编程的System.Threading.Tasks.Parallel类，可以使多个线程能够同时执行。如果直接采用多个线程去实现并行，需要经常处理线程或线程池，采用这些多线程编程标准可以简化并行开发，也不必直接处理线程或线程池。

在C/C++中采用OpenMP指令的格式如下：

#pragma omp …

关键字omp表示这个指令是OpenMP指令，所以它会被OpenMP编译器处理，其他非OpenMP编译器将不会理会。由于OpenMP指令都预先定义了，所以很容易被识别出来。这样程序员编写的并行代码就可以在不同的平台上运行。如果平台不支持并行，也会直接跳过并行指令把程序当作串行程序来运行。

OpenMP提供了两种控制并行的结构：第一种就是提供了一个用于创建多线程程序的指令，这些线程相互之间是并行的，这个指令实际上就是创建了一些线程去执行并形体中的程序；第二种就是对已存在的并行结构进行分工的指令，像循环中的do指令（Fortran）或for（C/C ++）。

一个OpenMp程序通常都是从一个单线程程序开始，我们通常把这个单线程程序叫做主线程（Master Thread），在主线程的程序中应该要包含整个程序中需要使用的数据变量，包括全局变量。当主线程遇到并行结构时，将会创建新的线程来执行并形体中的程序。每个线程都会独立的执行并形体中的程序，相互之间不会影响，但是它们之间可以共用主线程里面定义的全局变量。在并行过程中具体哪些变量是共享的、哪些变量是线程私有的，可以通过条件clauses(…)对每个变量进行指定，这些条件用于并行线程中决定哪些可用。一个变量可以有三种类型，即shared、private和reduction。其中shared表示在并行结构中将有一个单独的内存位置来存放这个变量，所有的并行线程都可以使用这个变量，所有的并行线程将共享这块内存地址，因此，线程间的通信通过普通的读写操作方式就可以实现，当然，这个变量也可以随意被任何一个线程修改。相反，private变量将会有多个内存地址，每个线程里面一个。这个变量的所有读写操作都只限于本线程，其他线程是无法访问本线程中该变量的内存地址的。所以，一般都用于定义临时变量。reduction就有点难理解了，它具有shared和private的特征，就像它的字面意思一样，reduction属性用于需要下降的变量（指值的减少）。Reduction操作在很多程序中都非常重要，最常见的例子就是计算并行结构中最后的临时局部变量的总和。除了这三种之外，OpenMP还提供了许多其他数据属性参数。

多个OpenMP线程之间可以采用共享变量（shared）通过简单的读写操作来进行通信，但是这需要在多个线程中协调一致。如果协调不一致，可能会出现多个线程同时修改这个变量，或者这个线程正在读而那个线程又正在写，这些潜在的冲突都将导致数据的错误，因此，在多线程中必须避免这种情况，必须明确地协调好。在并行程序中设置同步（synchronization）就可以协调这些执行的多线程。最常见的两种情况就是相互排斥和事件同步，互斥就是在这段代码中通过一个线程不让其他线程读取这个共享变量。当很多线程正在修改同一个变量时，为了确保这个变量值是对的，在修改之前就需要进行互斥存取。OpenMP中提供了一个critical指标来表示互斥。事件同步常用于表示多线程间的事件，最简单的形式就是barrier阻塞。在并行程序中barrier指标表示在某点处每个线程都在这等待其他的线程也运行到这里，一旦所有的线程都达到这个点后，它们又继续执行。就像跑步的时候，有的人跑得快，有的人跑得慢，在跑了两圈的时候，所有人都在这里等待最后一个人，当最后一个人也跑到两圈的时候，然后大家又接着继续跑，这个过程就称为barrier阻塞。barrier指令能保证所有线程都执行了在barrier之前的代码。

一个典型的并行程序结构如下图所示：

OpenMP API是一套非常简便的共享存储并行计算应用程序接口，它是一个多线程、共享存储的模型。线程间通过共享的变量进行交换，并可以通过线程同步来防止数据冲突，当然，同步是需要耗费很多的资源的，所以尽量减少同步的需要。

并行数目与并形体对运行效率的影响

xwebsite — Mon, 07 May 2012 10:18:39 +0000

接下来再做一个测试，将并行和串行的循环次数设置为100，即将上例的main函数中：

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

更改为：

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

然后分别运行10次，其结果如下表所示：

从上面的分析结果可见，在循环100次的时候，只有极少数情况下并行计算比串行计算所需的时间要少，许多情况下并行需要更多的时间，这与我们设计并行程序的初衷是截然相反的。出现这种情况的原因之一就是，在分发并行的时候，系统也是需要消耗资源的，如果用于并行分发所耗的时间大于并行计算中节约的时间，那么这种情况下的并行计算就显得毫无意义，正如上例中的测试。所以，在并行计算中，并不是所有的并行计算都比串行计算要节约时间，具体要看并行的任务是否值得去做并行计算。还有一个重要的原因就是每次并行的线程数目，由于计算机CPU同时支持的并行线程有限，不可能指定并行100次， CPU在同一时刻就能运行100个线程。另外，由于这个比较程序的计算量非常小，很容易受到系统中其他因素的影响而导致计算结果的不稳定，所以，建议在进行测试时，尽量将计算量稍微调大一点，同时每次测试时应尽量保证运行环境相近，以减少系统中其他程序对测试结果的干扰。

下面用一个例子更能说明并行数目与程序运行效率间的关系，设置并形体中的计算量都一样，每次只是并行的次数不同，具体代码如下：

//File: Test02.cpp

#include "stdafx.h"

#include

#include

using namespace std;

//循环测试函数

void test02()

{

for(inti=0;i<5000000;i++)

{

for(intj=0;j<1000;j++);

}

}

int main()

{

cout<<"这是一个新的并行测试程序!\n";

cout<>N;

cout<<"开始进行计算...\n";

doublestart = omp_get_wtime( );//获取起始时间

#pragmaomp parallel for

for(inti = 0; i < N; i++)

{

test02();

}

doubleend = omp_get_wtime( );//获取结束时间

cout<<"计算耗时为："<end;

return0;

}

在近似的测试环境中分别对并行1次（相对于串行）、2次、3次等参数进行测试，其结果如下表：

计算时间与并行次数之间的关系如下图所示：

从以上分析结果可知，在并形体中计算量相同的情况下，在计算机ＣＰＵ物理线程数目以内的并行次数可以得到更好的效果。这也可以很好的解释并行中线程数目设置的限制问题，如当设置９个并行线程时，由于计算机最多只支持８个线程，那第９个线程理所当然就不能和前面８个线程处于同一起跑线，它只能排在这８个线程的后面。假定第１到第８个线程是处于第一排，这一排的８个线程将会同时起步运行，而第９个到第１６个处于第二排，它们则要在第一排后面起步，依次类推。每一时刻，都只会有８个线程在进行计算，而并行的结束是以所有的线程运行结束为标志，因此，最后那个线程（或者说最慢的那个线程）将决定并行结束的时间，所以线程越多，那么排队就越长，并行结束的时间相应就会增长。当然，具体一队中有多少个循环，可以通过schedule来设定，关于schedule后面将会详细介绍。

当然，上面的分析是基于并形体中计算量相同的前提，但有些情况下并形体的计算量与并行次数有着密切关系，譬如说总计算量一定的情况下，任何设置合理的并行次数对整个程序的运行起着至关重要的作用。如下例子，并行计算的总计算量一定，即如果设置并行次数越多，则并形体中的计算量越小。代码如下：

//File: Test03.cpp

#include "stdafx.h"

#include

#include

using namespace std;

//循环测试函数

void test03(int space)

{

for(inti=0;i
{

for(intj=0;j<1000;j++);

}

}

int main()

{

inttotal=36288000;

cout<<"在总计算量一定的情况下测试程序!\n";

cout<>N;

intspace =total/N;

cout<<"开始进行计算...\n";

doublestart = omp_get_wtime( );//获取起始时间

#pragmaomp parallel for

for(inti = 0; i < N; i++)

{

test03(space);

}

doubleend = omp_get_wtime( );//获取结束时间

cout<<"计算耗时为："<end;

return0;

}

分别设置并行次数从１到４２进行测试，测试结果如下表所示：

比较结果如下图所示：

由上图中可以很明显的看出，当并行数目达到计算机ＣＰＵ最多线程数目时（测试计算机上ＣＰＵ支持８线程），其计算效率将达到比较好的效果。假定计算机支持的最多线程为ｎ，并行数目在０～ｎ之间，计算效率逐渐增加，达到ｎ时效率极高，当增加到ｎ＋１个并行数目时，计算效率会骤降，但在ｎ＋１与２ｎ之间，计算效率同样也会逐渐增加，当达到２ｎ＋１时，又会骤降，随着并行数目不断增加，该规律将会不断的重现。

所以，综合以上两个测试例子也不难发现，并非并行数目越多，其计算效率就越高，具体效率跟程序结构以及计算机有着密切的联系。

相关程序源码下载地址：

http://download.csdn.net/detail/xwebsite/3843187

移动Web应用程序开发高性能JavaScript篇(二) JavaScript 开发分析工具

Dawei Cheng 程大伟 (Intel) — Sat, 07 Apr 2012 12:51:28 +0000

1. JavaScript 引擎介绍

这里只介绍主流浏览器的JavaScript引擎。如下图所示：

JS引擎一般作为共享库使用，应用程序调用引擎提供的API函数。引擎API函数大致分为以下几种：数据类型操作、RunTime控制、类与对象的创建和维护、函数与脚本执行、字符串操作、错误处理、安全控制、Debug支持。

上图中测试使用的是Google V8 benchmark。可以看出Chrome V8引擎JavaScript执行各项指标最优。

其中：每款浏览器JavaScript引擎发展历史：

Mozilla

• SpiderMonkey，第一款JavaScript引擎，由Brendan Eich在Netscape Communications时编写，用于Mozilla Firefox 1.0～3.0版本。

• Rhino，由Mozilla基金会管理，开放源代码，完全以Java编写。

• TraceMonkey，基于即时编译的引擎，其中部份程式码取自Tamarin引擎，用于Mozilla Firefox 3.5～3.6版本。

• JaegerMonkey，德文Jäger原意为猎人，结合追踪和组合码技术大幅提高效能，部分技术借凿了V8、JavaScriptCore、WebKit，用于Mozilla Firefox 4.0以上版本。

Google

• V8，开放源代码，由Google丹麦开发，是Google Chrome的一部分。

微软

• Chakra (JScript引擎)，中文译名为查克拉，用于Internet Explorer 9的32位版本。

Opera

• Linear A，用于Opera 4.0～6.1版本。

• Linear B，用于Opera 7.0～9.2版本。

• Futhark，用于Opera 9.5～10.2版本。

• Carakan，由Opera软件公司编写，自Opera10.50版本开始使用。

其它

• KJS，KDE的ECMAScript/JavaScript引擎，最初由Harri Porten开发，用于KDE项目的Konqueror网页浏览器中。

• Narcissus，开放源代码，由Brendan Eich编写（他也参与编写了第一个SpiderMonkey）。

• Tamarin，由Adobe Labs编写，Flash Player 9所使用的引擎。

• Nitro（原名SquirrelFish），为Safari 4编写。

2. JavaScript 开发工具

下面介绍几款常用的JavaScript 开发调试工具：

1. Google Chrome Developer Tools

个人觉得目前Chrome开发者工具是所有工具中最好用的JavaScript开发调试工具，其具有非常强大的功能。具体参考：https://developers.google.com/chrome-developer-tools/docs/overview

2. Mozilla Firefox Firebug

Mozilla 在Web开发领域一直是一个领导者，Firebug也是非常方便的开发调试工具。可以分析，查看log, Debug等功能很强大。具体参考：http://getfirebug.com/

3. IE Developer Tools

微软IE也提供了自己的一套开发工具，但是个人觉得用起来不是很方便，可能是不习惯的原因吧。具体信息参考http://www.microsoft.com/download/en/confirmation.aspx?id=18359

再介绍两款JavaScript网页性能分析工具：

1. JavaScript Performance 网站 http://jsperf.com/

用户可以在该网站上面写不同的test case来测试如何写JavaScript代码更加高效。如果需要针对IE做优化，只需要在IE中打开该网站进行测试和分析，如果需要在Chrome中做优化，一样，对应地在Chrome中打开就可以了。点击测试之后，会给出一份很详细的测试报告。

2. Chrome speedtracer 插件。

具体的使用方式参考：https://developers.google.com/web-toolkit/speedtracer/get-started

然后打开你要性能分析的网页，打开这个工具，然后刷新目标网站，刷新完了点击停止分析，就可以查看报告了。

打开每一项之后可以看到很详细的分析报告，如下图：

相关文章

移动Web应用程序开发高性能JavaScript篇 (一) JavaScript 性能瓶颈

参考文章： WiKi Javascript Engine

在写一篇文章中将给大家结合实例例子及分析工具介绍在加载JavaScript代码时，如何编程可以让Web应用或者网页更加高效。

移动Web应用程序开发高性能JavaScript篇 (一) JavaScript性能瓶颈

Dawei Cheng 程大伟 (Intel) — Mon, 26 Mar 2012 13:43:51 +0000

介绍

本系列博客将主要介绍如今大红大紫的移动Web应用程序开发最重要的三个工具：HTML5，JavaScript， CSS3。博文也分为三个大部分：

1. 众望所归的HTML5将主要介绍HTML5的前世今生，主要功能和API以及相关Demo，Demo的代码都可以在文章附件中下载到；

2. 高性能JavaScript将主要介绍如何让JavaScript更流畅，JavaScript debug和分析工具，可以说，没有JavaScript就不可能有互联网的今天，更不可能有移动互联网的明天，编写高性能的JavaScript至关重要；

3. 变化万千的CSS3将主要介绍如今异常强大的CSS3，结合HTML5编写动态的Web应用。熟练使用异常Fashion & Cool & 炫的CSS3将使Web应用增色不少。

本篇是高性能JavaScript介绍的第一篇，主要介绍JavaScript语言特性，为什么要编写高性能的JavaScript代码，以及对编写高性能JavaScript代码的开篇小结。

HTML5 系列文章

移动Web应用程序开发 HTML5篇 (一) HTML5简介

移动Web应用程序开发 HTML5篇 (二) 新功能介绍和测试

移动Web应用程序开发 HTML5篇 (三) Canvas API

移动Web应用程序开发 HTML5篇 (四) 多媒体 API

移动Web应用程序开发 HTML5篇 (五) 地址位置 API

移动Web应用程序开发 HTML5篇 (六) 通信(Communication) API

移动Web应用程序开发 HTML5篇 (七) Web Sockets API

移动Web应用程序开发 HTML5篇 (八) Offline Web Applications

移动Web应用程序开发HTML5篇 (九) Web Storage API

1. JavaScript 介绍

JavaScript用于Web编程的功能实现，被数百万计的网页用来改进设计、验证表单、检测浏览器、创建cookies，以及更多的应用。按照WiKipedia的说法，它是：

Prototype-based scripting language;

Dynamic, weakly typed and has first-class functions language;

Implementation of the ECMAScript language standard. ECMA-262-3。

我们依次来解释其中每句话的意思。

1. JavaScript是基于原型的脚本语言：基于原型的语言和传统基于类型的语言如Java等相对的。基于原型的语言所有的对象都是实例，通过原型来继承属性，构造函数或者原型指定了一组初始的属性.可以对一个对象或者一组对象动态的增加和删除属性。

2. 动态的，弱类型以及拥有First class function 的语言。

动态是指JavaScript是运行时动态解释的语言，系统不会将其编译为二进制文件进行执行。

弱类型是和强类型相对的，弱类型语言允许将一块内存看做多种类型。比如直接将整型变量与字符变量相加。强类型语言在没有强制类型转化前，不允许两种不同类型的变量相互操作。Java、C# 和 Python 等都是强类型语言。

First Class Function是指"能够用于类型生命"，即变量的类型可以是函数，可以赋值和传递函数。

3. 多范式的，支持基于对象的，指令模式和函数编程。

4. JavaScript是ECMAScrip标准的一个实现，目前使用的是ECMA-262-3. ECMAScript是一种由Ecma国际（前身为欧洲计算机制造商协会）通过ECMA-262标准化的脚本程序设计语言。

2. 为什么JavaScript性能很重要

通过上面的介绍，我们了解了JavaScript的属性和大致情况，那么为什么程序员在开发JavaScript代码时需要特别注重JavaScript性能呢？原因主要有以下几点：

1. 在过去的十年中，互联网改变了一切，最近的2年中，移动互联网深刻地改善了人们的生活，各种新技术层出不穷，HTML5，CSS3等等。网络负载越来越大，网页内容越来越丰富，加载的内容也越来越多，所有的一切都变了，只有JavaScript没有变。其作为一种脚本语言，伴随着互联网的发展十余年，都没有改变过。所以在以前没有的性能问题，如今都显现出来，如长时间Block UI Thread等问题。这就迫切需要我们深入了解其机制，编写高性能的JavaScript代码。

2. JavaScript是一个动态解释的语言，其固有特性导致运行的速度比编译成二进制代码的语言要慢很多，要想加快运行速度迫使开发者开发高性能的JavaScript代码。

3. 由于JavaScript是动态运行的，并没有编译环节，所以也迫使开发者编程时要完成很多本来可以由编译器完成的优化选项。比如gcc -o3的这些优化原理需要开发者在开发JavaScript代码时，自己手动去编写。

3. 总结

综上所述，JavaScript作为一个广受欢迎的web开发脚本语言，因为其已使用的特点，被广大Web开发者用来开发各种应用程序，但是由于网络环境，负载情况和运行环境在近几年都发生了很大的变化使开发者必须为Web应用优化JavaScript代码才能使其得到高效的运行，同时JavaScript固有特性使开发者需要去做可以由编译器完成的优化工作，也迫使开发者编写高性能的JavaScript代码。

本篇完，在第二篇中将给大家介绍目前流行的JavaScript引擎以及如何使用JavaScript性能分析工具来Tuning你的JavaScript代码。

参考文献： High performance JavaScript O'Reilly Yahoo Press

相关文章阅读：

JavaScript被扩展以支持并行运算

高性能计算

yeahugo — Thu, 22 Mar 2012 09:29:30 +0000

信息时代的硬件芯片和存储器价格以摩尔定律的形式下降，可是现在处理的数据量也越来越大。我们先以cocoa编程为例，然后再结合网格计算、云计算，综合对最新的高性能计算技术作介绍。

使用 runloop
在cocoa编程如果用NSThread开线程
[NSThread detachNewThreadSelect: @selector(run) toTarget:self withObject:nil]
也可以用runLoop的方式来取代
[self performSelector:@selector(run) withObject:nil afterDelay:0.0]
在runLoop里面的run函数要有循环调用
相比而言使用runLoop的方法效率更高。

Grand Central Dispatch
GCD是一项由苹果发展起来的技术，用多核处理器和其他多处理系统去优化应用对系统的支持。这是一个根据线程池模式的并行任务的实现。它首先发布在mac os x10.6上，也可以用在ios 4上。
GCD是一个替代诸如NSThread等技术的很高效和强大的技术。GCD完全可以处理诸如数据锁定和资源泄漏等负责的异步编程问题。
在开始之前，需要理解是要提供给GCD队列的是代码块，用于在系统或者用户创建的的队列上调度运行。
如下会返回一个用户创建的队列：
dispatch_queue_t myQueue = dispatch_queue_create("com.iphonedevblog.post", NULL);

执行一个队列
如下会异步执行传入的代码：
dispatch_async(myQueue, ^{ [self doSomething]; }); 其中，首先传入之前创建的队列，然后提供由队列运行的代码块。
声明并执行一个队列
如果不需要保留要运行的队列的引用，可以通过如下代码实现之前的功能：
dispatch_async(dispatch_queue_create ("com.iphonedevblog.post", NULL), ^{ [self doSomething]; });

从队列中在主线程运行代码
有些操作无法在异步队列运行，因此必须在主线程（每个应用都有一个）上运行。UI绘图以及任何对NSNotificationCenter的调用必须在主线程长进行。
在另一个队列中访问主线程并运行代码的示例如下：
dispatch_sync(dispatch_get_main_queue(), ^{ [self dismissLoginWindow]; });
注意，dispatch_suspend （以及dispatch_resume）在主线程上不起作用。

SETI@home
at Home，在家搜寻外星智慧（地外文明---也就是我们常说的“外星人”）），是一个通过互联网利用家用个人计算机处理天文数据的分布式计算项目。该项目试图通过分析阿雷西博射电望远镜采集的无线电信号，搜寻能够证实外星智能生物存在的证据。该项目由美国加州大学伯克利分校的空间科学实验室主办。

网格计算: Xgrid
Xgrid是一组Mac OS X应用套件，它使管理人员可以将本地和远程计算机连接起来形成网格，从而使本地和远程用户可以随时使用整个网格提供的计算资源。当用户将一项工作（Job）提交给系统后，Xgrid将为每项工作创建多个任务（Task）并且将它们分配给网格上的多个节点去并行地执行。Xgrid产生的目的是为了解决复杂耗时的计算问题，诸如蒙特卡洛计算、3D渲染等。然而，Xgrid本身并不是一种计算方法，它是一种让多台计算机相互“交谈”的网格结构。

Xgrid允许一个程序在不同的机器上并行运行，从而迅速得到运行结果。在Xgrid中包括三大软件组件:用于启动运算例程的客户机（Client）、进行初始化计算的控制机（Controller）以及执行计算过程的代理机（Agent）。

GridEZ.framework
GridEZ 框架是目的是使得你的yingiyong整合Xgrid的服务更加容易。XgridFoudation api是强大的，可是它使用起来很复杂。为了让使用者连接控制器，提交一项工作和得到相应的结果，你需要用XgridFoundation写数百行代码，和管理一个复杂的XgridFoundation要求你的异步调用链。
GridEZ框架提供一个使用简单的对象隐藏了这些复杂度，和提供了大部分你所需要的功能。例如，你提交一项工作，当工作完成之后结果回自动装载到你的应用，而你要做的仅仅是写一个代理方法去处理它。如果你从来没有使用XgridFoundation APIs，你可能不知道困难的是什么。可是如果你知道的话，你已经意识到GridEZ是怎么使你的生活大为轻松了。

云计算 :EC2
Elastic Compute Cloud(EC2)
EC2是由亚马逊提供的web计算服务，是一个让使用者可以租用云端电脑运行所需应用的系统。EC2由提供web
服务的方式让使用者可以弹性地运行自己的Amazon机器映象档，使用者将可以在这个虚拟机上运行任何自己想要的应用程序。
EC2 与传统的服务器电脑有以下优势：
没有系统管理员
没有机房的空间
没有电费账单
没有限制的空间

OpenMPI
MPI最大的特点是用户写一份单独的程序却运行在所有的计算机上。可是因为每一个计算机被赋予一个唯一的标识序列，尽管它只运行相同的代码，它却可以为不同的机器上进行不同的操作：

if ( I am processor A ) then
add a bunch of numbers
else if ( I am processor B ) then
multipy a matrix times a vector
end

另一个MPI的特点的特点是单独数据存储在各个计算机上。如果一个计算机需要从另一个得到数据，或者发送一个特别的数据到所有其他计算机，它必须单独调用合适的库要求数据传输。
由于库路径的调用，它对发送者和接收者来说要求同时在线（意味着一个人将可能要等待另一个人出现），或者为了以后传输发送者在同一时间发送一个消息到缓冲区，允许发送者立即进行再进一步的计算。
这是一个一份程序看起来的简单例子，在那里数字X被认为被处理器A计算，数字B被处理器B计算。

if ( I am processor A ) then
call MPI_Send ( X )
else if ( I am processor B ) then
call MPI_Recv ( X )
end

open MPI 项目是一个开源的MPI-2层级的实现，由科研机构和合伙公司共同发展和维护的。open MPI可以从各个高性能的计算单位联合专家知识、技术和资源，从而组建一个最高MPI可行的库。open MPI向系统和软件供应商和应用开发者和计算机学者提供很多好处。

不完全列举open MPI的特点：
完全支持MPI-2 层级
线程和并发安全
支持异构网络
单一库支持所有网络
运行时指令
支持各种操作系统
在各个平台上的高性能
可移植和容易维护
动态和快速响应的邮件列表

并行程序：OpenMP
OpenMP（Open Multi-Processing）是由OpenMP Architecture Review Board牵头提出的，并已被广泛接受的，用于共享内存并行系统的多线程程序设计的一套指导性注释（Compiler Directive）。
程序员通过在源代码中加入专用的pragma来指明自己的意图，由此编译器可以自动将程序进行并行化，并在必要之处加入同步互斥以及通信。当选择忽略这些pragma，或者编译器不支持OpenMP时，程序又可退化为通常的程序（一般为串行），代码仍然可以正常运作，只是不能利用多线程来加速程序执行。
OpenMP提供的这种对于并行描述的高层抽象降低了并行编程的难度和复杂度，这样程序员可以把更多的精力投入到并行算法本身，而非其具体实现细节。对基于数据分集的多线程程序设计，OpenMP是一个很好的选择。同时，使用OpenMP也提供了更强的灵活性，可以较容易的适应不同的并行系统配置。线程粒度和负载平衡等是传统多线程程序设计中的难题，但在OpenMP中，OpenMP库从程序员手中接管了部分这两方面的工作。

例子
在 omp parallel 段內的程序代码由多线程來執行：
int main(int argc, char* argv[])
{
#pragma omp parallel
printf("Hello, world.\n");

return 1;
}

GPU 编程： OpenCL
OpenCL (Open Computing Language，开放计算语言) 是一个为异构平台编写程序的框架，此异构平台可由CPU，GPU或其他类型的处理器组成。OpenCL由一门用于编写kernels （在OpenCL设备上运行的函数）的语言（基于C99）和一组用于定义并控制平台的API组成。OpenCL提供了基于任务分割和数据分割的并行计算机制。
OpenCL类似于另外两个开放的工业标准OpenGL和OpenAL，这两个标准分别用于三维图形和计算机音频方面。OpenCL扩展了GPU用于图形生成之外的能力。OpenCL由非盈利性技术组织Khronos Group掌管。

OpenCL 是基于C的一个程序语言，在软件上，分为Platform Layer、Runtime、Compiler三个部分。

•Platform Layer用来管理计算装置，提供初始化装置的界面，并用来建立compute contexts和work-queues
•runtime 用来管理资源，并执行程序的kennel
•编译器则是 ISO C99的子集合，并加上Open CL特殊的语法。

在OpenCL的执行模型中，有所谓的Compute Kenel 和Compute Program。Compute Kenel基本上类似于CUDA定义的kenel，是最基本的计算单元；而Compute Program则是Compute Kernel和内建函数的集合，类似一个动态函数库。而应用程序则是会把要执行的compute kernel排序，在执行时则可以依序或不依序来执行。

在平行计算方面，有data-parallel和task-parallel两种不同计算模型。

中文 » 博客征文专栏

Metro Web应用开发中页面通信问题解决方法

C#多线程参数传递

显式算法和隐式算法的并行化比较

Android 多线程编程

关于core_uses_pid 标志对多线程程序无用的调查

OpenMP 概述

并行数目与并形体对运行效率的影响

移动Web应用程序开发 高性能JavaScript篇(二) JavaScript 开发分析工具

移动Web应用程序开发 高性能JavaScript篇 (一) JavaScript性能瓶颈

高性能计算

移动Web应用程序开发高性能JavaScript篇(二) JavaScript 开发分析工具

移动Web应用程序开发高性能JavaScript篇 (一) JavaScript性能瓶颈