UPC快速学习笔记(3)

Unified Parallel C - 统一并行C语言。用于并行计算和编程，是C语言的一个扩充版本。
转载任何内容都请注明出处。若用于任何教育或商业目的请先联系作者，谢谢。

3.1 UPC指针

和C差不多，但根据UPC公有变量和私有变量的不同，两两组合有4种指针

int *p1; // private to private
shared int *p2; // private to shared
int *shared p3; // shared to private
shared int *shared p4; // shared to shared

P3是公有指针，指向私有变量。不是非法，但应该避免，因为这与UPC的分布式共享内存模型的设计初衷（公有空间对所有线程可见，私有数据仅对相关联的线程可见）相违背。

3.2 指针的算术

#define N 16
shared int x [N];
shared int *dp, *dp1;
dp = &x [5];
dp1 = dp + 9;

 

#define N 16
shared int x [N];
shared int *shared dp;
shared int *dp1;
dp = & x [5];
dp1 = x+MYTHREAD;

dp只有一个实例，指向x[5]。dp1的偏移量是线程id，正好是每个线程的首个被分配到的元素

 若将最后一行改成：

dp1 = &x [MYTHREAD];

则dp1指向每个线程的首个数组元素的地址

为追踪共享数据，UPC的公有指针（即指向一个公有对象的指针）包含三个域：thread, phase, virtual address

 thread域指出所指向数据相关联的线程；block address 指出块地址(block address)；phase指出这个块内的数据项的所在位置。

通过给出一个有相同分块信息(blocking factor)的指针，可用于遍历分块数组(blocked array)，看下面

#define N 16
shared [3] int x[N], *dp, *dp1;
shared int *dp2;
...
dp = &x [5];
dp1 = dp + 9;
dp2 = dp + 3;

若4线程，数据布局为

 其他都好理解，为什么dp2指向x[12]呢？因为dp和dp1声明时提供了分块信息，他们把共享空间看作3个以所指向类型的数据为一块而构成的许多数据块。而dp2仍是默认方式，他不知道数据是有三个元素的一块，因此每次增加他都移向下一个线程的一个新元素。而dp1可以用于访问分块数组中的每个元素。

3.3 指针类型转换

shared->private 线程信息丢失；private->shared 出错；private->自己本地的共享数据，这是可以的，比如

shared int x [THREADS];
int *p;
p = (int *) &x [MYTHREAD]; /* p points to x [MYTHREAD] */

 再看一个例子

#define N 4
shared int x[N][N];
shared int *dp1;
int *dp2;
dp1 = x+MYTHREAD;
dp2 = (int *)dp1+MYTHREAD;

分析：x是以轮转法分配的共享数组，元素为存放在公有空间的整型；dp1指向每个线程的第一个数组元素；dp2相对于dp1的偏移量等于本线程id。

如图：

 看一个较难的例子

shared int x [N];
shared [3] int *dp=&x[5], *dp1;
dp1 = dp + 9;

数据分布竟然是···

 和之前某个例子的区别在于，这里的数组并没有按块划分，但指针却有分块信息。因此从dp指向的那个元素开始，三个三个为一块。

3.4指针信息与相关函数

size_t upc_threadof (shared void *ptr);

参数：ptr是一个私有指针，指向任意共享类型的对象

返回值：与ptr所指向的公有对象相关联的线程的id

size_t upc_phaseof (shared void *ptr);

返回值：phase

size_t upc_addrfieldof (shared void *ptr);

返回值：ptr所指向的公有对象的本地地址（返回值依赖于函数实现）

举个例子，以下程序使用thread 0打印指针的三个域，其中地址域以10进制显示，线程数和phase域以2进制显示

//PrintPointerElements
#include <stdio.h>
#include <upc.h>
#include <upc_relaxed.h>
#define BLOCKING_FACTOR 3
#define SIZE BLOCKING_FACTOR*THREADS
shared [BLOCKING_FACTOR] int buffer [SIZE];
int main(void)
{
　　int i;
　　shared [BLOCKING_FACTOR] int *buffer_ptr;
　　if(MYTHREAD == 0)
　　{
14　　　　 buffer_ptr = buffer + 5;
　　　　　for(i=0; i<SIZE; i++, buffer_ptr++)
　　　　{
　　　　　　printf("&buffer [%d]: ", i);
　　　　　　printf("THREAD: %02d 	 ",
　　　　　　upc_threadof(buffer_ptr));
　　　　　　printf("ADDRESS: %010Xh 	 ",
　　　　　　upc_addrfield(buffer_ptr));
　　　　　　printf("PHASE: %02d
",
　　　　　　upc_phaseof(buffer_ptr));
　　　　}
　　}
return 0;
}

第14行，使得buffer_ptr指向第二个块的最后一个元素buffer[5]，打印结果应该是：线程号=1，phase=2

buffer_ptr = upc_resetphase(buffer_ptr);

函数功能：重置指针的phase，使其指向当前块的首元素。

如果把它放在上面程序的打印之前，phase值会变成0而不是2

这些函数的具体实现：略

3.5更多的例子

// Matrix Squaring
shared double A [THREADS][THREADS], A_Sqr [THREADS][THREADS];
int main(void)
{
    shared double *rows_ptrs [THREADS]; // Points to the rows
    double *cols_ptr; // Points to the local shared columns
    int i, j, k;
    double d;
    //Initialize the pointers
    for(i=0; i < THREADS; i++)
    {
        rows_ptrs [i] = &A [i][0];
    }
// Privatize (local shared to private)
    cols_ptr = (double *)&A [0][MYTHREAD];
// Matrix squaring computation
    for(i=0; i<THREADS; i++) // for each row
        upc_forall(j=0; j<THREADS; j++; j) // each thread
        { // computes one element
            d = 0;
            for(k=0; k<THREADS; k++)
                d += *(rows_ptrs [i]+k) * *(cols_ptr+k);
            A_Sqr [i][j] = d; // write to A_sqr [row i][col j]
}
return 0;
}                                    

上面是一个计算矩阵平方的程序

cols_ptr = (double *)&A [0][MYTHREAD];//&A[0][i]是一个共享的引用，而cols_ptrs是私有指针，需要进行类型转换

这里使用了一个元素类型为指向共享对象的私有指针的数组，用以访问每一行。也可以用单指针，见下面的例子：

// Matrix Squaring (single pointer)
shared double A [THREADS][THREADS], A_Sqr [THREADS][THREADS];
int main(void)
{
    shared double *rows_ptrs;
    double *cols_ptr;
    int i, j, k;
    double d;
// Initialize the pointers
    rows_ptrs = &A [0][0];
    cols_ptr = (double *)&A [0][MYTHREAD];
// for each row
    for(i=0; i<THREADS; i++, rows_ptrs+=THREADS)
        upc_forall(j=0; j<THREADS; j++; j) // for each local
// shared column
        {
            d = 0;
           for(k=0; k<THREADS; k++)
                d += *(rows_ptrs+k) * *(cols_ptr+k);
            A_Sqr [i][j] = d; // write to A_sqr [row i][col j]
        }
return 0;
}            

如果将这个程序的算法封装到一个函数中，则是：

// Matrix Squaring
shared double A [THREADS][THREADS], A_Sqr [THREADS][THREADS];
void mat_squaring(shared double (*dst)[THREADS],
                            shared double (*src）[THREADS])
{
    shared double *rows_ptrs [THREADS];
    double *cols_ptr;
    int i, j, k;
    double d;
// Initialize the pointers
    for(i=0; i<THREADS; i++)
        rows_ptrs[i] = &src[i][0];
// Privatize (local shared to private)
    cols_ptr = (double *)&src[0][MYTHREAD];
// Matrix squaring computation
    for(i=0; i<THREADS; i++) // for each row
        upc_forall(j=0; j<THREADS; j++; j) // each thread
        {
            d = 0;
            for(k=0; k<THREADS; k++)
            d += *(rows_ptrs[i]+k) * *(cols_ptr+k);
           dst[i][j] = d;
        }
}
int main(void)
{
    mat_squaring(A_Sqr, A);
    return 0;
}                

注意：共享的对象全都定义在函数外部，以保证他们不再动态范围内（局部变量出了就被销毁）

3.6总结

略

注：　　

本系列所有内容均来自《UPC: Distributed Shared Memory Programming》。这些文章是为了期中考试临时抱佛脚的结果···若有谬误，敬请指教。

All contents in this article are from <UPC: Distributed Shared Memory Programming>, if this has violated your copyright, contact me immediately at yanwt2013@gmail.com. Thank you.