<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:wfw="http://wellformedweb.org/CommentAPI/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
	xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
	>

<channel>
	<title>中文 &#187; erwincv</title>
	<atom:link href="http://software.intel.com/zh-cn/blogs/author/erwincv/feed/" rel="self" type="application/rss+xml" />
	<link>http://software.intel.com/zh-cn/blogs</link>
	<description></description>
	<lastBuildDate>Mon, 28 May 2012 13:40:23 +0000</lastBuildDate>
	<language>en</language>
	<sy:updatePeriod>hourly</sy:updatePeriod>
	<sy:updateFrequency>1</sy:updateFrequency>
	<generator>http://wordpress.org/?v=3.1.3</generator>
		<item>
		<title>多核编程技术 - 4</title>
		<link>http://software.intel.com/zh-cn/blogs/2009/09/09/400002261/</link>
		<comments>http://software.intel.com/zh-cn/blogs/2009/09/09/400002261/#comments</comments>
		<pubDate>Wed, 09 Sep 2009 07:07:53 +0000</pubDate>
		<dc:creator>erwincv</dc:creator>
				<category><![CDATA[博客征文专栏]]></category>
		<category><![CDATA[多核]]></category>

		<guid isPermaLink="false">http://software.intel.com/zh-cn/blogs/2009/09/09/400002261/</guid>
		<description><![CDATA[4 每层中，对每个节点建立barrel，为了达到负载均衡，通常对任务进行排序，np难题。如：80，30，10，5，2.可以分两个线程，80，30+10+5+2. 动态任务调度模式本地队列-&#62;共享队列。从共享队列中“偷”任务来完成，太高负载均衡的目的。实现算法简介：快排。动态内存排序时，将总任务分为两部分，即两个子任务，放入分布式队列中。如此往复迭代，知道分解为足够小的串行任务，再执行。 /\ /\ /\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/ &#124; &#124; &#124; \/ \/ \/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/ 负载均衡的处理方法：前缀和计算，如一些区间 &#124;-2-&#124;-3-&#124;-6-&#124;-2-&#124;-5-&#124;-4-&#124; 方法较复杂，见网页http://blog.csdn.net/drzhouweiming/archive/2008/10/28/3164974.aspx 多用于基数排序。爬虫搜索工具。]]></description>
			<content:encoded><![CDATA[<p>4 每层中，对每个节点建立barrel，为了达到负载均衡，通常对任务进行排序，np难题。如：80，30，10，5，2.可以分两个线程，80，30+10+5+2. 动态任务调度模式本地队列-&gt;共享队列。从共享队列中“偷”任务来完成，太高负载均衡的目的。实现算法简介：快排。动态内存排序时，将总任务分为两部分，即两个子任务，放入分布式队列中。如此往复迭代，知道分解为足够小的串行任务，再执行。 /\ /\ /\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/ | | | \/ \/ \/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/ 负载均衡的处理方法：前缀和计算，如一些区间 |-2-|-3-|-6-|-2-|-5-|-4-| 方法较复杂，见网页http://blog.csdn.net/drzhouweiming/archive/2008/10/28/3164974.aspx 多用于基数排序。爬虫搜索工具。</p>
]]></content:encoded>
			<wfw:commentRss>http://software.intel.com/zh-cn/blogs/2009/09/09/400002261/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>多核编程技术 - 2</title>
		<link>http://software.intel.com/zh-cn/blogs/2009/09/09/400002259/</link>
		<comments>http://software.intel.com/zh-cn/blogs/2009/09/09/400002259/#comments</comments>
		<pubDate>Wed, 09 Sep 2009 07:06:53 +0000</pubDate>
		<dc:creator>erwincv</dc:creator>
				<category><![CDATA[博客征文专栏]]></category>
		<category><![CDATA[多核]]></category>

		<guid isPermaLink="false">http://software.intel.com/zh-cn/blogs/2009/09/09/400002259/</guid>
		<description><![CDATA[$2 死锁与数据竞争：死锁：互相等待对方的资源。请看周伟明的《软件测试实践》；）尽量避免嵌套锁。数据竞争：比较烦，与死锁比较，更难避免。多线程推出与资源释放：以计数的方式统计各个线程已经结束。共享资源并行遍历：线程控制：Set_ ThreadAffinity指定内核，执行指定线程。不同编程模型的对比与适用场景： OpenMP：简单的并行执行。缺点：容易出现数据竞争。 TBB：分布式内存管理，动态任务调度。有正式版本可用。（有数据竞争的bug） CAPI：mr周所写。 OpenMP编程模型。 Fork-Join模型，在串行期之前，等待所有线程都结束。barrier栅障。一般格式为： #progma omp parallel for num_threads（···） //主句 // 从句 for（i = 0; i&#60;···; i++） // 结构块 { } 不指定线程数量时，会用缺省线程数量（如cpu核数）。线程数量牵扯到扩展性问题，如一个循环到底设置多少线程数量合适？？创建内存开销需要有2000次循环，如果执行10 000次，···总之创建线程越多，开销也随之增大。每个线程必须保证一个循环次数， 如2000次，最多只能有5个线程，如果内核数为8，也只能创建5 个线程。有时候每次循环和上一次循环结果有逻辑依赖关系。如：数据竞争 int i , S[1024]; s[0] = 0; #pragma omp parallel for for (int i = 1; i &#60; sizeof(S)/sizof(int); i++) { S[i] = S[i-1] + i; [...]]]></description>
			<content:encoded><![CDATA[<p>$2 死锁与数据竞争：死锁：互相等待对方的资源。请看周伟明的《软件测试实践》；）尽量避免嵌套锁。数据竞争：比较烦，与死锁比较，更难避免。多线程推出与资源释放：以计数的方式统计各个线程已经结束。共享资源并行遍历：线程控制：Set_ ThreadAffinity指定内核，执行指定线程。不同编程模型的对比与适用场景： OpenMP：简单的并行执行。缺点：容易出现数据竞争。 TBB：分布式内存管理，动态任务调度。有正式版本可用。（有数据竞争的bug） CAPI：mr周所写。 OpenMP编程模型。 Fork-Join模型，在串行期之前，等待所有线程都结束。barrier栅障。一般格式为： #progma omp parallel for num_threads（···） //主句 // 从句 for（i = 0; i&lt;···; i++） // 结构块 { } 不指定线程数量时，会用缺省线程数量（如cpu核数）。线程数量牵扯到扩展性问题，如一个循环到底设置多少线程数量合适？？创建内存开销需要有2000次循环，如果执行10 000次，···总之创建线程越多，开销也随之增大。每个线程必须保证一个循环次数， 如2000次，最多只能有5个线程，如果内核数为8，也只能创建5 个线程。有时候每次循环和上一次循环结果有逻辑依赖关系。如：数据竞争 int i , S[1024]; s[0] = 0; #pragma omp parallel for for (int i = 1; i &lt; sizeof(S)/sizof(int); i++) { S[i] = S[i-1] + i; }</p>
]]></content:encoded>
			<wfw:commentRss>http://software.intel.com/zh-cn/blogs/2009/09/09/400002259/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>多核编程技术 - 1</title>
		<link>http://software.intel.com/zh-cn/blogs/2009/09/09/400002258/</link>
		<comments>http://software.intel.com/zh-cn/blogs/2009/09/09/400002258/#comments</comments>
		<pubDate>Wed, 09 Sep 2009 07:06:23 +0000</pubDate>
		<dc:creator>erwincv</dc:creator>
				<category><![CDATA[博客征文专栏]]></category>
		<category><![CDATA[多核]]></category>

		<guid isPermaLink="false">http://software.intel.com/zh-cn/blogs/2009/09/09/400002258/</guid>
		<description><![CDATA[串行比例f 串行时间k,把f看做n的函数，由于摩尔定律n上升， f下降，串行时间近似为常数。 Gustafson定律： S（n） = n + (1-n)K = K + (1-K)n,总时间是1，k串行执行时间&#60;1. 如何实现串行比例f，随着内核数量增加，如何使得f降低呢？就是说串行部分在总执行部分的比例呢？比如，队列排队，需要多处枷锁操作，如何来减少这样的锁呢？ 1，减少串行执行代码， 2，减少锁的使用， 3，减少集中式锁竞争，避免出现多个进程竞争同一把锁。尽量使用多个队列，多个锁的形式，即分布式锁竞争。 4，负载均衡，1ms，4ms地进行并行效率不会高。 5，降低并行计算开销，例如，一个排序算法，单核执行，10ms，双核执行各6ms，多出2ms 计算开销。与算法设计的优劣有关。 ok，提高加速比的方法大致如上。 讲一下，锁竞争下的加速比。集中式加速比。加锁1~2千万次/s,至少相当于200条指指令，开销很大的。 任务粒度因子，锁粒度因子，fk = ts/tl,锁粒度越小并行性越好。锁竞争越小。 单核与多核多线程的区别。线程数量不少于cpu核数，考虑负载均衡*，任务调度，优先级抢占（&#60;单核优先级不考虑任务调度，多核情况，高优先级任务可以利 用里一个核，所以高优先不一定先与地有限结束，） 不同架构cpu的影响。 Cache需要对齐的：如果没对齐会怎样？？即为共享问题，对于同时访问同一行的cache时，会互斥，会加锁，产生乒乓现象。大幅降 低执行效率。锁与原子操作：原子操作，+1操作， add var；两个线程不能对同一个变量进行+1操作，实际上cpu会对变量进行，锁总线控制，就是互斥的，广义原子操作，表示整个一系列操作是这个整体，不可分割，造作到一半的时候不可以打断的，即使打断也会从头开始。进行读操作，没问题，如果对不变量进行写操作，就要用到原子操作。 CAS操作：(比较并交换炒作) CompareAndSwapt 有两个线程操作链表，线程1先读到指针Tail，线程2随后读到Tail并改到其他节点,线程1就不能随便进行写操作 了。 cas就是对应这样的一个操作，先比较是否与原值相等，不等则进行交换。不等则进行交换(当做出错情况),继续循环这样的操作，直到相等再进行写操 作 。cas是原子操作，不允许被打断！！LockFree编程。状态比较复杂，容易出错。 TestAndSet操作：（测试是否等0，等零则至一）线程切换时候经常进行这样的操作，多为系统底层所用，在应用层偶尔也会用到。]]></description>
			<content:encoded><![CDATA[<p>串行比例f 串行时间k,把f看做n的函数，由于摩尔定律n上升， f下降，串行时间近似为常数。 Gustafson定律： S（n） = n + (1-n)K = K + (1-K)n,总时间是1，k串行执行时间&lt;1. 如何实现串行比例f，随着内核数量增加，如何使得f降低呢？就是说串行部分在总执行部分的比例呢？比如，队列排队，需要多处枷锁操作，如何来减少这样的锁呢？ 1，减少串行执行代码， 2，减少锁的使用， 3，减少集中式锁竞争，避免出现多个进程竞争同一把锁。尽量使用多个队列，多个锁的形式，即分布式锁竞争。 4，负载均衡，1ms，4ms地进行并行效率不会高。 5，降低并行计算开销，例如，一个排序算法，单核执行，10ms，双核执行各6ms，多出2ms 计算开销。与算法设计的优劣有关。 ok，提高加速比的方法大致如上。 讲一下，锁竞争下的加速比。集中式加速比。加锁1~2千万次/s,至少相当于200条指指令，开销很大的。 任务粒度因子，锁粒度因子，fk = ts/tl,锁粒度越小并行性越好。锁竞争越小。 单核与多核多线程的区别。线程数量不少于cpu核数，考虑负载均衡*，任务调度，优先级抢占（&lt;单核优先级不考虑任务调度，多核情况，高优先级任务可以利 用里一个核，所以高优先不一定先与地有限结束，） 不同架构cpu的影响。 Cache需要对齐的：如果没对齐会怎样？？即为共享问题，对于同时访问同一行的cache时，会互斥，会加锁，产生乒乓现象。大幅降 低执行效率。锁与原子操作：原子操作，+1操作， add var；两个线程不能对同一个变量进行+1操作，实际上cpu会对变量进行，锁总线控制，就是互斥的，广义原子操作，表示整个一系列操作是这个整体，不可分割，造作到一半的时候不可以打断的，即使打断也会从头开始。进行读操作，没问题，如果对不变量进行写操作，就要用到原子操作。 CAS操作：(比较并交换炒作) CompareAndSwapt 有两个线程操作链表，线程1先读到指针Tail，线程2随后读到Tail并改到其他节点,线程1就不能随便进行写操作 了。 cas就是对应这样的一个操作，先比较是否与原值相等，不等则进行交换。不等则进行交换(当做出错情况),继续循环这样的操作，直到相等再进行写操 作 。cas是原子操作，不允许被打断！！LockFree编程。状态比较复杂，容易出错。 TestAndSet操作：（测试是否等0，等零则至一）线程切换时候经常进行这样的操作，多为系统底层所用，在应用层偶尔也会用到。</p>
]]></content:encoded>
			<wfw:commentRss>http://software.intel.com/zh-cn/blogs/2009/09/09/400002258/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>多核编程技术 - 3</title>
		<link>http://software.intel.com/zh-cn/blogs/2009/09/05/400002260/</link>
		<comments>http://software.intel.com/zh-cn/blogs/2009/09/05/400002260/#comments</comments>
		<pubDate>Sat, 05 Sep 2009 07:07:23 +0000</pubDate>
		<dc:creator>erwincv</dc:creator>
				<category><![CDATA[博客征文专栏]]></category>
		<category><![CDATA[多核]]></category>

		<guid isPermaLink="false">http://software.intel.com/zh-cn/blogs/2009/09/05/400002260/</guid>
		<description><![CDATA[$3 数据处理： private firstprivate lastprivate reduction copyin copyprivate 数据竞争的例子，j在循环外面，会出现数据竞争。 可以转为循环内部，或者在外部声明为const。图像放缩的实例。 OpenMP性能很好，尤其是简单的应用。但是经常碰到其他的问题。看“任务调度与伪代码” 问题在于，使用dynamic的时候会出现数据竞争，用动态调度达到负载均衡的效果，但是声明步长要较长（dynamic，16）。 barrier，可以显示调用的，达到多个线程同步机制，让所有线程执行结束。 nowait，不再隐含着barrier在后面， 而是直接执行后面的代码。（默认OpenMP是在循环后面加barrier操作的）。 order， 按照一定顺序执行。 OpenMP是通过在编译预处理来实现的。 线程分组竞争，锁的数量》=cpu核数，指定哪几个线程用那几把锁。随即竞争，线程可以自由选择锁。 儒家观点：人之初，性本善。西方观点：人之初，性本恶。各种模式的基本思想：人类伦理的基本思想，善恶皆于“贪”-》优化，人有生以来具有特性。本能。自私，只不过程度不同。每个线程有私有数据，还有多个线程共享的数据，显然操作私有数据会有更高的效率。不需要加锁解锁。偷，强……也是优化方法。这些都是多核优化的最基本思想。具体模式：多线程对哈希表操作（查询，插入，删除）。 Bucket分段锁的多线程访问哈希表。一个共享队列池，有些队列为空，从中读数据可能多次执行，加锁解锁操作。如何使用一次加锁解锁即可把数据取出？对每个队列加标志位flag，通过判断flag的状态，来决定是否执行lock/unlock操作。 数据本地化模式（自私） TlsSetValue TlsGetValue thread local storage 批量处理模式：列表遍历，10万个节点，每次每次访问2个节点，加解锁，只有5万次了。 TBB内存管理算法，用到了该模式。流水线模式：对整个工作分步骤处理，每个线程处理一个步骤。数据分解模式：数据依赖关系问题，不能简单的分解。负载均衡，分析具体数据结构。数据边界上的伪共享问题。矩阵横分解，要比竖分解优越很多。伪共享只有一个数据，而不是一组。思考：如何对矩阵进行分块相乘？（伪共享，Cache的命中率）为了提cache命中率，乘法后面的矩阵往往需要进行转置，再横向分块！！ Map-Reduce（google）有一个文本文件，只包含字母和数字，如何统计字母个数？ 任务图调度（n-p难题）并行化计算的核心问题。OpenMP对循环进行分解是一个最简单的图。两个顶点。有依赖关系的任务步骤，构成图。例如，f1,f2,f3……f10函数有依赖关系，指针数组p1……pn指向他们。 f6……f10依赖f1……f5才是一般意义的图，无环有向图。结构化程序：顺序，分支，循环。 http://gforge.osdn.net.cn/projects/capi]]></description>
			<content:encoded><![CDATA[<p>$3 数据处理： private firstprivate lastprivate reduction copyin copyprivate 数据竞争的例子，j在循环外面，会出现数据竞争。 可以转为循环内部，或者在外部声明为const。图像放缩的实例。 OpenMP性能很好，尤其是简单的应用。但是经常碰到其他的问题。看“任务调度与伪代码” 问题在于，使用dynamic的时候会出现数据竞争，用动态调度达到负载均衡的效果，但是声明步长要较长（dynamic，16）。 barrier，可以显示调用的，达到多个线程同步机制，让所有线程执行结束。 nowait，不再隐含着barrier在后面， 而是直接执行后面的代码。（默认OpenMP是在循环后面加barrier操作的）。 order， 按照一定顺序执行。 OpenMP是通过在编译预处理来实现的。 线程分组竞争，锁的数量》=cpu核数，指定哪几个线程用那几把锁。随即竞争，线程可以自由选择锁。 儒家观点：人之初，性本善。西方观点：人之初，性本恶。各种模式的基本思想：人类伦理的基本思想，善恶皆于“贪”-》优化，人有生以来具有特性。本能。自私，只不过程度不同。每个线程有私有数据，还有多个线程共享的数据，显然操作私有数据会有更高的效率。不需要加锁解锁。偷，强……也是优化方法。这些都是多核优化的最基本思想。具体模式：多线程对哈希表操作（查询，插入，删除）。 Bucket分段锁的多线程访问哈希表。一个共享队列池，有些队列为空，从中读数据可能多次执行，加锁解锁操作。如何使用一次加锁解锁即可把数据取出？对每个队列加标志位flag，通过判断flag的状态，来决定是否执行lock/unlock操作。 数据本地化模式（自私） TlsSetValue TlsGetValue thread local storage 批量处理模式：列表遍历，10万个节点，每次每次访问2个节点，加解锁，只有5万次了。 TBB内存管理算法，用到了该模式。流水线模式：对整个工作分步骤处理，每个线程处理一个步骤。数据分解模式：数据依赖关系问题，不能简单的分解。负载均衡，分析具体数据结构。数据边界上的伪共享问题。矩阵横分解，要比竖分解优越很多。伪共享只有一个数据，而不是一组。思考：如何对矩阵进行分块相乘？（伪共享，Cache的命中率）为了提cache命中率，乘法后面的矩阵往往需要进行转置，再横向分块！！ Map-Reduce（google）有一个文本文件，只包含字母和数字，如何统计字母个数？ 任务图调度（n-p难题）并行化计算的核心问题。OpenMP对循环进行分解是一个最简单的图。两个顶点。有依赖关系的任务步骤，构成图。例如，f1,f2,f3……f10函数有依赖关系，指针数组p1……pn指向他们。 f6……f10依赖f1……f5才是一般意义的图，无环有向图。结构化程序：顺序，分支，循环。 http://gforge.osdn.net.cn/projects/capi</p>
]]></content:encoded>
			<wfw:commentRss>http://software.intel.com/zh-cn/blogs/2009/09/05/400002260/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
	</channel>
</rss>

