毕业设计外文资料翻译-Java中的数据并行骨架

1、毕业设计外文资料翻译学 院： 专业班级： 学生姓名： 学 号： 指导教师： 外文出处：(外文) HYPERLINK /s?wd=author%3A%28Herbert%20Kuchen%29%20&tn=SE_baiduxueshu_c1gjeupa&ie=utf-8&sc_f_para=sc_hilight%3Dperson t _blank H Kuchen， HYPERLINK /s?wd=author%3A%28Steffen%20Ernsting%29%20&tn=SE_baiduxueshu_c1gjeupa&ie=utf-8&sc_f_para=sc_hilight%3Dpers

2、on t _blank S Ernsting HYPERLINK /s?wd=journaluri%3A%288a5122ddf169d008%29%20%E3%80%8AProcedia%20Computer%20Science%E3%80%8B&tn=SE_baiduxueshu_c1gjeupa&ie=utf-8&sc_f_para=sc_hilight%3Dpublish&sort=sc_cited o Procedia Computer Science t _blank Procedia Computer Science,2012,9(11):18171826 附 件：1.外文资料翻

3、译译文； 2.外文原文 指导教师评语：基本符合翻译要求。签名： 2015年10月14日1外文资料翻译译文Java中的数据并行骨架摘要在过去的几年中，多核处理器和集群的多核心处理器已经成为有前途的方向，以满足日益增长的需求，计算性能。他们提供可扩展的性能，当然代价是繁琐和复杂的并行编程的成本。由于缺乏高层次的抽象，并行应用程序开发人员必须处理低级别的细节，如协调线程或同步进程。因此，并行编程仍然是一个困难和容易出错的任务。为了程序员屏蔽了这些底层细节，算法的骨架已经被提出。他们封装了典型的并行编程模式，并已经成为一种有效的和可扩展的方法，以简化并行应用程序的开发。在本文中，我们提出我们的骨架库j

4、ava绑定。我们指出java的优缺方面的并行与分布式计算。矩阵乘法基准测试表明，java泛型提供性能较差，因此，java实现无法在性能方面和C+实现竞争。【关键字】算法骨架，并行编程，分布式编程，编程环境，消息传递，java HPC1.简介在过去的几十年中，提高微处理器的性能的策略是推动一个单一的核心，不断增加的时钟速率，并引入复杂的和高功耗的功能，如序执行和分支预测。这导致了一个电源问题，因为这些微处理器所需的功率以更快的速度增长，而不是频率，以及它的性能。为了满足日益增长的计算性能需求，芯片设计人员目前已转向多核处理器。原性能的增加，现在来自增加的核心数量，而不是把频率推到它的极限。一方面

5、，这一战略的结果有高性能的收益，同时，在一个相当恒定的水平，保持电力消耗。另一方面，这一战略也导致了编程的多核心处理器的复杂性上一个显着的增长。今天，并行程序员必须处理的低级别的概念，如多线程和消息传递。由于缺乏高层次的抽象，便携式并行编程可以是一个非常复杂和容易出错的任务。开发商不仅要处理在一定程度上完全不同的计算平台和编程方法，他们还必须处理消息传递的标准如MPI 1 和多线程的概念，如OpenMP 2 或java并发API。因为程序员屏蔽了低层细节，从而降低了复杂度，算法的骨架已经提出 3 。他们封装了典型的并行计算和通信模式，从而隐藏低级别的细节，实现程序员的并行。在本文中，我们提出了

6、基层库JMuesli，java的骨架库4数据并行部分结合，5。为了保证平台的独立性，JMuesli只使用纯java的特点和不通过java本地接口使用任何本地代码（JNI）。因为C / C+编译为机器码，从而来执行，和java虚拟机的比较，通常被称为java提供的表现比C / C+糟糕。但是在时间的有效技术的发展（JIT）编译更快（并发）的垃圾收集器，这个位置至少是可疑的。在本文中，我们想找出java相对于并行与分布式计算对C+的比较中的优势和劣势。本文的其余部分的结构如下：2节讨论相关工作，3部分介绍了C+骨架库、指出其观念和利益。4部分详细描述了如何用java实现的骨架库的概念。此外，与矩阵

7、乘法的一个小程序，我们演示了如何使用JMuesli实现并行应用程序。5节提供实验结果包含测量运行的矩阵乘法基准速度。最后，第6节总结了论文，并给出了一个简短的展望未来的工作。2.相关工作在 3 中，通过引入一组初始的算法骨架：固定度的划分，迭代组合，聚类和任务队列分布，建立了算法的骨架方法。他讨论了一般的实施细节，独立的基本主机语言的功能或必要性，并阐述了骨骼库方法的长处和短处。今天，骨架编程有与编程范式不同的几种方法。其中大部分为命令式编程语言如C、C+和java的MPI上或其他发行库在程序库方面的骨骼。在 6 gonzalez-v艾雷泽，莱顿提供的算法骨架的框架和库的艺术状态概述。他们详细

8、地描述了不同的方法，并总结了最近的研究骨骼编程的主题。根据我们在C+和java类库提供的算法骨架的方法，我们将简要讨论骨骼规划近期类似的方法。另一个值得一提的方法对骨骼编程是PISA的并行编程语言（P3L） 9 ，一个结构化的并行语言为骨架构建代码的协调并行或顺序执行。爱丁堡框架库(eSkel)10是实现算法的骨架第一个库。作为一个结构化的并行编程库,eSkel提供各种骨骼编程结构的C函数MPI。然而,新版本eSkel2解决了更多的概念更大的灵活性。以上提到的Java框架库利用先进的消息传递库MPJE等分布式计算。RMI技术依赖于客户机-服务器模型,因此引入可伸缩性问题时, 可能会有成百上千的

9、节点。3.骨架构建库骨架构建库是一个c+模板库提供各种任务和数据并行骨架。为一种有效的支持许多核心的计算机架构以及集群的库，利用OpenMP MPI1和2。此外,库提供数据并行骨架使用CUDA GPU处理18。因为没有质量CUDA绑定Java,随后我们将只考虑多节点数据并行骨架,多核或许多核心计算机。在库中,两类数据并行骨架可以区分:计算骨架和沟通骨架。计算骨架如地图,邮政,折叠,扫描及其变体以及通信permutePartition等骨架,广播,并收集提供库作为分布式数据结构的成员函数,即类表示分布式数据结构。目前,分布式数据结构数组、矩阵和稀疏矩阵提供的库,即Template class D

10、istributedArray. / one -dimensional Template class DistributedMatrix. / two -dimensional Template class DistributedSparseMatrix. / two -dimensional 清单1:库提供的分布式数据结构类DistributedArray表示一维(固定)多态分布数组,类DistributedMatrix和DistributedSparseMatrix代表二维(固定)多态分布数组(矩阵)。模板参数T表示元素的类型由分布式数据存储结构组成。通过实例化参数T,可以生成任意元素类型

11、。顾名思义,分布式数据结构分布在几个MPI的过程,每一个存储整个数据结构(当地)分区。分布式数据结构提供一个透明和灵活的自动化数据分发机制。但是,因为在某些情况下,它可能是为程序员处理本地索引时,有骨架使用本地索引。此外,一些通信骨架要求程序员注意这个数据分布方案。此外,全局和本地有getter和setter指数。当调用计算骨架,分布式数据结构作为一个整体来处理,例如地图骨架给定用户函数适用于分布式数据结构的每个元素并替换元素。褶皱骨架结合了所有元素的一个分布式数据结构先后通过二进制用户给定的关联函数。当骨架包括进程间通信(折叠,扫描),这是处理在这些骨架,因此对于程序员是完全透明的。程序员只

12、需要知道数据结构作为一个整体,而不是它的分解为本地分区当使用计算骨架。为了避免效率低下,没有其他隐式通信,通过访问远程分区的元素。显式通信、分布式数据结构提供各种通信骨架,例如交换和当地广播分区过程中收集整个数据结构。沟通正确使用骨架,程序员需要知道分布式数据结构分解为本地分区,但不产生的沟通细节。利用这些通信概念显著减少死锁的风险,从而大大减少开发时间。库的一个关键概念是骨骼的参数功能可以部分应用程序。因为骨架定义了一些并行算法结构,由一个适当的细节是固定的参数函数与固定数量的参数,这一特性为骨骼提供更多的表现力:用一个参数函数作为一个部分应用,骨架的细节可以自己依靠额外的参数,在运行时计算

13、。辅助函数用于普通的c+函数转换成部分应用程序。在这个过程中,大量的参数是固定的一些值(函数的参数),返回一个函数参数要求低于原来的函数。4. 实现之前已经提到,JMuesli是一个纯Java实现的c+框架库。当我们想要达到一个比较Java和c+并行和分布式计算(骨骼编程),JMuesli完全依赖于核心Java API。我们不使用JNI，利用操作系统或特定于平台的特性。通过这种方式,我们也保证平台独立性和普遍的可移植性。4.1 Java中并行和分布式计算Java是一种平台独立的编程语言,它可用于任何支持Java的机器或不同的机器上的组合。此外,垃圾收集和隐含的序列化机制帮助程序员编写与Java

14、并发很多可靠的代码。Java提供了内置的支持多线程。大量的易于使用的特性,比如线程池和线程同步在Java简化并行编程作出重大贡献。最后但并非最不重要,与Java开发工具包(JDK)Java标准库提供了一个巨大的有用的工具。设计时考虑到网络语言,Java自然提供了分布式计算技术。一方面有api为分布式对象和远程过程调用RMI、CORBA等另一方面有相当低级的点对点通信技术使用或java。前者将表现不佳,后者是一个非常低级的包,其中包括复杂的套接字编程。MPJ表达(MPJE)19有一个质量实现MPI标准的Java绑定。该系统实现了线程安全的通信通过消息传递在Java中。可插式传输设备之间在运行时,

15、程序员可以选择要么基于Java NIO,这是一个纯Java实现,或基于高性能像Myrinet互联,实现使用Java Native Interface(JNI)。我们使用Java NIO运输设备为基准。4.2 并行化在JMuesli中,并行性指的是在两个步骤。节点间并行,SPMD编程模型由MPI(MPJE)是利用,每个进程只有商店(当地)分区的一个分布式数据结构。在第三节指出,库,分布式数据结构是一个简单的模板类,它提供了计算和通信骨架以及各种辅助方法。为了保持多态性移植Java分布式数据结构时,我们利用Java泛型。public class DistributedArray . public

16、class DistributedMatrix . public class DistributedSparseMatrix . 清单2:JMuesli提供的分布式数据结构一个标识符由MPJE过程,每个过程都可以独立地计算自己的分区,由一个通用的本地存储的数组。因为它不允许直接在Java中创建一个泛型数组,使用Java Reflection API来克服这个限制。清单3展示了通用在Java中创建数组。/ not allowed: T a = new TmySize; / allowed: import java.lang.reflect.Array;public T getGenericArr

17、ay(Class type , int size) return (T) Array.newInstance(type , size); / Call: T a = getGenericArray(Integer.class , mySize); 清单3:通用数组创建Javaintra-node并行,Java线程池用于分发工作负载中参与的线程的数量。使用线程池的最重要的原因为每个任务是创建一个新线程创建和销毁线程。通常骨架程序包含多个框架调用。创建和destoying每个骨骼的数量的线程调用会导致相当大的开销。为了减少这个线程创建和销毁的开销降到最低,一个线程池类ThreadPool介绍了抽象

18、层。这个类只使用单例模式,以确保实现一个线程池实例创建一个JMuesli实例。这个线程池实例之间共享单个程序的所有框架调用。然而,没有对资源的竞争,因为框架调用顺序。只有他们的并行执行完成。清单4展示了mapInPlace骨架,它论证函数适用于分布式数据结构和取代的每个元素对应的元素,函数调用的结果,使用线程池实现。如前所述,一个框架定义了一些并行算法结构的细节由一个适当的参数函数固定的。自Java是基于类和缺乏一流的函数(方法),mapInPlace骨架预计一个函数对象(或通常被称为函子)包含一个方法表示参数的函数。FunctionObj1表示,其参数功能预计一个参数,即相应的分布式数据结构

19、的元素。泛型类型参数T由相应的分布式数据结构类定义。这表明回归和函数的参数类型对象。在4.3节。在清单4中,第7行线程开始通过提交任务线程池。在这里,一个任务是runnable接口的一个实现实例提供的JDK。最后,使用CountDownLatch线程加入。等待()方法块直到每一个线程都有叫倒计时()方法。 public void mapInPlace(FunctionObj1 fo1) int start; CountDownLatch cdl = new CountDownLatch(numThreads); for (int i = 0; i numThreads; i+) start =

20、 i * nLocal / numThreads; threadpool.submit(new MapWorker(start , cdl , elementsPerThread i, fo1); try cdl.await(); catch (InterruptedException e) 清单4:并行mapInPlace骨架与Java线程4.2.1 准备结合MPJ表达和Java线程而mapInPlace框架引入了一个非常简单的并行化没有任何进程间通信,在本节中,我们将演示如何交互intra-node和节点间的并行处理。考虑折叠骨架,它先后结合分布式数据结构的所有元素通过二进制用户给定的关联

21、函数。清单5给出了方案的褶皱骨架。首先,每个进程折叠它在第6行局部元素。类似于mapInPlace骨架在前面的部分中,使用Java线程并行地这样做。接下来,当地的结果必须分布在所有进程在8行。这是通过allgather通信例程。注意,可移植性的原因,我们想保持通信接口可互换,因此我们不利用集体MPJE提供的通信例程。相反,我们已经实施了有效的集体通信例程,专门利用简单的发送和接收方法以及超立方体的沟通。然而,我们没有观察到任何主要的性能缺陷。最后,每个进程折叠所有本地结果一个全局的结果。注意,Java线程用于intra-node并行。public T fold(FunctionObj2 fo2

22、) allgather(localResult , globalResults) result = foldGlobalResults(globalResults); return result; 清单5:交叉骨架的方案4.3 高阶函数和部分应用程序因为骨架函数作为参数,函数本身,他们可以被称为高阶函数。但是,由于没有一流的Java方法,它不可能将它们作为参数传递给其他方法。因此,骨架参数函数必须实现为类,它包含一个方法实际上实现所需的参数函数。函数对象,我们定义了一组接口包含一个抽象方法f(),这必须由程序员和实现可以被称为骨架。抽象类FunctionObj1清单6作为例子。它为骨架参数提供

23、了一个接口函数,期望一个参数。额外的参数要求,JMuesli为骨架的论点提供了接口函数,预计6个参数。清单6中还说明了部分应用程序是如何实现的。一个函数对象,必称为比预期少参数,返回另一个函数对象与相同的功能和给定的参数固定的。为此,每个函数对象提供了一个参考上级函数对象定义的层次结构(第3行)。预计参数的数量。通过这个引用,一个较低的函数对象可以函数调用转发到下一个更高的函数对象。在11到17行方法实现这个过程。它创建并返回下函数对象的一个实例,从而修复一个参数。(低)函数返回对象提供了一个参考当前(更高)函数对象为了能够向前f()调用的方法(14行)。注意参数arg必须宣布最终(只读),这

24、样的匿名内部类可以引用它。为简单起见,方法只能解决一个参数与单个调用。在灵活性这并不是一个缺点,因为相同的结果可以通过解决一个又一个论点。public abstract class FunctionObject1 extends FunctionObj protected FunctionObj2 fo2; protected FunctionObj1(FunctionObj2 fo2) this.fo2 = fo2; public FunctionObj0 curry(final A1 arg) return new FunctionObj0 (this) public T f() retu

25、rn (T)fo1.f(arg); ; public abstract T f(A1 arg1); 清单6:抽象类FunctionObj1 Java中代表了一种高阶函数。4.4 序列化序列化是分布式计算的一个重要概念,对我们的骨骼尤其是库JMuesli。每当一个分布式数据结构与任意数据类型,参数化元素在通过网络传输之前进行序列化。幸运的是,对于一个程序员没有真正努力序列化Java对象。Java提供了所谓的标记接口可序列化的。每一个类实现该接口可以序列化。同样适用于每一个实现了这个接口的类的子类。4.5 案例研究:矩阵乘法矩阵乘法的算法202 nn矩阵假定分成p子矩阵的矩阵大小mm(本地分区),

26、p表示流程的数量和m = n / #流程。最初的子矩阵A和B是周期性转移在水平和垂直方向上,分别。子矩阵的行(列j)是转移我向左(j)职位(向上)。算法的核心是当地子矩阵乘法,后跟一个重复循环移位的行和列的a和B在水平位置(在左边)和垂直方向(向上),分别。#流程步骤之后,每个进程都有一个生成的矩阵的子矩阵计算。清单7给出了大炮的算法的实现使用计算和通信JMuesli提供的骨架。首先,最初的转变是由通信骨架rotateRows rotateCols线21和22。当使用一个函数对象作为参数调用时,这些骨架计算每个子矩阵的职位数量必须通过应用这个函数对象转移到子矩阵的行和列索引,分别。根据否定函数

27、对象,子矩阵的行(列j)是转移我向左(j)职位(向上)。调用时的参数1(29、30行),子矩阵的行我(列j)向左移动一个位置(向上)。结果矩阵C在第24行实例化。接下来,标量积函数对象scproduct(1到9)行部分应用于A和b getter方法getGlobalLocal和getLocalGlobal(第5行)将第一个参数作为全球指数和第二个参数作为一个本地索引,反之亦然。为了解决前两个参数(A和B)的函数对象,使用辅助函数两次。结果是一个函数对象,它有两个参数固定和期望另一个三个参数。当传递给mapIndexInPlace骨架(28行)这个函数对象应用于结果矩阵的每个元素。除了结果矩阵的

28、元素,它是提供这些元素的行和列索引。class Scprod extends FunctionObj5 , DistributedMatrix , Integer , Integer , Integer public Integer f(DistributedMatrix A, DistributedMatrix B, Integer Cij , Integer i, Integer j) Integer sum = Cij; for (int k = 0; k A.getLocalRows(); k+) sum += A.getGlobalLocal(i, k) * B.getLocalGl

29、obal(k, j); return sum; class Negate extends FunctionObj1 public Integer f( Integer arg1) return -arg1; public DistributedMatrix matmult(DistributedMatrix A, DistributedMatrix B) Negate negate = new Negate(); Scprod scproduct = new Scprod(); A.rotateRows(negate); B.rotateCols(negate); DistributedMat

30、rix C = new DistributedMatrix (.); FunctionObj3 fo3 = scproduct.curry(A).curry (B); for (int i = 0; i A.getBlocksInRow(); i+) C.mapIndexInPlace(fo3); A.rotateRows(-1); B.rotateCols(-1); return C; 清单7:使用JMuesli实现算法。5. 实验结果为了弄清楚Java实现JMuesli能够与骨架的c+实现交互,我们实现了上述矩阵乘法基准使用数据并行计算和通信。基准测试了一个多节点、多核集群计算机。计算节点

31、由两个Intel Xeon Westmere X5650处理器共有12核(6芯)。是IcedTea6 JVM使用的JVM。表1:执行时间(以秒为单位)的矩阵乘法基准使用JMuesli(Java)的骨架。矩阵大小nn和n = 8192,np和nt表示每个进程,进程和线程的数量。加速效果(相对于一个核心)括号中给出。nt/np14 16 64149134.10(1.00)10968.30(4.48)2117.75(23.20)488.84(100.51)414543.08(3.38)3505.44(14.02)654.27 (75.10)193.57(253.83)87737.47 (6.35)2

32、016.84(24.36)402.29(122.14)125.88(390.32)125291.54 (9.29)1410.17(34.84)332.42(147.81)101.57(483.74)表2:执行时间(以秒为单位)的矩阵乘法基准使用库(c+)骨架。矩阵大小nn和n = 8192,np和nt表示每个进程,进程和线程的数量。加速效果(相对于一个核心)括号中给出。nt/np14 16 6418633.22(1.00)1975.12(4.37)2117.75(23.20)488.84(100.51)42431.89 (3.55)549.93(15.70)112.49 (76.75)19.4

33、5 (443.87)81189.37 (7.20)272.87(31.64)55.23 (156.31)10.28 (839.81)12861.05 (10.02)182.35(47.34)36.74 (234.98)7.41 (1165.08)表1和图2显示JMuesli(Java)和库(c+)的结果,分别对矩阵乘法的基准。很明显,JMuesli实现使用Java泛型面临一些戏剧性的性能和可伸缩性问题。JMuesli运行时超过了库运行时在6到14倍。过程,两者之间的性能差距越大的实现。因此,加速通过库实现超过通过JMuesli实现大约1.5到2倍。这是利用c+实现。但什么是Java实现的原因表

34、现不佳?为了阐述这个问题,我们实现了一个int变量的分布矩阵。表3显示了JMuesli结果时使用int类的实现DistributedMatrix代替通用版本。与一般的变体相比,int变量提供了更好的性能。运行时下降了大约3至7倍和加速增长了约2倍。与库结果相比,运行时和加速JMuesli和库符合对方,被在同一个数量级。但仍然有一个明显的优势的c+实现库,总计在运行时的两倍。比较通用和int Java泛型实现了一个戏剧性的性能的影响。仔细考虑Java泛型的实现细节,这个性能影响并不奇怪。而c+模板翻译专门为每个泛型类型(代码专门化)表示,对于所有Java泛型转换为一个表示泛型类型(代码共享)。一

35、种类型擦除技术的各个实例化泛型类型到单个字节代码表示通过添加类型检查和类型转换所需的地方。注意这些类型检查然后转换发生在运行时,引入一个调用泛型声明。此外,这种技术可以防止泛型类型被与原始数据类型实例化,这实际上意味着程序员需要使用包装器类。总的来说,所有这些缺点总结Java泛型引入的一个巨大的开销。6. 结论和未来的工作在本文中,我们提出了一个Java实现(JMuesli)的数据并行c+框架库的一部分库。它提供了一个有效的和可伸缩的高级方法来简化便携式并行和分布式编程。由于使用Java,JMuesli是跨各种平台的移植(支持Java)。与JMuesli甚至可以并行开发的应用程序运行在异构网格

36、使用1826表3:执行时间(以秒为单位)的矩阵乘法基准使用int实现JMuesli(Java)的骨架。矩阵大小nn和n = 8192,np和nt表示每个进程,进程和线程的数量。加速效果(相对于一个核心)括号中给出。nt/np14 16 64114024.75(1.00)2999.07(4.68)560.92(25.00)93.24(150.41)43537.14 (3.96)815.19 (17.20)141.50 (99.11)30.91(453.71)81770.30 (7.92)386.07 (36.33)73.74 (190.19)20.62(680.13)121198.43(11.7

37、0)260.17 (53.91)60.54 (231.66)15.83(885.93)种不同的操作系统和硬件的架构。进一步,大型JDK,内置的异常处理、垃圾收集和其他特性提供的Java平台使并行和分布式编程JMuesli很舒服。除了这些优点,使用纯Java的也有一些缺点:实验结果表明,该Java泛型不能在c+模板的性能和可伸缩性的问题上使用。泛型与c+模板,不能与原始数据类型参数化。即使限制原始数据类型,Java在性能实现方面不能与c+竞争。仍然有一个明显的优势在性能和可伸缩性的c+上实现。除了提供更多的数据来使并行骨架提高表达能力水平,未来的工作也可以直接由骨架库提供在Java中实现任务并行

38、。但对于JMuesli的进一步发展,有必要找到一个概念来克服Java泛型提出的性能问题。参考文献1 W. Gropp, W. Lusk, A. Skjellum, 使用MPI -便携式与消息传递并行编程接口,麻省理工学院出版社,1996年。 2 B. Chapman, G. Jost, R. van der Pas, 使用OpenMP -便携式共享内存并行编程,科学和工程计算,麻省理工学院出版社,2008年。 3 M. Cole, 算法骨架:结构化管理并行计算,麻省理工学院出版社,1989年。4 H. Kuchen, A skeleton library, 第八届国际Euro-Par会议程序并

39、行处理,Euro-Par 02 SpringerVerlag,伦敦,英国,2002年,页620 - 620。5 S. Ernsting, H. Kuchen, 数据并行骨架GPU集群和Multi-GPU系统:程序的并行计算国际会议(2011年帕可出现),帕可2011。6 H. Gonzalez-V elez, M. Leyton, 算法框架的调查框架:高级结构化并行编程,软件:实践和经验40(12)(2010)1135 - 1160。7 R. Loogen, Y. Ortega-Mallen, R. Pe na-Mar , 并行函数式编程在伊甸园,函数式编程15(3)杂志(2005)431 -

40、 475。8 C. Herrmann, C. Lengauer, Hdc: 分治法的一种高阶语言、并行处理信件10(2)(2000)239 - 250。9 B. Bacci, M. Danelutto, S. Orlando, S. Pelagatti, M. Vanneschi, P3l: 结构化高级并行语言,和结构性支持,并发性:实践和经验7(3)(1995)225 - 255。10 A. Benoit, B. Cole, S. Gilmore, J. Hillston, Flexible Skeletal Programming with eSkel, 第11届国际Euro-Par研讨会

41、论文集,3648卷,施普林格,2005年,页761 - 770。11y Karasawa,h . Iwasaki多核集群的并行骨架库,:并行处理国际会议上,2009年,页84 - 91。 12 J. Sobral, A. Proenc 使jaskel集群和计算网格骨架,:集群计算,2007年IEEE国际会议上,IEEE,2007年,页365 - 371。13 G. Kiczales, E. Hilsdale, J. Hugunin, M. Kersten, J. Palm, W. Griswold的概述,ECOOP 2001面向对象编程(2001)327 - 2001。14 M. Aldinu

42、cci, M. Danelutto, P. Teti, 先进环境支持结构化并行编程在java中,未来一代的计算机系统19(5)(2003)611 - 626。 15 M. Aldinucci, M. Danelutto, P. Dazzi, Muskel: 一个可扩展的框架环境、可伸缩的计算:实践和经验8(4)。16 D. Caromel, M. Leyton, 微调算法骨架,Euro-Par 2007并行处理(2007)72 - 2007。17 M. Leyton, J. M. Piquer, Skandium: 多核编程与算法的骨架,IEEE 2010 Euro-micro PDP。18

43、Nvidia Corp., Nvidia CUDA C编程指南,Nvidia公司,2010年版。 19 A. Shafi, B. Carpenter, M. Baker, 嵌套并行多核hpc系统使用java, J. Parallel Distrib. Comput. 69年第一版。(6)(2009)532 - 545。20 M. J. Quinn, 并行计算(第二版):理论与实践,麦格劳-希尔,Inc .,纽约美国,1994年。2.外文原文Data parallel skeletons in JavaAbstract In the past years, multi-core processo

44、rs and clusters of multi-core processors have emerged to be promising approaches to meet the growing demand for computing performance. They deliver scalable performance, certainly at the costs of tedious and complex parallel programming. Due to a lack of high-level abstractions, developers of parall

45、el applications have to deal with low-level details such as coordinating threads or synchronizing processes. Thus, parallel programming still remains a difficult and error-prone task. In order to shield the programmer from these lowlevel details, algorithmic skeletons have been proposed. They encaps

46、ulate typical parallel programming patterns and have emerged to be an efficient and scalable approach to simplifying the development of parallel applications. In this paper, we present a Java binding of our skeleton library Muesli. We point out strengths and weaknesses of Java with respect to parall

47、el and distributed computing. A matrix multiplication benchmark demonstrates that the Java Generics deliver poor performance, thus the Java implementation is unable to compete with the C+ implementation in terms of performance. Key words algorithmic skeletons, parallel programming, distributed progr

48、amming, programming environments, message passing, Java for HPC 1. Introduction In the past decades, the strategy for raising the performance of microprocessors was to push a single core to continuously increased clock rates and to introduce complex and highly power consuming features like out-of-or

49、der execution and branch prediction. This led to a power problem because the power required by those microprocessors grew at a faster rate than the frequency and along with it the performance. In order to meet the growing demand of computing performance, chip designers nowadays have turned to multi-

50、core processors. Raw performance increases now come from increasing the number of cores instead of pushing the frequency to its limits. On the one hand, this strategy results in high performance gains while, at the same time, keeping power consumption on a rather constant level. On the other hand, t

51、his strategy also leads to a significant growth in complexity of programming multi-core processors. Today, parallel programmers have to deal with rather low-level concepts like multi-threading and message passing. Due to the lack of high-level abstractions, portable parallel programming can be a ver

52、y complicated and error-prone task. Developers not only have to deal with to some extent completely different computing platforms and programming approaches, they additionally have to deal with message passing standards such as MPI 1 and multithreading concepts like OpenMP 2 or the Java concurrency

53、API. In order to shield the programmer from lowlevel details and thus reducing complexity, algorithmic skeletons have been proposed 3. They encapsulate typical parallel computation and communication patterns, thus hiding low-level details of parallelism from the programmer. In this paper, we present

54、 the skeleton library JMuesli, a Java binding of the data parallel part of our skeleton library Muesli 4, 5. In order to guarantee platform independence, JMuesli makes only use of pure Java features and does not make use of any native code through the Java Native Interface (JNI). Not least because C

55、/C+ compiles to machine code, which can natively be executed, and Java is interpreted by a virtual machine, Java is commonly known for delivering worse performance than C/C+ does. But with the development of efficient techniques like just-in-time (JIT) compilation and faster (and concurrent) garbage

56、 collectors, this position is at least questionable. In this paper, we want to figure out where the strengths and weaknesses of Java are with respect to parallel and distributed computing in comparison to C+. The remainder of this paper is structured as follows: related work is discussed in section

57、2, section 3 introduces the C+ skeleton library Muesli, pointing out its concepts and benefits. Section 4 describes in detail how the concepts of Muesli are implemented in Java. Additionally, with a small program for matrix multiplication, we demonstrate how to implement parallel applications using

58、JMuesli. Section 5 provides experimental results containing measured runtimes and speedups of the matrix multiplication benchmark. Finally, section 6 concludes the paper and gives a brief outlook to future work. 2. Related Work In 3 Cole establishes the algorithmic skeleton approach by introducing a

59、n initial set of algorithmic skeletons: fixed degree divide and conquer, iterative combination, cluster, and task queue. He discusses on general implementation details independent of whether the underlying host language is of functional or imperative nature and elaborates on the strengths and weakne

60、sses of the skeletal approach. Today, there are several approaches to skeleton programming with diverging programming paradigms. Most of which provide skeletons in terms of program libraries for imperative programming languages like C/C+ and Java on top of MPI or other distribution libraries. In 6 G