代码小兵

openMP讨论帖

[推荐] 【系列讲座】OpenMP 入门[问题点数:0分，结帖人:intel_jeff]

intel_jeff
(Jeff@英特尔欢迎到"英特)
等　级：
结帖率：88.89%

楼主发表于：2008-05-12 16:48:04

OpenMP是一个业界的标准，很早以前就有了，只是近一段时间才逐渐热起来。我们可以在C/C++和Fortran使用OpenMP、很容易的引入多线程。

OpenMP目前的标准是2.5，3.0马上也要通过了。官方网站www.openmp.org上有你需要知道的一切信息，包括OpenMP规范文档。

下图是一个典型的OpenMP程序的示意图，我们可以看到它是由串行代码和并行代码交错组成的，并行代码的区域我们把它叫做“并行区”。主线程一旦进入并行区，就自动产生出多个线程，来并行的执行。

怎样在我们的代码中使用OpenMP呢？很简单，拿我们常用的C/C++代码来说，只需要插入如下pragma，然后我们选择不同的construct就可以完成不同的功能。

（待续。。。）

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

回复次数： 99

intel_jeff
(Jeff@英特尔欢迎到"英特)
等　级：

#1楼得分：0回复于：2008-05-12 16:54:03

首先，我们来看一下如何创建一个并行区：增加一行代码#pragma omp parallel，然后用花括号把你需要放在并行区内的语句括起来，并行区就创建好了。并行区里每个线程都会去执行并行区中的代码。

那么怎么来控制并行区中线程的数量呢？默认情况下，并行区内线程数=系统中核的个数。如果你需要修改，方法之一是设置环境变量。

下一节我们将看一个最简单的OpenMP代码，看看并行区是怎样工作的。

（待续。。。）

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

精华推荐：多核编程中的条件同步模式【含代码】

Kaile
(领头羊)
等　级：

#2楼得分：0回复于：2008-05-12 17:15:04

没有了？

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

精华推荐：四道微软面试算法题

intel_jeff
(Jeff@英特尔欢迎到"英特)
等　级：

#3楼得分：0回复于：2008-05-13 11:16:47

我们来看一个最简单的OpenMP程序例子：
===================================
#include

int main() {
#pragma omp parallel
{
int i;
printf("Hello World/n");
for(i=0;i<6;i++)
printf("Iter:%d/n",i);
}
printf("GoodBye World/n");
}
===================================

我们现在用Intel编译器来编译这个小程序，当然你也可以用VS2005来编译。

我们可以看到编译器在没有加 /Qopenmp 开关的时候，会忽略掉所有openmp pragma。我们可以利用这个特性来检查你的代码在串行的时候运行

结果是否正确。
D:/test>icl /nologo HelloWorlds.c
HelloWorlds.c
HelloWorlds.c(4): warning #161: unrecognized #pragma
#pragma omp parallel
^

串行代码执行的结果如下：
D:/test>HelloWorlds.exe
Hello World
Iter:0
Iter:1
Iter:2
Iter:3
Iter:4
Iter:5
GoodBye World

下面我们加上 /Qopenmp 开关重新编译，我们会看到编译器给出提示说已经把并行区给做并行化了。
D:/test>icl /nologo /Qopenmp HelloWorlds.c
HelloWorlds.c
HelloWorlds.c(4): (col. 5) remark: OpenMP DEFINED REGION WAS PARALLELIZED.

我的机器是4核，运行这个程序就打印出如下结果。我们可以看到每次运行打印出来的东西顺序是不一定的，这个符合多线程程序的特性。在4

核的机器上，并行区内就产生了4个线程同时执行for循环打印，默认线程数=核的个数。
D:/test>HelloWorlds.exe
Hello World
Iter:0
Iter:1
Iter:2
Iter:3
Iter:4
Iter:5
Hello World
Iter:0
Hello World
Iter:0
Iter:1
Iter:2
Iter:3
Iter:4
Iter:5
Hello World
Iter:0
Iter:1
Iter:1
Iter:2
Iter:2
Iter:3
Iter:3
Iter:4
Iter:4
Iter:5
Iter:5
GoodBye World

我们来修改一下线程的数量，然后再运行一下代码，看下运行结果
D:/test>set OMP_NUM_THREADS=2
D:/test>HelloWorlds.exe
Hello World
Iter:0
Iter:1
Iter:2
Iter:3
Iter:4
Iter:5
Hello World
Iter:0
Iter:1
Iter:2
Iter:3
Iter:4
Iter:5
GoodBye World

D:/test>

现在我们对并行区有了一定的了解，并行区里每个线程执行的代码是一样的，做的事情似乎也是一样的，但是实际工作中，我们希望把一部分

工作分配给不同线程来做，这应该怎么实现呢？请看下节。

（待续。。。）

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

精华推荐：【连载之八】~~~NUMA与英特尔下一代Xeon处理器学习心得！

intel_jeff
(Jeff@英特尔欢迎到"英特)
等　级：

#4楼得分：0回复于：2008-05-13 16:22:00

我们近期将推出更多的系列讲座，大家希望看到我们介绍什么内容可以提出来，当然主要是围绕Intel的软件工具产品。如果大家认为有比讲座更好的方式，也请告诉我们，谢谢！

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

精华推荐：求解一道内存溢出的作业题

intel_jeff
(Jeff@英特尔欢迎到"英特)
等　级：

#5楼得分：0回复于：2008-05-14 16:33:33

下面我们来看一个新的openmp语句
#pragma omp for
使用这个语句，我们就可以把一个for循环的工作量（例如：1...N）分配给不同线程。这个语句后面必须紧跟一个for循环，他只能对循环的工作量进行划分、分配。

看下面这个例子，0...11的工作量被平均分配给了3个线程。当3个线程都完成了各自的工作后，程序才继续往下执行。

写2行openmp pragma实在有些麻烦，我们可以把2行或多行openmp pragma合并未一行，这样好多了，是吧。

（待续。。。）

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

精华推荐：过年前的讨论2！关于天平称球问题的统一解法!

abuion
(abuion)
等　级：

#6楼得分：0回复于：2008-05-14 18:13:46

全英文！
用点通俗点的来介绍一下你的openmp嘛
是一种语言还是像xml之类的一种业界标准

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

youxia000
(无剑无我)
等　级：

#7楼得分：0回复于：2008-05-14 19:20:10

能问个问题么

多线程对可分的计算是很好的

但是对大量内存的访问是不是也能提速呢，

比如我做图像处理，做一个gauss光滑，要访问周围点然后来计算，并且前后不相关，可以分多线程，计算方面肯定提速了

但是对不同线程的内存访问是不是也分别用各自的缓存

似乎这个问题和多核的cpu是共享缓存，还是各自独立缓存有关，

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

intel_iclifort
(iclifort)
等　级：

#8楼得分：0回复于：2008-05-14 22:47:44

引用 6 楼 abuion 的回复:
全英文！
用点通俗点的来介绍一下你的openmp嘛
是一种语言还是像xml之类的一种业界标准

是业界的标准, 详细的规范请见 http://www.openmp.org

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

intel_jeff
(Jeff@英特尔欢迎到"英特)
等　级：

#9楼得分：0回复于：2008-05-16 11:24:53

引用 7 楼 youxia000 的回复:
能问个问题么

多线程对可分的计算是很好的

但是对大量内存的访问是不是也能提速呢，

比如我做图像处理，做一个gauss光滑，要访问周围点然后来计算，并且前后不相关，可以分多线程，计算方面肯定提速了

但是对不同线程的内存访问是不是也分别用各自的缓存

似乎这个问题和多核的cpu是共享缓存，还是各自独立缓存有关，

最好能利用好缓存，尽量把相近的点一起做。你可以尝试不同的划分方法，比如把大图切割成 n x n 的小块，每个线程做一个小块；或者每个线程做1行，即线程1做第1，n+1，2n+1行，第2个线程做第2，n+2，2n+2行，n为线程数。多试试几个方法，应该有一个最适合你的方法。

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

intel_jeff
(Jeff@英特尔欢迎到"英特)
等　级：

#10楼得分：0回复于：2008-05-16 14:12:34

==================================
数据环境（Data Environment）
==================================

OpenMP属于共享内存的编程模型。在我们的多线程代码中，大部分数据都是可以共享的。共享内存给我们程序中数据的共享带来了极大的便利。因此在默认情况下，OpenMP将全局变量、静态变量设置为共享属性。

但是，还是有些变量需要是每个线程私有的，也就是每个线程有这些变量的独立拷贝，这样每个线程在使用这些变量时不会相互影响。需要私有的变量包括：

我们可以通过如下方法来改变OpenMP的变量默认属性，你可以把它设置为共享（shared）或无。也可以单独改变某几个变量的属性，把他们设置为shared或private。

看看下面这个例子，循环变量i默认为私有，因为x和y是中间变量，应该设置为私有，否则线程之间的x,y会互相影响。

再看看这个例子。变量sum定义在并行区之外，所以默认为共享，这个例子里又写了shared(sum)，没错，但是实际上是罗嗦了。那么这个例子里有什么错误呢？

如果以前做过多线程开发的话应该能看出来，sum不应该是共享的，但是设置为私有的也不对。我们的做法应该是将sum保护起来，防止多个线程同时对sum进行写操作。我们可以使用OpenMP的临界区来对sum进行保护。

（待续。。。）

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

intel_jeff
(Jeff@英特尔欢迎到"英特)
等　级：

#11楼得分：0回复于：2008-05-22 16:15:47

欢迎大家有问题随时提问。

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

Kaile
(领头羊)
等　级：

#12楼得分：0回复于：2008-05-28 13:19:58

我是OPENMP新手，对于上一段代码，我还是有困惑：

设置了critical以后，　

sum+= ... 这句话说明多个线程不同时作加法，但是还是每个线程做N次加法，　这样N＊线程数的结果与单线程的N次结果会大相径庭，对吗？

有什么办法既提高速度又不改变逻辑了？

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

Kaile
(领头羊)
等　级：

#13楼得分：0回复于：2008-05-28 14:43:45

我上面的理解不对，

#pragma omp parallel for
这句话应该是　把for循环分为N部分，分配给每个独立的线程。

因为　

sum+= N这一句话　牵涉到读　sum，所以不能设置为shared.

我这样理解对吗？

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

Kaile
(领头羊)
等　级：

#14楼得分：0回复于：2008-05-28 21:20:47

上面的代码如果这样改：

#pragma omp for reduction(+: sum)
for(int i = 0; i {
sum += a[i] + b[i];
}

是不是和范例的代码等价了？

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

intel_jeff
(Jeff@英特尔欢迎到"英特)
等　级：

#15楼得分：0回复于：2008-05-29 11:13:53

引用 13 楼 Kaile 的回复:
我上面的理解不对，

#pragma omp parallel for
这句话应该是　把for循环分为N部分，分配给每个独立的线程。

因为　

sum+= N这一句话　牵涉到读　sum，所以不能设置为shared.

我这样理解对吗？

昨天本想回你12楼的贴的，结果及其出问题了。今天上来一看，你已经自己解决了这个问题了。鼓励一下！
不错，你这个分析的完全正确。

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

Kaile
(领头羊)
等　级：

#16楼得分：0回复于：2008-05-29 15:29:36

谢谢及时回复。那么14楼的分析有没有问题了？问题在哪里？

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

Kaile
(领头羊)
等　级：

#17楼得分：0回复于：2008-05-29 15:42:48

#pragma omp parallel for
for (i=0;ifor (j=0;jt[i][j]=FALSE;
}
}

还有，象上面这个语句，i 是私有的， j 是shared，运行起来会不会有问题了？

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

intel_iclifort
(iclifort)
等　级：

#18楼得分：0回复于：2008-05-29 15:56:13

引用 17 楼 Kaile 的回复:
#pragma omp parallel for
for (i=0;i for (j=0;j t[i][j]=FALSE;
}
}

还有，象上面这个语句，i 是私有的， j 是shared，运行起来会不会有问题了？

并行区(Parallel Region)内, 未经声明, 所有的变量都是共享的, 只有一个例外

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

intel_iclifort
(iclifort)
等　级：

#19楼得分：0回复于：2008-05-29 16:03:09

引用 16 楼 Kaile 的回复:
谢谢及时回复。那么14楼的分析有没有问题了？问题在哪里？

没有问题, 这是OpenMP提供的累加归约(Reduction)操作. 另外, 还可以支持乘, 逻辑运算等归约操作

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

intel_iclifort
(iclifort)
等　级：

#20楼得分：0回复于：2008-05-29 16:14:44

引用 7 楼 youxia000 的回复:
能问个问题么

多线程对可分的计算是很好的

但是对大量内存的访问是不是也能提速呢，

比如我做图像处理，做一个gauss光滑，要访问周围点然后来计算，并且前后不相关，可以分多线程，计算方面肯定提速了

但是对不同线程的内存访问是不是也分别用各自的缓存

似乎这个问题和多核的cpu是共享缓存，还是各自独立缓存有关，

在新的Core 微架构中, 采用了一个叫做 " Intel Advanced Smart Cache" 的技术

Intel Advanced Smart Cache is a multi-core optimized cache that improves performance and efficiency by increasing the probability
that each execution core of a dual-core processor can access data from a higher-performance, more-efficient cache subsystem.

To accomplish this, Intel Core microarchitecture shares the Level 2 (L2) cache between the cores. This better optimizes cache
resources by storing data in one place that each core can access. By sharing L2 cache between each core, Intel Advanced Smart
Cache allows each core to dynamically use up to 100 percent of available L2 cache. Threads can then dynamically use the required
cache capacity. As an extreme example, if one of the cores is inactive, the other core will have access to the full cache.
Intel Advanced Smart Cache enables very efficient sharing of data between threads running in different cores. It also enables
obtaining data from cache at higher throughput rates for better performance. Intel Advanced Smart Cache provides a peak transfer
rate of 96 GB/sec (at 3 GHz frequency)

这篇白白书中有详细的说明: http://download.intel.com/technology/architecture/sma.pdf

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

intel_jeff
(Jeff@英特尔欢迎到"英特)
等　级：

#21楼得分：0回复于：2008-05-29 16:56:32

引用 17 楼 Kaile 的回复:
#pragma omp parallel for
for (i=0;i for (j=0;j t[i][j]=FALSE;
}
}

还有，象上面这个语句，i 是私有的， j 是shared，运行起来会不会有问题了？

会有问题的，你需要将j声明为私有，或者在并行去内声明变量j。

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

intel_jeff
(Jeff@英特尔欢迎到"英特)
等　级：

#22楼得分：0回复于：2008-05-29 17:12:54

我们可以给临界区命名，在下面例子中，如果我们不给临界区命名，在任一时刻，只能有一个线程调用consum函数。而我们给临界区命名后，任一时刻可以有最多2个线程在调用consum函数（1个调用 consum(B, &R1)，另一个调用 consum(A, &R2)。这在这2句语句可以同时执行的情况下，我们通过临界区命名来尽可能减少线程等待时间。

归约（Redunction）是个很有用的功能，可以简化我们的编程，op代表一个操作，list是执行这个操作的一个或多个变量。

我们再看刚才上面的例子就清楚了。我们对sum这个变量使用归约操作，操作符是+。这样的话，每个线程就会有一个私有的sum变量，当所有线程的计算完成后，每个线程的私有的sum的值将被用“+”归约成一个总的sum，即线程1的sum + 线程2的sum + ... + 线程n的sum -> 总的sum，这个总的sum值将被带出并行区并赋给全局的那个sum变量，因此，当这个并行区的代码执行完以后，我们的sum变量的值就是我们期望得到的值了。
是不是比前面用临界区的方法要好得多、代码也会快得多呢？

下图是归约支持的操作符：

好了，来给大家做个小作业。下面代码是一个串行的求Pi的代码，使用的是积分的办法。请大家把这个代码用OpenMP来做并行化。

（待续。。。）

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

Kaile
(领头羊)
等　级：

#23楼得分：0回复于：2008-05-29 21:12:34

我来试试：

#include

static long num_steps = 100000;
double step, pi;
void main()
{

int i;
double x, sum = 0.0;
step = 1.0/ (double) num_steps;

#pragma omp parallel for private(x) reduction(+:sum)
for(i=0; i< num_steps; i++)
{
x = ( i + 0.5)*step;
sum = sum + 4.0/(1.0+ x*x);
}
pi = step * sum;
printf("Pi = %f/n"),pi);
}

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

Kaile
(领头羊)
等　级：

#24楼得分：0回复于：2008-06-02 15:50:57

#pragma omp parallel for
for(int i = 0; i< 20;i++)
{
if(i> 4)
break;
}

在学习OpenMP中，发现这样的break语句不能在这里用，如果循环中有这种逻辑，如何处理？

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

Kaile
(领头羊)
等　级：

#25楼得分：0回复于：2008-06-02 15:54:03

我在单核心的机器上测试，如果加上

#pragma omp parallel sections

或者：

#pragma omp parallel for reduction(+:sum)
二种语句，性能会急剧下降。

如果只加 #pragma omp parallel for
性能不变化。

请问这种情况是正常的吗？

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

intel_iclifort
(iclifort)
等　级：

#26楼得分：0回复于：2008-06-02 16:29:21

引用 25 楼 Kaile 的回复:
我在单核心的机器上测试，如果加上

#pragma omp parallel sections

或者：

#pragma omp parallel for reduction(+:sum)
二种语句，性能会急剧下降。

如果只加 #pragma omp parallel for
性能不变化。

请问这种情况是正常的吗？

请先考虑正确性, 再考虑性能

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

Kaile
(领头羊)
等　级：

#27楼得分：0回复于：2008-06-02 16:32:03

当然是原来的逻辑没有改变了。

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

intel_jeff
(Jeff@英特尔欢迎到"英特)
等　级：

#28楼得分：0回复于：2008-06-04 11:09:31

引用 24 楼 Kaile 的回复:
#pragma omp parallel for
for(int i = 0; i < 20;i++)
{
if(i> 4)
break;
}

在学习OpenMP中，发现这样的break语句不能在这里用，如果循环中有这种逻辑，如何处理？

这样的循环是不能并行的，你需要改写你的代码（如果可能的话），至于怎么改写就要看具体情况了。

对我有用[1]
丢个板砖[0]
引用
举报
管理
TOP

intel_jeff
(Jeff@英特尔欢迎到"英特)
等　级：

#29楼得分：0回复于：2008-06-04 11:13:02

sections 和 reduction 实际上的代码实现很简单，没有特别复杂的东西（正如我前面介绍reduction原理时说的）。在程序逻辑相同的情况下，应该不会大幅度降低性能。你的测试代码能否贴出来看看？

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

Kaile
(领头羊)
等　级：

#30楼得分：0回复于：2008-06-13 09:59:58

前段时间比较忙，这2天开始研究这个问题。

因为我做得是一个棋牌程序，里面有三重循环，体内还有一个递归函数。我估计是循环，递归不断创建，析构线程导致性能下降，因此做了一个测试程序，请intel的大侠帮助看看。

void CopenmptestDlg::OnBnClickedButton1()
{
m_nCount = 0;
m_nValue = 0;

int nTick1 = GetTickCount();
for(int i = 0; i< 20;i ++)
{
for (int j=0; j< 20; j++)
{
for (int k=0; k< 20 ;k ++)
{
qs(m_nCount);
}
}
}
int nTick2 = GetTickCount();

ATLTRACE2(traceAppMsg, 0, "Value is %d, Tick count is %d/n", m_nValue, nTick2 - nTick1);
}

int CopenmptestDlg::qs(int count)
{
count ++;
if (count > 20)
return m_nValue;
int v1 = 0,v2=0 ;
#pragma omp parallel sections
{
#pragma omp section
v1 += 10;
#pragma omp section
v2 += 20;
}
m_nValue += v1 + v2;

qs(count);

return m_nValue;

}

很简单的测试，对话框上一个按钮，按一下进入循环体，执行一个递归函数。

openmp 的section段也很简单，最后输出执行时间，但使用不使用OPENMP的结果让人大跌眼镜：

Value is 4800000, Tick count is 3828 //使用openmp sections

Value is 4800000, Tick count is 16 // 不使用

看来逻辑没问题，就是性能下降太厉害。

请教大侠这种情况如何是好？

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

Kaile
(领头羊)
等　级：

#31楼得分：0回复于：2008-06-13 10:43:16

感觉是不是粒度分得太细，线程的开销已经大于多线程并行带来的好处，加上多重循环的累积，造成性能下降厉害。

有没有办法初始化线程，以后不动态创建和析构，这样是不是减少损耗？

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

intel_jeff
(Jeff@英特尔欢迎到"英特)
等　级：

#32楼得分：0回复于：2008-06-16 14:22:47

同意Kaile的看法，粒度太细了，应该尽可能在外层的循环用omp parallel for来做多线程化

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

intel_jeff
(Jeff@英特尔欢迎到"英特)
等　级：

#33楼得分：0回复于：2008-06-16 14:44:06

================================================
OpenMP中工作量的划分与调度
================================================

前面我看到在使用工作量共享(work-sharing)这种方式的时候，工作量是自动给我们划分好并分配给各个线程的。下面，我们来看看如何来控制工作量的划分与调度。

如上图所示，工作量的划分与调度有3种方式：
1、静态：把循环的迭代按照每x次(x=chunk)迭代分为一块，这样你的总工作量就被划分成了n/x块(n为迭代次数、循环次数)，然后将这些块按照轮转法依次分配给各个线程。举个例子：比如我们有100次迭代，x=chunk=4，那么我们的工作就被分为25块，假设我们有2个线程可以做工作，那么线程1分到的块是1,3,5,7....,25，线程2分到的块是2,4,6,...,24；
2、动态：迭代分块方法同上，但是工作块被放到一个队列中，每个线程每次拿一块，做好了才能到队列里去拿下一块；
3、Guided：这个方式是动态方式的改进。在这个方式里，分块的x是不固定的，一开始块的大小(x)比较大，随着剩余工作量的减小，块的大小也随之变小。

我们总结一下每种方式适合什么样的工作量
静态方式：比较适合每次迭代的工作量相近(主要指工作所需时间)的情况
动态方式：比较适合每次迭代的工作量非常不确定的情况
Guided方式：类似动态方式，但是队列相关的开销会比动态方式小

下面我们看一个例子：
#pragma omp parallel for schedule (static, 8)
for( int i = start; i <= end; i += 2 )
{
if ( TestForPrime(i) ) gPrimesFound++;
}

在这个例子中，如果start=3，那第一块就={3,5,7,9,11,13,15,17}

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

Kaile
(领头羊)
等　级：

#34楼得分：0回复于：2008-06-29 21:28:50

还没有新内容吗？

更新能否快一些。

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

intel_jeff
(Jeff@英特尔欢迎到"英特)
等　级：

#35楼得分：0回复于：2008-07-02 13:34:49

好的，前些时间有些忙，希望今天能更新，谢谢～ ^_^

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

intel_jeff
(Jeff@英特尔欢迎到"英特)
等　级：

#36楼得分：0回复于：2008-07-02 14:33:29

================================================
另外几个OpenMP Construct
================================================

下面我们来看一看Parallel Section，其实看看下面的图片就知道了，我们可以定义多个section，让这些section并行的执行。下面的例子是我们有足够的线程来同时执行这3个section，如果我们只有2个线程，情况会是怎样呢？

如果只有2个线程，那么肯定得有1个线程要比另一个线程勤劳一点，执行2个section了。
在使用Parallel Section时需要注意的是，每个section的工作之间应该是相互独立、没有依赖关系的。如果不满足这个要求的话，就不要对他们用并行了。

下面再介绍2个有可能会用到的OpenMP construct。
1、single：有时候在并行区里，我们希望有部分代码只能执行一次，也就是说只有一个线程去执行这部分代码。如下面的例子，ExchangeBoundaries() 这句语句前面我们加上 #pragma omp single ，就保证只有一个线程去执行它。同时在single后面会有一个隐含的障碍（implicit barrier）。我们后面会具体介绍障碍这个概念。

#pragma omp parallel
{
DoManyThings();
#pragma omp single
{
ExchangeBoundaries();
} // threads wait here for single
DoManyMoreThings();
}

2、master：master跟single很类似。在下面例子中，只有主线程会去执行 ExchangeBoundaries() 这条语句。但是master没有隐含的障碍，因此如果其他线程遇到 #pragma omp master，就会跳过去，直接执行master后面的语句。

#pragma omp parallel
{
DoManyThings();
#pragma omp master
{ // if not master skip to next stmt
ExchangeBoundaries();
}
DoManyMoreThings();
}

（待续～～～）

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

intel_jeff
(Jeff@英特尔欢迎到"英特)
等　级：

#37楼得分：0回复于：2008-07-02 14:50:27

================================================
障碍
================================================

在我们前面介绍过的OpenMP Construct，如parallel, for, single，他们自身都带有隐含的障碍。我们来看一下前面出现过的一个例子：

在这个例子里面，线程1做0-3的迭代，线程2做4-7的迭代，线程3做8-11的迭代，如果每次迭代的工作量不同，那么线程1、2、3完成他们各自的工作所需的时间是不同的，也就是说，某个线程可能比另外2个线程提前完成工作，但是这个线程不能继续往下走去执行并行区后面的工作，因为#pragma omp for里面带了隐含的障碍，这个障碍的意思就是说，所有的线程做完了自己的工作后必须在这里等，直到所有的线程都完成了各自的工作，大家才能往下走。汇编里的memory fence与这个有点神似。

为什么这些construct要带了个隐含的障碍呢？障碍不是让程序执行速度变慢了吗？因为它怕你程序里面后面的代码对这块代码有依赖关系，如果这块代码的工作没完成就去执行后面的代码，可能会引起错误。

那如果你后面的代码对这块代码没有依赖，可以用 nowait 来把这个隐含的障碍给去掉。比如：

例子1：

C/C++ code

              
              
              
              
               
               
               
               

               
               
               
               #pragma
               
               
               
                omp for nowait
               
               
               
               
   
               
               
               
               for
               
               
               
               (...)
     {...};

例子2：

C/C++ code

              
              
              
              
               
               
               
               

               
               
               
               #pragma
               
               
               
                single nowait
               
               
               
               
{ [...] }

例子3：

C/C++ code

              
              
              
              
               
               
               
               

               
               
               
               #pragma
               
               
               
                omp for schedule(dynamic,1) nowait
               
               
               
               
 
               
               
               
               for
               
               
               
               (
               
               
               
               int
               
               
               
                i
               
               
               
               =
               
               
               
               0
               
               
               
               ; i
               
               
               
               <
               
               
               
               n; i
               
               
               
               ++
               
               
               
               )
   a[i] 
               
               
               
               =
               
               
               
                bigFunc1(i);


               
               
               
               #pragma
               
               
               
                omp for schedule(dynamic,1) 
               
               
               
               
 
               
               
               
               for
               
               
               
               (
               
               
               
               int
               
               
               
                j
               
               
               
               =
               
               
               
               0
               
               
               
               ; j
               
               
               
               <
               
               
               
               m; j
               
               
               
               ++
               
               
               
               )
   b[j] 
               
               
               
               =
               
               
               
                bigFunc2(j);

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

Kaile
(领头羊)
等　级：

#38楼得分：0回复于：2008-07-03 08:25:50

我看别的资料没有你解释得这么详细的，no wait我一直不知道怎么用，现在明白了。

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

n_yHHy_n
(n_yHHy_n)
等　级：

#39楼得分：0回复于：2008-07-04 12:40:25

学习]

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

gubin04110245
等　级：

#40楼得分：0回复于：2008-07-04 13:32:14

路过，顶

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

xiao7cn
(FriedChicken)
等　级：

#41楼得分：0回复于：2008-07-04 17:39:08

眼泪哗哗的~~

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

wangyj705
等　级：

#42楼得分：0回复于：2008-07-05 10:15:39

榜样啊。。学习中。。顶。

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

ewqtan
(学习)
等　级：

#43楼得分：0回复于：2008-07-05 11:05:35

顶

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

e_bot
(挖坟工Never Mind t)
等　级：

#44楼得分：0回复于：2008-07-07 19:27:14

打酱油路过
看看

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

next163
(毛爪)
等　级：

#45楼得分：0回复于：2008-07-08 17:19:52

谢谢

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

sz000000001
(程序员在深圳)
等　级：

#46楼得分：0回复于：2008-07-08 20:59:12

***************************************************************************

思想决定行动,行动决定习惯,习惯决定命运.
程序员在深圳QQ群,交流产生思想碰撞.

部份专业群:
程序员在深圳c++群15195967
程序员在深圳英语学习群:23864353
程序员在深圳c++Ⅱ17409451
程序员在深圳嵌入式开发群37489763
程序员在深圳移动开发群31501597
程序员在深圳创业群33653422

部份高级程序员群:
高级群I:17538442
高级群II:7120862

部份初、中级程序员群:
第三群:2650485
第五群:29537639
第四群:28702746
第六群:10590618
第七群:10543585
第八群:12006492
第九群:19063074
第十群:2883885
第十一群:25460595
第十二群:9663807

深圳程序员QQ群联盟成立三年多，拥有三十个以上的QQ群,人数超二千多人,大量经验丰富的老手,成员从业于大公司（如微软、IBM,SUN，华为

）、来自国内著名高校和研究院成员，和有丰富实践经验的高级程序员、系统分析员(包括参加过上亿元的项目的架构师),有很热爱技术的成员

(包括自己写操作系统),还有少数女程序员。推荐：深程高级群I:17538442 深程高级群II:7120862 (深程高级群不欢迎新手,如果在深圳,月薪

6K以下的别加入) c++:15195967 mobile:31501597嵌入式:37489763
——————————————————————————————————————————
如果你不是第一次看到此广告,说明我们最近T了一些人,因为我们要不断提升群的质量,保证名副其实.
-------------------------------------------------------------------------------------
在通过电邮、新闻组或者聊天室提出技术问题前，检查你有没有做到：
1. 通读手册，试着自己找答案。
2. 在FAQ里找答案（一份维护得好的FAQ可以包罗万象:）。
3. 在网上搜索（个人推荐google~）。
4. 向你身边精于此道的朋友打听。
我想我们首先应该*自己解决问题，然后才是问！

*****************************************************************************

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

anjie4402211
等　级：

#47楼得分：0回复于：2008-07-08 23:32:41

不懂。。。。。。。。。。MARK

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

intel_jeff
(Jeff@英特尔欢迎到"英特)
等　级：

#48楼得分：0回复于：2008-07-11 11:22:26

================================================
介绍几个OpenMP API
================================================

在大多数情况下，我们不会用到OpenMP API。一般只有在调试和某些情况下，才需要用到API。

如果你需要使用 OpenMP API，记得先包含OpenMP头文件

C/C++ code

最常用的2个API是：

C/C++ code

              
              
              
              
               
               
               
               int
               
               
               
                omp_get_thread_num(
               
               
               
               void
               
               
               
               );

               
               
               
               int
               
               
               
                omp_get_num_threads(
               
               
               
               void
               
               
               
               );

在并行区里调用omp_get_thread_num返回的是当前线程的线程ID，一般是0到(N-1)，N是并行区里的总线程数。
在并行区里调用omp_get_num_threads返回的是并行区里的总线程数。

使用这2个API，我们可以只用 #pragma omp parallel 就实现每个线程完成循环中不同的迭代。比如我们有这样一段代码，怎样在不使用 #pragma omp parallel for 的情况下，改写代码、把工作量划分给各个线程呢？

C/C++ code

              
              
              
              
               
               
               
               #pragma
               
               
               
                omp parallel 
               
               
               
               
{
    
               
               
               
               for
               
               
               
               (i
               
               
               
               =
               
               
               
               0
               
               
               
               ;i
               
               
               
               <
               
               
               
               N;i
               
               
               
               ++
               
               
               
               )
    {
        c[i] 
               
               
               
               =
               
               
               
                a[i] 
               
               
               
               +
               
               
               
                b[i];
    }
}

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

wwwquzhinet
(王小波)
等　级：

#49楼得分：0回复于：2008-07-11 17:00:32

刚开始学习OpenMP，谢谢指教。

#pragma omp parallel
{
for(i=0;i<(N/omp_get_num_thread()+1);i++)
{
int j = i * omp_get_num_thread() + omp_get_thread_num();
if(j < N)
{
c[j]= a[j] + b[j];
}
}
}

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

intel_jeff
(Jeff@英特尔欢迎到"英特)
等　级：

#50楼得分：0回复于：2008-07-16 14:01:44

引用 49 楼 wwwquzhinet 的回复:
刚开始学习OpenMP，谢谢指教。

#pragma omp parallel
{
for(i=0;i <(N/omp_get_num_thread()+1);i++)
{
int j = i * omp_get_num_thread() + omp_get_thread_num();
if(j < N)
{
c[j]= a[j] + b[j];
}
}
}

工作量划分的要求做到了，但是效率还不够高哦。

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

wwwquzhinet
(王小波)
等　级：

#51楼得分：0回复于：2008-07-18 10:14:07

咨询几个问题：

我用VS2005编写了一个多线程应用程序P，运行时至少运行2个线程；
这个应用程序中，我调用了一个C语言的库cLib；
我想在这个cLib 中添加一些OpenMP的指令，以加快多核计算机上的程序速度。

/********************************************
机器：IBM T61
CPU: Intel Core(TM)2 Duo CPU T7500 @2.00GHz
内存：1G
OS： WindowsXP Sp2
*********************************************/

第一个问题是：我发现，如果 cLib 是静态库，则cLib中的平行区域肯定是按照单核处理的。
按照 http://msdn.microsoft.com/en-ca/magazine/cc163717.aspx 的说法，“Note that Visual C++ does not support static linking of
the OpenMP runtime”，这句话是不是说明，如果cLib使用静态链接库，则编译出来的库，不支持多核指令？如果使用Intel的编译器一样吗？

第二个问题：我将cLib编译成动态链接库，通过打印文件，我发现他确实是双核并行处理的。但是，并行处理部分的执行时间变化很大，如果不用OpenMP指令，则大约是 22ms，最大最小相差2ms左右；如果用了openMP指令，则执行时间变化很大，最慢的23ms也就是和单核一样，最快的15ms。
如果我在任务管理器中，强制设置应用程序只用一个核，则执行时间能稳定在17ms左右，但是偶然也有30多ms的。

也就是说，windowsXP下多核计算机，
自动对多线程程序多核并行处理的效率 < 强制让一个核处理多线程，但是多线程中的主要部分多核并行运算的效率
我这样理解对吗？

我要怎么做才能在多线程程序中使用OpenMP提高性能呢？
谢谢

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

intel_jeff
(Jeff@英特尔欢迎到"英特)
等　级：

#52楼得分：0回复于：2008-07-18 16:06:18

那句话是说MS的OpenMP库必须要动态链接，不可以静态链接，因为他们不提供OpenMP的静态库。Intel编译器10.1默认使用Intel的OpenMP库（可以做静态链接），你可以/Qopenmp-lib这个开关让Intel编译器选择使用Intel的OpenMP库还是用MS的OpenMP库。另外顺便说一下，从Intel编译器11.0开始，将默认使用MS的OpenMP库，以便可以跟MS编译器混合编译一个OpenMP项目，即：一个OpenMP的项目中，一部分文件用Intel编译器编译、另一部分用MS编译器编译，最后链接到一起。

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

intel_jeff
(Jeff@英特尔欢迎到"英特)
等　级：

#53楼得分：0回复于：2008-07-18 16:13:20

第2个问题，多线程的调度是由OS负责的，你测到的时间变化较大估计是受到了系统其他应用的影响，也可能你的并行代码有IO相关的操作。通常情况下，我们不需要去关心OS如何调度线程，OS的调度多半都是比较合适的。

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

ewqtan
(学习)
等　级：

#54楼得分：0回复于：2008-08-04 19:43:07

不懂？？？？？？

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

intel_jeff
(Jeff@英特尔欢迎到"英特)
等　级：

#55楼得分：0回复于：2008-08-07 15:24:44

下面再介绍几个数据环境相关的construct。前面我们看过了private, public，现在我们来看另外3个。

1、firstprivate：变量属性为private，同时每个线程的这个变量的初始值为全局变量的值。比如下面例子中，我们先给全局变量incr设置了一个值0，然后再并行区，每个线程都有自己的incr，而这些incr的初始值也为0（与并行区之前的全局量incr的值一致）。

C/C++ code

              
              
              
              
               
               
               
               incr
               
               
               
               =
               
               
               
               0
               
               
               
               ;

               
               
               
               #pragma
               
               
               
                omp parallel for firstprivate(incr)
               
               
               
               

               
               
               
               for
               
               
               
                (I
               
               
               
               =
               
               
               
               0
               
               
               
               ;I
               
               
               
               <=
               
               
               
               MAX;I
               
               
               
               ++
               
               
               
               ) {
    
               
               
               
               if
               
               
               
                ((I
               
               
               
               %
               
               
               
               2
               
               
               
               )
               
               
               
               ==
               
               
               
               0
               
               
               
               ) incr
               
               
               
               ++
               
               
               
               ;
    A(I)
               
               
               
               =
               
               
               
               incr;
}

2、lastprivate：当退出并行区时，最后一次迭代内的lastprivate变量的值将被带出并行区赋给全局的同名变量。在下面例子中，i循环的最后一次迭代中的x的值将被赋给全局的x，所以退出并行区后，全局量x被赋值了。

C/C++ code

              
              
              
              
               
               
               
               void
               
               
               
                sq2(
               
               
               
               int
               
               
               
                n, 
               
               
               
               double
               
               
               
                
               
               
               
               *
               
               
               
               lastterm)
{
  
               
               
               
               double
               
               
               
                x; 
               
               
               
               int
               
               
               
                i;
  
               
               
               
               #pragma
               
               
               
                omp parallel 
               
               
               
               
  
               
               
               
               #pragma
               
               
               
                omp for lastprivate(x)
               
               
               
               
  
               
               
               
               for
               
               
               
                (i 
               
               
               
               =
               
               
               
                
               
               
               
               0
               
               
               
               ; i 
               
               
               
               <
               
               
               
                n; i
               
               
               
               ++
               
               
               
               ){
     x 
               
               
               
               =
               
               
               
                a[i]
               
               
               
               *
               
               
               
               a[i] 
               
               
               
               +
               
               
               
                b[i]
               
               
               
               *
               
               
               
               b[i];
     b[i] 
               
               
               
               =
               
               
               
                sqrt(x);
  }
  lastterm 
               
               
               
               =
               
               
               
                x;
}

3、threadprivate：用于指定某变量为线程私有的全局变量。threadprivate和private的区别是private只在并行区中有效，而threadprivate属性是全局范围内有效的。
copyin：把全局变量的值拷贝到各线程中同名的threadprivate变量中去。

C/C++ code

              
              
              
              
               
               
               
               struct
               
               
               
                Astruct A;

               
               
               
               #pragma
               
               
               
                omp threadprivate(A)
               
               
               
               
…


               
               
               
               #pragma
               
               
               
                omp parallel copyin(A)
               
               
               
               
  do_something_to(
               
               
               
               &
               
               
               
               A);
…


               
               
               
               #pragma
               
               
               
                omp parallel 
               
               
               
               
  do_something_else_to(
               
               
               
               &
               
               
               
               A);

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

intel_jeff
(Jeff@英特尔欢迎到"英特)
等　级：

#56楼得分：0回复于：2008-08-07 15:34:22

下面我们看个程序加强理解

C/C++ code

              
              
              
              
               
               
               
               #include 
               
               
               
               <
               
               
               
               stdio.h
               
               
               
               >
               
               
               
               


               
               
               
               int
               
               
               
                main()
{
        
               
               
               
               int
               
               
               
                i, x 
               
               
               
               =
               
               
               
                
               
               
               
               100
               
               
               
               ;
        
               
               
               
               #pragma
               
               
               
                omp parallel for private(x)
               
               
               
               
        
               
               
               
               for
               
               
               
                (i
               
               
               
               =
               
               
               
               0
               
               
               
               ; i
               
               
               
               <
               
               
               
               8
               
               
               
               ; i
               
               
               
               ++
               
               
               
               )
        {
                x 
               
               
               
               +=
               
               
               
                i;
                printf(
               
               
               
               "
               
               
               
               x = %d/n
               
               
               
               "
               
               
               
               , x);
        }
        printf(
               
               
               
               "
               
               
               
               global x = %d/n
               
               
               
               "
               
               
               
               , x);
        
               
               
               
               return
               
               
               
                
               
               
               
               1
               
               
               
               ;
}

因为我的cpu是4核的，所以默认有4个线程，线程1跑i=0、1，线程2跑i=2、3，线程3跑i=4、5，线程2跑i=6、7，所以运行结果为：
x = 0
x = 1
x = 2
x = 5
x = 6
x = 13
x = 4
x = 9
global x = 100

下面我们把private换成firstprivate，结果就变成了
x = 100
x = 101
x = 102
x = 105
x = 106
x = 113
x = 104
x = 109
global x = 100
看出区别了吧，每个线程的x的初值都变成100了。

如果我们再加上个lastprivate：

C/C++ code

              
              
              
              
               
               
               
               #include 
               
               
               
               <
               
               
               
               stdio.h
               
               
               
               >
               
               
               
               


               
               
               
               int
               
               
               
                main()
{
        
               
               
               
               int
               
               
               
                i, x 
               
               
               
               =
               
               
               
                
               
               
               
               100
               
               
               
               ;
        
               
               
               
               #pragma
               
               
               
                omp parallel for firstprivate(x) lastprivate(x)
               
               
               
               
        
               
               
               
               for
               
               
               
                (i
               
               
               
               =
               
               
               
               0
               
               
               
               ; i
               
               
               
               <
               
               
               
               8
               
               
               
               ; i
               
               
               
               ++
               
               
               
               )
        {
                x 
               
               
               
               +=
               
               
               
                i;
                printf(
               
               
               
               "
               
               
               
               x = %d/n
               
               
               
               "
               
               
               
               , x);
        }
        printf(
               
               
               
               "
               
               
               
               global x = %d/n
               
               
               
               "
               
               
               
               , x);
        
               
               
               
               return
               
               
               
                
               
               
               
               1
               
               
               
               ;
}

结果如下：
x = 100
x = 101
x = 102
x = 105
x = 106
x = 113
x = 104
x = 109
global x = 113
全局的x的值最后变成了i=7的x的值，i=7是由线程4来做的。线程4在做完i=6时，私有x=106，做完i=7时，私有x=113，因为是lastprivate，113被带给全局量x了。

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

intel_jeff
(Jeff@英特尔欢迎到"英特)
等　级：

#57楼得分：0回复于：2008-08-07 15:40:52

公布一下我在48楼留得问题的答案，答案有很多种，我提供2个做参考，这2种的区别是不同的工作量划分方法：

C/C++ code

              
              
              
              
               
               
               
               #pragma
               
               
               
                omp parallel
               
               
               
               
{
    
               
               
               
               int
               
               
               
                i, istart, iend;
    
               
               
               
               int
               
               
               
                Nthrds 
               
               
               
               =
               
               
               
                omp_get_num_thread(), id 
               
               
               
               =
               
               
               
                omp_get_thread_num();
    istart 
               
               
               
               =
               
               
               
                id 
               
               
               
               *
               
               
               
                N 
               
               
               
               /
               
               
               
                Nthrds;
    iend 
               
               
               
               =
               
               
               
                (id
               
               
               
               +
               
               
               
               1
               
               
               
               ) 
               
               
               
               *
               
               
               
                N 
               
               
               
               /
               
               
               
                Nthrds;
    
               
               
               
               for
               
               
               
               (i
               
               
               
               =
               
               
               
               istart; i
               
               
               
               <
               
               
               
               iend; i
               
               
               
               ++
               
               
               
               )
    {
       c[i] 
               
               
               
               =
               
               
               
                a[i] 
               
               
               
               +
               
               
               
                b[i];
    }
}

C/C++ code

              
              
              
              
               
               
               
               #pragma
               
               
               
                omp parallel
               
               
               
               
{
    
               
               
               
               int
               
               
               
                i, istart, iend;
    
               
               
               
               int
               
               
               
                Nthrds 
               
               
               
               =
               
               
               
                omp_get_num_thread(), id 
               
               
               
               =
               
               
               
                omp_get_thread_num();
    
               
               
               
               for
               
               
               
               (i
               
               
               
               =
               
               
               
               id; i
               
               
               
               <
               
               
               
               iend; i
               
               
               
               +=
               
               
               
               Nthrds)
    {
       c[i] 
               
               
               
               =
               
               
               
                a[i] 
               
               
               
               +
               
               
               
                b[i];
    }
}

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

youxia000
(无剑无我)
等　级：

#58楼得分：0回复于：2008-08-20 15:50:06

没测试，不过我想从利用cach的角度看

还是第一个的效率要高些

感谢楼主，继续关注

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

firebird321
(涅磐的凤凰)
等　级：

#59楼得分：0回复于：2008-09-02 17:50:20

学习；谢谢楼主

对我有用[1]
丢个板砖[0]
引用
举报
管理
TOP

aling6888
等　级：

#60楼得分：0回复于：2008-09-03 15:53:58

跟着楼主学到了很多东西。我也一直用openmp
有一个问题一直困扰我，我采用openmp对vector进行并行运算，但发现运行时间比原来的慢了将近5倍，有时是10倍，我对openmp中可能涉及到的负载平衡进行调试，结果一样.不知道是不是openmp对vector不支持，还是程序修改有问题，请各位专家指导，小弟不尽感谢。
另外针对vector 的操作openmp是否有更好的解决方法？？？？？？？？
具体代码如下，我用的是ms+双核机器，两段程序vc2005编译都没问题。

没有采用openmp之前的部分代码：
QueryPerformanceCounter((LARGE_INTEGER *)&start);
for(vector ::iterator i=m_list.begin();i=!m_list.end();i++)
{
for(vector ::iterator j=i+1;j!=m_vDefectList.end();j++)
{
//一系列处理
}
}

QueryPerformanceCounter((LARGE_INTEGER *)&finish); //counter
int time=finish-start;

修改后的,用了openmp后的程序：
vector ::iterator i = m_list.begin();

QueryPerformanceCounter((LARGE_INTEGER *)&start);
#pragma omp parallel for
for(int tempN=0; tempN {
for(vector ::iterator j=i+tempN+1;j!=m_vDefectList.end();j++)
{
//一系列处理
}
}

QueryPerformanceCounter((LARGE_INTEGER *)&finish); //counter
int time=finish-start;

非常感谢。

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

intel_jeff
(Jeff@英特尔欢迎到"英特)
等　级：

#61楼得分：0回复于：2008-09-10 14:03:50

引用 60 楼 aling6888 的回复:
跟着楼主学到了很多东西。我也一直用openmp
有一个问题一直困扰我，我采用openmp对vector进行并行运算，但发现运行时间比原来的慢了将近5倍，有时是10倍，我对openmp中可能涉及到的负载平衡进行调试，结果一样.不知道是不是openmp对vector不支持，还是程序修改有问题，请各位专家指导，小弟不尽感谢。
另外针对vector 的操作openmp是否有更好的解决方法？？？？？？？？
具体代码如下，我用的是ms+双核机器，两段程序vc200…

貌似您的问题已经在下面贴中解决了。
http://topic.csdn.net/u/20080902/14/7efa241e-068d-4e8d-bbf9-36668829e5e0.html

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

wlcy1988
等　级：

#62楼得分：0回复于：2008-09-22 21:48:06

顶下

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

wzzwt
等　级：

#63楼得分：0回复于：2008-09-23 23:21:29

支持下

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

formajia3
(2)
等　级：

#64楼得分：0回复于：2008-09-24 16:57:31

专门来做记号，慢慢研究

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

beastbobo
(beastbobo)
等　级：

#65楼得分：0回复于：2008-09-28 15:54:17

有些内容比Intel出版的那本多核程序设计技术详细。
学习了。
还想向楼主请教一个非技术性的问题，望不吝赐教。
我是研二的学生，编程新手，等于说全部都是从头来的，包括语言。
现在刚入了个门，老板就让我来研究并行编程了。
刚刚有了点头绪，但是心里仍然没底，看了书过后不知从何下手了。
不知道有什么途径可以对内容加深理解，提高应用的能力？
当然你可能说多练习，我就是不知道给从何处开始练习啊，
不知道能不能有些例程之类，
我还要多长时间才能真正的上手呢？迷茫...
期待楼主能解惑
也希望大家多给我帮助，共同进不。

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

majiajun_no_2
(马甲军)
等　级：

#66楼得分：0回复于：2008-09-29 23:42:04

我同意支持一下

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

laxila
(希腊多)
等　级：

#67楼得分：0回复于：2008-09-30 12:41:59

非常好，学习过了，谢谢楼主呀！！！

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

majiajun_no_5
(马甲军)
等　级：

#68楼得分：0回复于：2008-09-30 23:31:56

获益匪浅

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

treetor
(treetor)
等　级：

#69楼得分：0回复于：2008-09-30 23:37:08

要做个记号

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

cornmoon_blue
(BlueCornMoon)
等　级：

#70楼得分：0回复于：2008-10-02 18:34:02

建议大家看看熬富江的《并行程序设计模式》，机械工业(或者电工？)，

非常不错的书

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

szy41
(szy41)
等　级：

#71楼得分：0回复于：2008-10-28 12:17:36

mark

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

cdef9108
等　级：

#72楼得分：0回复于：2008-10-28 13:09:48

mark,学习。

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

honeyxuer
(雪儿)
等　级：

#73楼得分：0回复于：2008-11-05 18:36:24

刚接触多核编程，前段时间搞过并行，发现差别还是相当的大啊，学习阶段……

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

goldencode
等　级：

#74楼得分：0回复于：2008-12-05 12:10:07

不错, OpenMP使用上比Native API方便多了,只要在你需要并行的地方加个编译器语句指明关键的变量的属性,编译器就负责帮你创建多线程了.

对我有用[1]
丢个板砖[0]
引用
举报
管理
TOP

qgdbr08
(qgdbr08)
等　级：

#75楼得分：0回复于：2009-03-04 15:45:50

谢谢~ 辛苦了..
为什么前边好多例子我都看不见了，只显示 CSDN图样..
为什么我再 VS2005环境中，用Intel编译器编译，会出现找不到libguide40.dll的错误提示呢？？

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

seavon
(seavon)
等　级：

#76楼得分：0回复于：2009-03-18 12:10:56

引用 33 楼 intel_jeff 的回复:
================================================
OpenMP中工作量的划分与调度
================================================
......
如上图所示，工作量的划分与调度有3种方式：
1、静态：把循环的迭代按照每x次(x=chunk)迭代分为一块，这样你的总工作量就被划分成了n/x块(n为迭代次数、循环次数)，然后将这些块按照轮转法依次分配给各个线程。举个例子：比如我们有100次迭代，x=chunk=4，那么我们的工作就被分为25块，假设我们有2个线程可以做工作，那么线程1分到的块是1,3,5,7....,25，线程2分到的块是2,4,6,...,24；
2、动态：迭代分块方法同上，但是工作块被放到一个队列中，每个线程每次拿一块，做好了才能到队列里去拿下一块；
3、Guided：这个方式是动态方式的改进。在这个方式里，分块的x是不固定的，一开始块的大小(x)比较大，随着剩余工作量的减小，块的大小也随之变小。

关于静态的任务分配顺序好像与这里说的不是很一致，或者不同的编译器有不同的实现方式，比如在GCC上，如果任务数为N，线程数为T，
实际用到的线程数t = [N / [N/T]上取整 ]上取整，比如N=10,T=8,那么t=5,也就是只有5个线程真正启动，而线程1被分配到的是任务0和1，线程2分配到2和3，以此类推。
这样做还是有好处的，假设每个任务所需的时间一样，那么就可以在保证同样运行时间的情况下减少线程开销。

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

wwwquzhinet
(王小波)
等　级：

#77楼得分：0回复于：2009-03-18 17:22:58

请教一个问题：

omp_get_thread_num() 这个函数，
得到的CPU编号是计算机上所有CPU的编号（全局编号），
还是当前并行区中CPU的编号（局部编号）
谢谢

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

wangjun825
(雪之舞)
等　级：

#78楼得分：0回复于：2009-05-05 17:30:13

期待楼主更新啊

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

hikaliv
(李博（光宇广贞）)
等　级：

#79楼得分：0回复于：2009-05-15 02:06:30

标一下。谢楼主。

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

intel_jeff
(Jeff@英特尔欢迎到"英特)
等　级：

#80楼得分：0回复于：2009-05-20 10:15:03

引用 77 楼 wwwquzhinet 的回复:
请教一个问题：

omp_get_thread_num() 这个函数，
得到的CPU编号是计算机上所有CPU的编号（全局编号），
还是当前并行区中CPU的编号（局部编号）
谢谢

这个编号是线程的编号，与CPU无关。返回的编号是0..N-1，N为总线程数
所以不管你机器上有几个CPU，假设你并行区里有8个线程，那他们返回的编号分别就是0, 1, ..., 7

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

intel_jeff
(Jeff@英特尔欢迎到"英特)
等　级：

#81楼得分：0回复于：2009-05-20 10:22:03

引用 76 楼 seavon 的回复:
引用 33 楼 intel_jeff 的回复:
================================================
OpenMP中工作量的划分与调度
================================================
......
如上图所示，工作量的划分与调度有3种方式：
1、静态：把循环的迭代按照每x次(x=chunk)迭代分为一块，这样你的总工作量就被划分成了n/x块(n为迭代次数、循环次数)，然后将这些块按照轮转法依次分配给各个线程。举个例子：比如我们有…

这个是跟OpenMP实现相关了，Intel编译器的实现是尊重T的值，因为在通常情况下，T=核的数量。有核不用岂不浪费？
在你给的这个例子中，你有一个假设：每块工作量（i循环每次迭代的工作量）都是差不多的，所以8个线程与5个线程最后的运行时间都是差不多的。但是如果每块工作量不均匀的话，8个线程很可能就会比5个线程的时候快了。

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

intel_jeff
(Jeff@英特尔欢迎到"英特)
等　级：

#82楼得分：0回复于：2009-05-20 10:23:57

引用 75 楼 qgdbr08 的回复:
谢谢~ 辛苦了..
为什么前边好多例子我都看不见了，只显示 CSDN图样..
为什么我再 VS2005环境中，用Intel编译器编译，会出现找不到libguide40.dll的错误提示呢？？

你是说在运行的时候找不到这个DLL吧？这个DLL在Intel编译器安装目录里面，你在运行环境中把这个DLL路径加到PATH里就可以了。

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

beyond_jhf
(beyond_jhf)
等　级：

#83楼得分：0回复于：2009-05-26 17:20:47

辛苦了，intel_jeff大哥。。向你致敬！！！
好好学习OpenMP！！！

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

goldensea001
(popbird)
等　级：

#84楼得分：0回复于：2009-06-24 12:34:05

学习了,收获颇丰,非常感谢楼主.

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

miaoshasha
(miaoshasha)
等　级：

#85楼得分：0回复于：2009-10-08 14:31:27

学习了，非常感谢
如果能看到你是怎样用openmp解决一个复杂的算法就好了

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

shark_sq
(shark_sq)
等　级：

#86楼得分：0回复于：2009-12-17 14:11:53

引用 74 楼 goldencode 的回复:
不错, OpenMP使用上比Native API方便多了,只要在你需要并行的地方加个编译器语句指明关键的变量的属性,编译器就负责帮你创建多线程了.

相当经典简洁的总结啊：一是加上语句，二是指名关键变量属性。
剩下的就交给编译器来负责了~~

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

JiaoYanChen
(JiaoYanChen)
等　级：

#87楼得分：0回复于：2009-12-18 20:30:49

好贴，LZ有心人啊，先回了再细看

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

walk121
等　级：

#88楼得分：0回复于：2010-01-25 21:11:40

假设程序中有若干个线程以流水线的方式完成一个任务，想在每个线程里利用openMp
有个疑问，
如果机器是8核的话，由于线程之间协作的繁忙程度不一样，线程里的openmp设为几个并行处理比较好？
openMP在每个线程里会根据当前总体的运行情况(cpu繁忙程度)进行动态的调整并行任务个数还是会固定的采取8个核？
如果采取固定8个核会不会影响效率？

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

teribithia
(teribithia)
等　级：

#89楼得分：0回复于：2010-05-08 10:31:41

小弟在Linux下写了一个简单的omp程序，大体结构是
while（1）
{
#pragma omp parallel for
for(int i=0; i<4; i++)
{
//数据处理
}
//显示此次循环的时间
sleep(n);
}
数据处理代码是不相关的，或者都注释掉也行，应该只是线程开销比较大。主要问题是sleep时间不同的时候，主线程CPU使用率不同，但是子线程的cpu使用率一直接近100%，使得整体的CPU使用率很高。但在windows使用相同的程序，子线程的cpu使用率基本和主线程一致。
Linux下编译的时候：g++ -fopenmp -o outfile [srcfile]
程序中包含了
windows下使用的是VS2008，使用的也是默认设置。
请问这是为什么啊？

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

hqjjsw520
(hqjjsw520)
等　级：

#90楼得分：0回复于：2010-05-10 17:04:41

请问OpenMP支持跨平台开发吗？

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

dyl123dyl123
(dyl123dyl123)
等　级：

#91楼得分：0回复于：2010-07-08 16:15:38

每天回帖即可获得10分可用分！

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

dengxiaer
(霞儿)
等　级：

#92楼得分：0回复于：2010-08-03 19:42:02

我用openMP写了一个程序，刚开始几秒的执行速度很快，然后速度就开始下降，这是什么原因啊？

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

anxin821
(anxin821)
等　级：

#93楼得分：0回复于：2010-08-05 21:12:22

openMP能在c++builder 6 中用么？

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

geniusufo
(geniusufo)
等　级：

#94楼得分：0回复于：2010-08-08 23:41:50

每天回帖即可获得10分可用分

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

zuopaide
(zuopaide)
等　级：

#95楼得分：0回复于：2010-09-19 23:13:25

相见恨晚啊

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

a408498863
(a408498863)
等　级：

#96楼得分：0回复于：2010-09-19 23:14:17

看不懂

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

fengpei9
(fengpei9)
等　级：

#97楼得分：0回复于：2010-10-02 11:16:04

您好！想请问下如何合理有效的使用多核系统中的多级缓存？谢谢

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

jiaon
等　级：

#98楼得分：0回复于：2010-10-14 18:22:37

对递归算法起作用吗？

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

guluyiyi
(guluyiyi)
等　级：

#99楼得分：0回复于：2010-11-30 11:50:54

QIANG!

对我有用[0]
丢个板砖[0]
引用
举报
管理
TOP

你可能感兴趣的:(WORD)

[AI笔记]-Word2Vec面试考点 Micheal超 AI笔记人工智能笔记 word2vec
✅一、基础认知类什么是Word2Vec？它的基本思想是什么？关键词：将词语转换为向量表示；捕捉语义关系；基于上下文预测Word2Vec与One-hot编码的区别？关键词：维度灾难(维度过高，存储空间大)、高稀疏性、语义表达能力(没有距离概念，无法计算相似度)、内积关系Word2Vec的两种模型是什么？它们有何区别？答案：Word2Vec的重要假设：文本中离得越近的词语相似度越高。主要有：CBOW（
RabbitMQ实现路由模式发送接收消息
1.基础类publicclassRabbitMQHelper{publicstaticIConnectionGetConnect(){//连接工厂varfac=newConnectionFactory(){HostName=“127.0.0.1”,//IPPort=5672,//端口UserName=“xxx”,Password=“xxx”,VirtualHost=“/”};returnfac.C
python实战:在Linux服务器上使用LibreOffice命令行批量接受Word文档的所有修订 Ven% 服务器 python linux LiberOffice 开源办公软件 linux办公软件
在Linux服务器上使用LibreOffice命令行批量接受Word文档的所有修订一、背景与需求1.1常见场景1.2为什么选择LibreOffice二、环境准备2.1安装LibreOffice2.2验证安装三、Python实现代码四、代码解析4.1主要功能4.2错误处理4.3使用灵活性五、高级应用5.1批量处理多个文件5.2与其他工具集成六、注意事项七、总结在实际工作中，我们经常需要处理包含修订标
MFC小例子说明千里修行 MFC Windows
目录一.枚举窗口EnumDialog1.枚举方式2.查找窗口3.检测当前应用程序是否存在二.按钮激活ButtonActive1.原理2.实现三.星形查看器AsterPassword1.原理2.实现四.图片浏览器ImageExplore1.原理2.实现五.模拟键鼠消息MouseKeboardClick1.原理2.实现六.屏幕放大镜ScreenMagnify1.原理2.实现七.屏幕截图功能SCreen
Word插入公式时OLE错误解决方法洛昂ᯤ⁶ᴳ word c#开发语言
这个错误提示通常发生在Word尝试通过OLE（对象链接与嵌入）与其他应用程序（如MathType或Excel）通信时，通信被阻塞或未能正确完成。导致此问题的常见原因及解决方法有以下几种可能的原因，请按顺序尝试：常见原因和解决方法1.后台卡死的Excel进程：这是最常见的原因。即使你没有主动使用Excel，也可能有隐藏的Excel进程卡在后台（例如，之前打开过包含Excel图表的Word文档，或者O
Nginx 运维实战与 HTML 静态网页开发全攻略
一、技术背景：静态站点的黄金时代1.静态网页的复兴浪潮性能优势：对比动态站点，静态资源响应速度提升60%+，首屏加载时间平均缩短1.2秒（基于WebPageTest实测数据）技术演进：Jamstack架构普及（2024年市场占有率达37%），Hugo、Nuxt.js等静态站点生成器（SSG）推动企业级应用典型场景：企业官网（占比78%）、产品着陆页（转化率提升23%）、博客系统（WordPress
行为型设计模式-备忘录模式网络深处的易某某设计模式设计模式备忘录模式开发语言后端
一、备忘录模式备忘录模式提供了一种状态恢复的实现机制，使得用户可以方便地回到一个特定的历史步骤，当新的状态无效或者存在问题时，可以使用暂时存储起来的备忘录将状态复原，很多软件都提供了撤销（Undo）操作，如Word、记事本、Photoshop、IDEA等软件在编辑时按Ctrl+Z组合键时能撤销当前操作，使文档恢复到之前的状态；还有在浏览器中的后退键、数据库事务管理中的回滚操作、玩游戏时的中间结果存
解决web服务中在线查看minio上文件提示CORS的问题 Hong.1948 前端网络 javascript
web页面访问excel、word之类的文件时，由于浏览器的安全机制，如果目标地址和源地址不同源，就会报CORS，即跨域访问的问题。解决跨域的问题，主要有2个思路：方案1：修改目标服务的CORS策略，允许跨域访问方案2：强行同源，然后使用nginx转发请求。此前使用s3服务的时候，使用方案1解决了跨域访问的问题。s3服务，不管是客户端还是pythonsdk，都可以直接修改指定桶的CORS策略，配置
003-128 最长连续序列 Ernest_NEU 算法 leetcode
题目我的思考+word题解题解题解思路classSolution{publicintlongestConsecutive(int[]nums){SetnumSet=newHashSet<>();for(intnum:nums){numSet.add(num);}intmaxLength=0;for(intnum:numSet){if(!numSet.contains(num-1)){intcurN
151. 翻转字符串里的单词 ( 三种实现) 小可爱amour 每日一题 C/C++leetcode 字符串
题目要点：1：字符串首尾都有可能存在多余的空格2：字符串中间单词之间又可能存在连续多个空格解法1：从字符串手择单词，放到一个缓存数组里classSolution{private://传入字符串的左下标，确定单词的有效左右下标，右下标指向单词的下一位boolgetWord(conststring&s,intlen,int&left,int&right){while(left=len)returnfa
免费文件管理智能转换GC-Prevue：PDF 转 Word 多种格式一键完成文哥工具箱2 开源软件电脑软件工程
前言在现代办公环境中，高效的数据处理和文档管理是提高工作效率的关键。GC-Prevue是一款专为Windows系统设计的办公辅助软件，软件下载地址安装包它通过一系列实用的功能，帮助用户更高效地处理和管理文档，提升整体办公效率。软件介绍GC-Prevue是一款集成了多种办公辅助功能的软件，旨在帮助用户更便捷地处理文档、表格和演示文稿。它支持多种文件格式，包括PDF、Word、Excel和PowerP
python 复制word表格并粘贴_Python应用之可控顺序复制粘贴 weixin_40005887 python 复制word表格并粘贴
1、应用场景：有大量源数据（保存在Excel表格中）需要逐个进行筛查（在第三方平台接口进行查询）。2、场景举例：由于学生无法上网，老师需要帮助上百名同学在第三方平台查询考试成绩。平台无法批量导入查询，只能逐个输入查询。3、常规操作步骤：从excel表格复制一个源数据，然后粘贴到第三方平台输入口，然后点击查询，获取查询结果。4、常规操作的问题：频繁切换窗口从excel中单元格中复制数据比较繁琐，此动
python word表格操作_Python|处理word的基本操作苗舰舰 python word表格操作
问题描述众所周知python有很多第三方库，这也是python简单实用的原因。要想用python处理word文档就需要安装python-docx库。解决方案1安装python-docx库首先找到python根目录(就是有python.exe的文件夹)打开Scripts文件夹Shift+鼠标右键选择在此处打开powershell窗口或者cmd窗口输入pipinstallpython-docx按下回车
Hadoop WordCount 程序实现与执行指南
HadoopWordCount程序实现与执行指南下面是使用Python实现的HadoopWordCount程序，包含完整的Mapper和Reducer部分。这个程序可以在PyCharm中本地测试，也可以部署到远程Hadoop集群上运行。mapper.pyimportsys#从标准输入读取数据forlineinsys.stdin:#移除行首行尾的空白字符line=line.strip()#将行分割为
Python|读取word文档表格内容算法与编程之美算法之美编程语言人工智能 python 数据挖掘数据可视化
本文首发于微信公众号："算法与编程之美"，欢迎关注，及时了解更多此系列文章。引言在日常生活里，不管是办公、学习还是制作邀请函、请柬、简历等等，我们都会使用一个软件MicrosoftOfficeWord，OfficeWord是微软公司的一个收费文字处理应用程序，是最流行的文字处理程序之一，它虽功能强大，但简学易懂，但同时也有一个缺点，当一个Word文档储存的内容特别庞大的时候，使用者想要提取自己想要
Python正式课11_关于cookie和session 时寒的笔记 python 开发语言
一、概念"""http,无连接,无状态.我们在淘宝上买东西.用户登陆的状态是必须要有的...工作当中是需要这个状态的.但是http协议是不负责维持这个状态的.loginusernamepassword浏览器想了一个办法.弄了一个本地化的存储.来保持这个状态.本地保存的这个东西.每次发请求的时候.浏览器都会自动携带该信息.这个本地化的存储.我们叫它cookiecookie的生成过程:1.cookie
elasticsearch 9200登录接口 leijmdas elasticsearch
嗯，关于Elasticsearch通过9200端口的登录接口，本质是启用安全认证后对HTTP请求的身份验证机制。以下是核心要点及操作指南：一、认证方式基础认证（用户名+密码）访问http://localhost:9200时会弹出登录框，需输入用户名和密码。默认超级用户：elastic，首次安装后密码需通过命令生成：./bin/elasticsearch-reset-password-uelasti
OpenGauss数据库-L.应用开发(Python)-选做 lovane_630 数据库 python oracle
第1关：简单查询#加载数据库模块importpsycopg2#连接数据库,创建连接并返回连接对象defconnect():conn=psycopg2.connect(database="finance",user="gaussdb",password="Passwd123@123",host="localhost")returnconn#建立与数据库连接mydb=connect()#获取游标#执行
docker-compose启动mysql一直提示挂载目录存在文件
version:"3.8"services:mysql:image:mysql:8.0.33container_name:mysqlrestart:unless-stoppedenvironment:MYSQL_ROOT_PASSWORD:123456MYSQL_DATABASE:sample_dbTZ:Asia/Shanghaiports:-"3306:3306"volumes:-/exampl
计算机考试发送邮件教程,电脑考试怎么发邮件 weixin_42613017 计算机考试发送邮件教程
匿名用户1级2018-12-16回答从电脑上打开“OutlookExpress”；2、单击"工具栏"上"新邮件"图标撰写新邮件；3、填写收件人的地址、抄送人地址及邮件主题(收件人地址是不可缺省的)，撰写邮件内容。如果事先用word或Excel已经撰写好附件，可以单击"工具栏"上的"附加"按钮添加附件。5、单击"工具栏"上的"发送"按钮，发送邮件。这样就完成了。一级MSOFFICE邮件收发是
使用 SQLite 和 Brighter 实现发件箱模式 actor_dev c#.net brighter sqlite
简介本指南演示如何使用SQLite和.NET8，结合Brighter库实现**发件箱模式（OutboxPattern）**，以确保数据库更新与消息发布之间的事务一致性。项目目标处理CreateNewOrder命令，在事务成功时发布两个事件（OrderPlaced,OrderPaid）。如果发生错误（例如业务规则冲突），则回滚数据库更改和消息发布。要求.NET8+使用Podman（或Docker）运
使用 MySQL 和 Brighter 实现出站箱模式 actor_dev .net c#brighter rabbitmq mysql 发件箱模式
简介本指南演示了如何使用Brighter库在MySQL和.NET8中实现Outbox模式(出站箱模式),以确保数据库更新和消息发布之间的事务一致性。项目目标处理一个CreateNewOrder命令，并且只有在事务成功时才发布两个事件(OrderPlaced,OrderPaid）。如果发生错误(例如业务规则冲突),则数据库更改和消息发布都将回滚。要求.NET8+Podman(或Docker)运行本地
C# 讯飞语音唤醒 jones.s c#
publicpartialclassMainWindow:Window{//导入C/C++的库文件[DllImport("msc_x64.dll",CallingConvention=CallingConvention.Winapi)]publicstaticexternintMSPLogin(stringusername,stringpassword,stringloginParams);[Dl
外观模式 - Flutter中的一键操作大师，复杂功能的极简入口！明似水 flutter 外观模式 flutter javascript
痛点场景：多步骤的用户注册流程假设你的应用需要处理以下注册步骤：验证邮箱格式检查密码强度调用注册API保存用户Token初始化用户配置同步基础数据发送欢迎邮件传统实现方式：FutureregisterUser(Stringemail,Stringpassword)async{//1.验证邮箱if(!EmailValidator.validate(email)){throwInvalidEmailE
一款wordperss AI免费插件自动内容生成+前端AI交互+文章批量采集 Linkreate 前端人工智能 wordpress wordpressAI插件 wordpress免费插件 wordpress自动发文自动发文源码
一款LinkreatewordperssAI自动内容生成+前端AI会话窗口交互+文章批量采集免费插件1.SEO优化文章生成关键词驱动的内容生成：用户可以输入关键词或长尾关键词，插件会根据这些关键词生成高质量的SEO优化文章。文章结构清晰，语言自然流畅，符合SEO标准，能够有效提升网站内容的搜索引擎排名。自定义文章长度和要求：用户可以根据需要指定文章的长度（字数）以及对文章的额外要求，例如内容风格、
织梦DedeCMS转WordPress asqq8
最近，有个用户找模板兔迁移网站，源站用的dede，需要转成wp，文章数量大概7000-8000篇，其中有个需求是保证旧文章的链接有效，在wp上的新文章与旧文章的链接类型不一样，所以这涉及到伪静态来处理跳转。虽然网上都很多教程，但是在这次导入过程中还是遇到过一些问题。以下教程是dede的数据表得与wp的数据表在同一个数据库下！要是不在，可以将dede_archives先导入到wp的数据库里。一般流程
文本数据增强-同义词替换、随机交换、随机插入、随机删除
根据zhangy代码改写，主要针对千言问题匹配进行文本数据增强。依赖安装pipinstalljiebapipinstallsynonymseda.pyimportjiebaimportsynonymsimportrandomfromrandomimportshufflerandom.seed(2019)#停用词列表，默认使用哈工大停用词表f=open('stopwords/hit_stopword
java 导出pdf去除边框_docx4j生成pdf时，如何指定pdf的页边框
生成pdf：publicStringsavePdf(WordprocessingMLPackagewordMLPackage,Mapdata)throwsException{StringpdfDir=getFilePath()+".pdf";Filefile=newFile(pdfDir);FileUtils.createDir(file);//使用默认的FOSettingssettings.se
Java使用documents4j将word和excel转pdf 药岩工作中的那些问题 java word excel
pom.xml添加documents4j依赖com.documents4jdocuments4j-local1.0.3com.documents4jdocuments4j-transformer-msoffice-word1.0.3<dependency
Leetcode【串联所有单词的子串】
30.串联所有单词的子串给定一个字符串s和一个字符串数组words。words中所有字符串长度相同。s中的串联子串是指一个包含words中所有字符串以任意顺序排列连接起来的子串。例如，如果words=["ab","cd","ef"]，那么"abcdef"，"abefcd"，"cdabef"，"cdefab"，"efabcd"，和"efcdab"都是串联子串。"acdbef"不是串联子串，因为他不是
JAVA基础灵静志远位运算加载 Date 字符串池覆盖
一、类的初始化顺序 1 （静态变量，静态代码块）-->（变量，初始化块）--> 构造器同一括号里的，根据它们在程序中的顺序来决定。上面所述是同一类中。如果是继承的情况，那就在父类到子类交替初始化。二、String 1 String a = "abc"; JAVA虚拟机首先在字符串池中查找是否已经存在了值为"abc"的对象，根
keepalived实现redis主从高可用 bylijinnan redis
方案说明两台机器（称为A和B），以统一的VIP对外提供服务 1.正常情况下，A和B都启动，B会把A的数据同步过来（B is slave of A） 2.当A挂了后，VIP漂移到B；B的keepalived 通知redis 执行：slaveof no one，由B提供服务 3.当A起来后，VIP不切换，仍在B上面；而A的keepalived 通知redis 执行slaveof B，开始
java文件操作大全 0624chenhong java
最近在博客园看到一篇比较全面的文件操作文章，转过来留着。 http://www.cnblogs.com/zhuocheng/archive/2011/12/12/2285290.html 转自http://blog.sina.com.cn/s/blog_4a9f789a0100ik3p.html 一.获得控制台用户输入的信息 &nbs
android学习任务不懂事的小屁孩工作
任务完成情况搞清楚带箭头的pupupwindows和不带的使用已完成熟练使用pupupwindows和alertdialog，并搞清楚两者的区别已完成熟练使用android的线程handler,并敲示例代码进行中了解游戏2048的流程，并完成其代码工作进行中-差几个actionbar 研究一下android的动画效果，写一个实例已完成复习fragem
zoom.js 换个号韩国红果果 oom
它的基于bootstrap 的 https://raw.github.com/twbs/bootstrap/master/js/transition.js transition.js模块引用顺序 <link rel="stylesheet" href="style/zoom.css"> <script src=&q
详解Oracle云操作系统Solaris 11.2 蓝儿唯美 Solaris
当Oracle发布Solaris 11时，它将自己的操作系统称为第一个面向云的操作系统。Oracle在发布Solaris 11.2时继续它以云为中心的基调。但是，这些说法没有告诉我们为什么Solaris是配得上云的。幸好，我们不需要等太久。Solaris11.2有4个重要的技术可以在一个有效的云实现中发挥重要作用：OpenStack、内核域、统一存档（UA）和弹性虚拟交换（EVS）。
spring学习——springmvc（一） a-john springMVC
Spring MVC基于模型-视图-控制器（Model-View-Controller，MVC）实现，能够帮助我们构建像Spring框架那样灵活和松耦合的Web应用程序。 1，跟踪Spring MVC的请求请求的第一站是Spring的DispatcherServlet。与大多数基于Java的Web框架一样，Spring MVC所有的请求都会通过一个前端控制器Servlet。前
hdu4342 History repeat itself-------多校联合五 aijuans 数论
水题就不多说什么了。 #include<iostream>#include<cstdlib>#include<stdio.h>#define ll __int64using namespace std;int main(){ int t; ll n; scanf("%d",&t); while(t--)
EJB和javabean的区别 asia007 bean ejb
EJB不是一般的JavaBean,EJB是企业级JavaBean,EJB一共分为3种,实体Bean,消息Bean,会话Bean,书写EJB是需要遵循一定的规范的,具体规范你可以参考相关的资料.另外,要运行EJB,你需要相应的EJB容器,比如Weblogic,Jboss等,而JavaBean不需要,只需要安装Tomcat就可以了 1.EJB用于服务端应用开发, 而JavaBeans
Struts的action和Result总结百合不是茶 struts Action配置 Result配置
一:Action的配置详解: 下面是一个Struts中一个空的Struts.xml的配置文件 <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE struts PUBLIC &quo
如何带好自已的团队 bijian1013 项目管理团队管理团队
在网上看到博客" 怎么才能让团队成员好好干活"的评论，觉得写的比较好。原文如下：我做团队管理有几年了吧，我和你分享一下我认为带好团队的几点： 1.诚信对团队内成员，无论是技术研究、交流、问题探讨，要尽可能的保持一种诚信的态度，用心去做好，你的团队会感觉得到。 2.努力提
Java代码混淆工具 sunjing ProGuard
Open Source Obfuscators ProGuard http://java-source.net/open-source/obfuscators/proguardProGuard is a free Java class file shrinker and obfuscator. It can detect and remove unused classes, fields, m
【Redis三】基于Redis sentinel的自动failover主从复制 bit1129 redis
在第二篇中使用2.8.17搭建了主从复制，但是它存在Master单点问题，为了解决这个问题，Redis从2.6开始引入sentinel，用于监控和管理Redis的主从复制环境，进行自动failover，即Master挂了后，sentinel自动从从服务器选出一个Master使主从复制集群仍然可以工作，如果Master醒来再次加入集群，只能以从服务器的形式工作。什么是Sentine
使用代理实现Hibernate Dao层自动事务白糖_ DAO spring AOP 框架 Hibernate
都说spring利用AOP实现自动事务处理机制非常好，但在只有hibernate这个框架情况下，我们开启session、管理事务就往往很麻烦。 public void save(Object obj){ Session session = this.getSession(); Transaction tran = session.beginTransaction(); try
maven3实战读书笔记 braveCS maven3
Maven简介是什么？ Is a software project management and comprehension tool.项目管理工具是基于POM概念(工程对象模型) [设计重复、编码重复、文档重复、构建重复，maven最大化消除了构建的重复] [与XP：简单、交流与反馈；测试驱动开发、十分钟构建、持续集成、富有信息的工作区] 功能：
编程之美-子数组的最大乘积 bylijinnan 编程之美
public class MaxProduct { /** * 编程之美子数组的最大乘积 * 题目: 给定一个长度为N的整数数组，只允许使用乘法，不能用除法，计算任意N-1个数的组合中乘积中最大的一组，并写出算法的时间复杂度。 * 以下程序对应书上两种方法，求得“乘积中最大的一组”的乘积——都是有溢出的可能的。 * 但按题目的意思，是要求得这个子数组，而不
读书笔记-2 chengxuyuancsdn 读书笔记
1、反射 2、oracle年-月-日时-分-秒 3、oracle创建有参、无参函数 4、oracle行转列 5、Struts2拦截器 6、Filter过滤器(web.xml) 1、反射 (1)检查类的结构在java.lang.reflect包里有3个类Field,Method,Constructor分别用于描述类的域、方法和构造器。 2、oracle年月日时分秒 s
[求学与房地产]慎重选择IT培训学校 comsci it
关于培训学校的教学和教师的问题,我们就不讨论了,我主要关心的是这个问题培训学校的教学楼和宿舍的环境和稳定性问题我们大家都知道，房子是一个比较昂贵的东西，特别是那种能够当教室的房子... &nb
RMAN配置中通道(CHANNEL)相关参数 PARALLELISM 、FILESPERSET的关系 daizj oracle rman filesperset PARALLELISM
RMAN配置中通道(CHANNEL)相关参数 PARALLELISM 、FILESPERSET的关系转 PARALLELISM --- 我们还可以通过parallelism参数来指定同时"自动"创建多少个通道： RMAN > configure device type disk parallelism 3 ; 表示启动三个通道，可以加快备份恢复的速度。
简单排序:冒泡排序 dieslrae 冒泡排序
public void bubbleSort(int[] array){ for(int i=1;i<array.length;i++){ for(int k=0;k<array.length-i;k++){ if(array[k] > array[k+1]){
初二上学期难记单词三 dcj3sjt126com sciet
concert 音乐会 tonight 今晚 famous 有名的；著名的 song 歌曲 thousand 千 accident 事故；灾难 careless 粗心的，大意的 break 折断；断裂；破碎 heart 心（脏） happen 偶尔发生，碰巧 tourist 旅游者；观光者 science （自然）科学 marry 结婚 subject 题目；
I.安装Memcahce 1. 安装依赖包libevent Memcache需要安装libevent,所以安装前可能需要执行 Shell代码收藏代码 dcj3sjt126com redis
wget http://download.redis.io/redis-stable.tar.gz tar xvzf redis-stable.tar.gz cd redis-stable make 前面3步应该没有问题，主要的问题是执行make的时候，出现了异常。异常一： make[2]: cc: Command not found 异常原因：没有安装g
并发容器 shuizhaosi888 并发容器
通过并发容器来改善同步容器的性能，同步容器将所有对容器状态的访问都串行化，来实现线程安全，这种方式严重降低并发性，当多个线程访问时，吞吐量严重降低。并发容器ConcurrentHashMap 替代同步基于散列的Map，通过Lock控制。 &nb
Spring Security（12）——Remember-Me功能 234390216 Spring Security Remember Me 记住我
Remember-Me功能目录 1.1 概述 1.2 基于简单加密token的方法 1.3 基于持久化token的方法 1.4 Remember-Me相关接口和实现
位运算焦志广位运算
一、位运算符Ｃ语言提供了六种位运算符： & 按位与 | 按位或 ^ 按位异或 ~ 取反 << 左移 >> 右移 1. 按位与运算按位与运算符"&"是双目运算符。其功能是参与运算的两数各对应的二进位相与。只有对应的两个二进位均为1时，结果位才为1 ，否则为0。参与运算的数以补码方式出现。例如：9&am
nodejs 数据库连接 mongodb mysql liguangsong mongodb mysql node 数据库连接
1.mysql 连接 package.json中dependencies加入 "mysql":"~2.7.0" 执行 npm install 在config 下创建文件 database.js
java动态编译 olive6615 java HotSpot jvm 动态编译
在HotSpot虚拟机中，有两个技术是至关重要的，即动态编译(Dynamic compilation)和Profiling。 HotSpot是如何动态编译Javad的bytecode呢？Java bytecode是以解释方式被load到虚拟机的。HotSpot里有一个运行监视器，即Profile Monitor,专门监视
Storm0.9.5的集群部署配置优化 roadrunners 优化 storm.yaml
nimbus结点配置（storm.yaml）信息： # Licensed to the Apache Software Foundation (ASF) under one # or more contributor license agreements. See the NOTICE file # distributed with this work for additional inf
101个MySQL 的调节和优化的提示 tomcat_oracle mysql
　1. 拥有足够的物理内存来把整个InnoDB文件加载到内存中——在内存中访问文件时的速度要比在硬盘中访问时快的多。　　2. 不惜一切代价避免使用Swap交换分区 – 交换时是从硬盘读取的，它的速度很慢。　　3. 使用电池供电的RAM（注：RAM即随机存储器）。　　4. 使用高级的RAID（注：Redundant Arrays of Inexpensive Disks，即磁盘阵列
zoj 3829 Known Notation(贪心) 阿尔萨斯 ZOJ
题目链接：zoj 3829 Known Notation 题目大意：给定一个不完整的后缀表达式，要求有2种不同操作，用尽量少的操作使得表达式完整。解题思路：贪心，数字的个数要要保证比∗的个数多1，不够的话优先补在开头是最优的。然后遍历一遍字符串，碰到数字+1，碰到∗-1,保证数字的个数大于等1，如果不够减的话，可以和最后面的一个数字交换位置（用栈维护十分方便），因为添加和交换代价都是1