OpenMP笔记(四)

个人博客地址：http://www.bearoom.xyz/2019/02/22/openmp4/

一、private

private子句用于将一个或多个变量声明成线程私有的变量，这样每个线程都有该变量的副本，不同线程的操作不会改变其他线程中的同名变量副本，且并行块的所有操作都不会影响外面的同名共享变量。 例子：

int k = 11;
printf("k=%d, &k=%d\n", k, &k);
omp_set_num_threads(10);
#pragma omp parallel for private(k)
for (k = 0; k < 10; k++)
{
    printf("k=%d, &k=%d, threadID=%d\n", k, &k, omp_get_thread_num());
}
printf("k=%d, &k=%d\n", k, &k);

这个说明并行块中每个线程的变量k跟共享变量k的地址都是不一样的。但是，这里加不加private(k)结果都是一样的。但是在下面这种情况，加不加private(k)结果是不一样的。 不加的情况：

int k = 11;
printf("k=%d, &k=%d\n", k, &k);
omp_set_num_threads(10);
#pragma omp parallel for 
for (int i = 0; i < 10; i++)
{
    k = i;
    printf("k=%d, &k=%d, threadID=%d\n", k+=i, &k, omp_get_thread_num());
}
printf("k=%d, &k=%d\n", k, &k);

加private(k)的情况：

要注意，加private(k)的时候以下的情况是会编译报错的：

int k = 11;
printf("k=%d, &k=%d\n", k, &k);
omp_set_num_threads(10);
#pragma omp parallel for private(k)
for (int i = 0; i < 10; i++)
{
    printf("k=%d, &k=%d, threadID=%d\n", k+=i, &k, omp_get_thread_num());
}
printf("k=%d, &k=%d\n", k, &k);

二、firstprivate

private就是并行块内部的同名变量与外部的共享变量无关，而firstprivate就是该变量依然无关，但是会用外部共享变量来初始化并行块内部的变量。例子：

int k = 11;
printf("k=%d, &k=%d\n", k, &k);
omp_set_num_threads(10);
#pragma omp parallel for firstprivate(k)
for (int i = 0; i < 10; i++)
{
    printf("k=%d, &k=%d, threadID=%d\n", k += i, &k, omp_get_thread_num());
}
printf("k=%d, &k=%d\n", k, &k);

k是用了外部的值做初始化，但是不改变外部的值，不加的话，结果如下：

与firstprivate(k)相对的有lastprivate(k)，如果只有firstprivate则不会改变外部，加了lastprivate就可以改变外部变量，此时并不是将运行在最后的一个线程的结果复制给外部共享变量，而是将语法上的最后一个线程的值复制给外部变量。

三、shared，default

shared子句用来声明一个或多个变量是共享变量，这个共享变量在不同线程之间是共享的，所以要注意当对共享变量存在写操作的时候就需要加以保护。 default允许用户控制并行区域中变量的共享属性，用法如下：default(shared | none)，使用shared时，缺省情况下，传入并行区域内的同名变量被当作共享变量来处理，不会产生线程私有副本，除非使用private等子句来指定某些变量为私有的才会产生副本；如果使用none作为参数，那么线程中用到的变量必须显示指定是共享的还是私有的，除了那些有明确定义的除外。

四、reduction

reduction子句主要用来对一个或多个参数条目指定一个操作符，每个线程将创建参数条目的一个私有拷贝，在区域的结束处，将用私有拷贝的值通过指定的运行符运算，原始的参数条目被运算结果的值更新。也就说，传进来的参数在线程结束后，会依次对所有线程的拷贝做reduction指定的运算符操作，将结果复制给该参数。 reduction的用法：reduction(operator:list)，operator的符号如下：

例子 ：

int k = 2;
printf("k=%d, &k=%d\n", k, &k);
omp_set_num_threads(10);
#pragma omp parallel for reduction(*:k)
for (int i = 0; i < 10; i++)
{
    printf("k=%d, &k=%d, threadID=%d\n", k = 2, &k, omp_get_thread_num());
}
printf("k=%d, &k=%d\n", k, &k);

注意，如果在并行区域内不加锁保护就直接对共享变量进行写操作，存在数据竞争问题，会导致不可预测的异常结果。共享数据作为private、firstprivate、lastprivate、threadprivate、reduction子句的参数进入并行区域后，就变成线程私有了，不需要加锁保护了。

五、copyin

这里要介绍copyin，要先讲下指令threadprivate，threadprivate的作用是指定一个变量是线程局部存储（thread local storage），也就是不同并行区域的同个线程里，这个变量是全局的，这个指令的作用效果如下：

int A = 100;
#pragma omp threadprivate(A)

int main(int argc, char *argv[])
{
#pragma omp parallel for  
    for (int i = 0; i < 5; i++)
    {
        A++;
        printf("Thread ID, i, A: %d, %d, %d\n", omp_get_thread_num(), i, A);
    }
    printf("Global A: %d\n", A);

#pragma omp parallel for
    for (int i = 0; i < 5; i++)
    {
        A++;
        printf("Thread ID, i, A: %d, %d, %d\n", omp_get_thread_num(), i, A);
    }
    printf("Global A: %d\n", A);
    system("pause");
    return 0;
}

可以看到我使用了两个完全一样的并行块#pragma omp parallel for，每个块都是for循环五次，我的电脑CPU是4线程的，所以，四个线程执行一次并行的++，那么首先是都会变成101，然后有一次线程多执行了一次，变成两次++就是102，此时全局A就变成102。但是第二个for循环，可以看到，线程0的初始值是102，但是线程1、2、3的初始值不是，而是上一个并行块的线程中最后的值。
然后在第二个for循环里加上一个copyin(A):

int A = 100;
#pragma omp threadprivate(A)
int main(int argc, char *argv[])
{
#pragma omp parallel for  
    for (int i = 0; i < 5; i++)
        {
        A++;
        printf("Thread ID, i, A: %d, %d, %d\n", omp_get_thread_num(), i, A);
    }
    printf("Global A: %d\n", A);
#pragma omp parallel for copyin(A)
    for (int i = 0; i < 5; i++)
    {
        A++;
        printf("Thread ID, i, A: %d, %d, %d\n", omp_get_thread_num(), i, A);
    }
    printf("Global A: %d\n", A);
    system("pause");
    return 0;
}

可以看到，此时第二个for循环的A的初始值是102。这是因为copyin将主线程threadprivate修饰的变量的值拷贝到执行并行区域的各个线程的threadprivate变量中作为变量初始值。copyin修饰的参数必须是被threadprivate修饰过的。

六、copyprivate

copyprivate子句提供了一种机制用一个私有变量将一个值从一个线程广播到执行同一并行区域的其他线程。copyprivate子句可以关联single构造，在single构造的barrier到达之前就完成了广播工作。copyprivate可以对private和threadprivate子句中的变量进行操作，但是当使用single构造时，copyprivate的变量不能用于private和firstprivate子句中。
single修饰的代码块将会在一个线程中执行，但是不一定会是主线程，例子：

static int A = 100;
#pragma omp threadprivate(A)
int B = 100;
int C = 1000;
#pragma omp parallel firstprivate(B) copyin(A)
    {
#pragma omp single
        {
            A = 10;
            B = 20;
            printf("Thread ID = %d, A = %d，B = %d, C = %d\n", omp_get_thread_num(), A, B, C);
        }
        printf("Initial Thread ID = %d, A = %d，B = %d, C = %d\n", omp_get_thread_num(), A, B, C);
    }
printf("Global A = %d, B = %d, C = %d\n", A, B, C);

single修饰的后面一段代码是在线程2中执行，并且就执行一次，因为其他线程是不执行的。然后在single后面用copyprivate修饰一个变量，如A，#pragma omp single copyprivate(A)，则得到的结果是：

可以看到，A被广播到了其他线程了。

紫陌红尘拂面来，

无人不道看花回。

玄都观里桃千树，

尽是刘郎去后栽。

--刘禹锡 《元和十年自朗州至京戏赠看花诸君子/玄都观桃花》