毕业设计外文资料翻译-在高性能计算领域中Java的研究、实践和经验

1、毕业设计外文资料翻译学 院： 信息工程学院 专业班级： 网络工程12（1） 学生姓名： 学 号： 指导教师： 外文出处：(外文) Guillermo L. Taboada, Sabela Ramos, Roberto R. Expsito, Juan Touri, Ramn Doallo.Science of Computer Programming, 2013:425-444 附 件：1.外文资料翻译译文； 2.外文原文 指导教师评语：该同学的英文专业资料术语翻译较准确，体现了一定的专业英语水平。翻译材料能够与原文保持一致，能正确表达出原文意思。翻译字、词数满足要求。翻译材料的格式符合要求。

2、该同学较好的完成了外文文献翻译工作。签名： 2015年10月14日第 第 页，共 10 页1外文资料翻译译文在高性能计算领域中Java的研究、实践和经验摘要人们对Java的高性能计算（HPC）这一领域兴趣的不断上升是基于多核集群架构对这种语言的吸引力是独特的。特别是内置的网络和多线程支持，以及Java虚拟机（JVM）不断增加的性能。然而，由于Java对于HPC现有的编程选项分析方面的限制使得它在这一领域的应用正在被推迟，而且随着绩效评估的深入和更新，以及缺乏对目前在这一领域的研究项目的了解，因此为了提高Java的高性能计算，提出解决方案是必要的。本文分析了在Java高性能计算方面的当前状态，是

3、共享和分布式内存编程两者相结合，提出了相关的研究项目，最后，评估当前Java HPC的解决方案以及研究开发两个共享存储环境和两个InfiniBand的多核集群的性能。 主要结论为一下几个方面：（1）在Java HPC方面获取的重大利益已经导致许多项目的发展，尽管平时相当温和，这可能会阻止Java在这一领域的更高的发展;（2）Java可以以本地编译语言实现几乎相同的性能，既为串行应用程序又为并行应用程序，是对HPC编程的替代;（3）在共享内存和低延迟的网络中有效的java通讯方面支持的最新优势是桥接Java和高性能计算本地编译应用程序之间的间隙。因此，Java的在这方面的良好前景吸引了产业界和学

4、术界的注意，这是java在高性能计算方面显著优势导致的。1.简介Java在它发行后不久，就已经成为一种主要的编程语言，尤其是在基于web的分布式环境下，而且对于高性能计算方面来说是一种新兴的选项。对于Java的并行计算方面日益增长的兴趣是基于其吸引人的特征：内置网络和多线程的支持，面向对象，平台无关性，可移植性，类型安全，安全性，拥有广泛的API和开发者广泛的社区，最后，它是计算机专业的学生主要培训语言。此外，性能不再是一个障碍。在过去几年里，Java和本地语言（如C语言和Fortran语言）之间的性能差距已经缩小，由于Java虚拟机（JVM）的即时（JIT）编译器，从Java字节中获取本机性

5、能。然而，java在高性能计算方面使用因缺乏此区域和彻底的和及时的最新的它们的性能评价的现有的编程选项分析而被延迟，以及Java高性能计算在目前的研究项目的不了解，其解决方案需要，以提高其通过率。关于HPC平台，新部署的显著增加安装内核的数量，以满足不断增长的计算能力需求。这目前的趋势是为了强调多核集群的并行性和多线程能力的重要性。 在这种情况下的Java代表的并行应用的开发有吸引力的选择，因为它是一个多线程的语言，并提供了内置的网络支持，主要特点为充分利用混合共享/分布式存储架构。 因此，Java可以使用共享内存（节点内）和分布式存储器（节点间）的通信网络支持的线程。然而，尽管Java和本地

6、语言之间的性能差距通常是较小的程序应用，它可以是特别依赖于低效率的通信库时的并行应用程序，这已阻碍了Java的高性能计算的采用。因此，目前的研究工作集中于提供可扩展的Java通信中间件，特别是在高性能计算系统，如InfiniBand或Myrinet的常用高速网络。本文的其余部分安排如下。第2节分析了Java的高性能计算领域中现有的编程选项。第3节描述了在这一领域的当前研究工作，特别要强调的是，提供可扩展的高性能通信中间件。第4节中提出了，Java的高性能计算方面解决方案，有代表性的综合绩效评价。最后，第5节总结了我们的结束语。2.Java的高性能计算本节分析在Java的高性能计算中现有的编程选

7、项，可分为：（1）共享内存编程; （2）Java的套接字; （3）远程方法调用（RMI）;（4）在Java中的消息传递。这些编程选项允许双方高级别库和Java并行应用程序的开发。2.1.Java共享存储器编程在Java的HPC中有几个选项用于共享内存编程，如使用Java线程，OpenMP类似于实现，和Titanium的实现。有几种选择在Java共享内存编程为高性能计算，例如使用Java线程，OpenMP的类实现和钛。因为Java已经内置了多线程支持，并行编程使用Java的线程是相当延伸，由于其较高的性能，尽管对于高性能计算而言它是相当低级的选项（工作并行化和共享数据访问同步通常难以实现）。此外

8、，该选项仅限于共享存储系统，该系统提供比分布式内存的机器较少的可扩展性。尽管如此，分布式内存编程模型组合，可以克服这个限制。最后，为了减少部分从线程的低层次细节编程的程序员，Java已经从1.5规范纳入了并发性工具，如线程池，任务，阻塞队列和低级别的高性能基元的高级并行编程例如CyclicBarrier。该项目并行的Java（PJ）在这些并发实用程序里已经实行了一些高级抽象，如ParallelRegion（代码并行执行），ParallelTeam（即执行并行区域的线程组）和并行For循环（线程间的工作并行），允许一个简单的线程基地共享内存编程。此外，由于它是用于混合编程共享PJ还实现消息传递范

9、例/分布存储器系统，例如多核簇。主要有两个OpenMP实现java对象，JOMP and JaMP .JOMP由编译器（书面在java中，利用JavaCC工具和运行时库的建立）。编译器将Java源代码与OpenMPjava源代码指令调用运行时库，从而使用java线程执行的并行性。这个整个系统是“纯正”的java（100% java），从而可以运行在任何Java虚拟机。这一实施的发展停在2000，它最近已被用于提供嵌套并行多核HPC系统。然而，跳必须与一些实用程序进行优化，比如并发框架的替换等通过更有效的java.util. concurrent. cyclicbarrier实现的跳障碍。实验评

10、价通过+跳配置混合（java消息的消息传递库线程安全）显示出3倍的性能比同等纯消息传递场景。虽然跳的可扩展性是有限的共享存储系统，它与分布式存储通信库（例如，消息传递库）的组合可以克服这个问题。对象是java OpenMP中Jackal的实现，基于软件的java分布式共享内存（需求侧管理）执行。因此，这个项目是有限的，这样的环境。跳起后跳的方法，但利用并发实用程序，例如任务，因为它是最近的一个项目。OpenMP类似的方法拥有使用Java线程的一些优点，如有一个代码更接近的顺序版本的更高层次的编程模型，并熟悉的使用OpenMP的开发，从而增加了可编程性。然而，当前的OpenMP-like的实现仍

11、是初步的工作和缺乏效率（忙等待JOMP屏障）和可移植性（JAMP）。Titanium 就是一个在加州大学伯克利分校被开发的Java的一个显式并行方言，它提供了全球分区地址空间（PGAS）的编程模型，如UPC和Co-array Fortran，从而实现更高级的可编程性。 除了Java的的特点，增加了Titanium灵活和高效的多维数组和明确的并行SPMD控制模型轻量级同步。此外，据报道它优于Fortran MPI code ，由于其源极到源编译成C代码和使用本地库，诸如数值和高速网络的通信库。然而，Titanium存在几个限制，例如避免使用Java线程中的和缺乏便携性，因为它依赖于Titaniu

12、m和C编译器。2.2.Java网络编程接口网络编程接口是一个用于网络通讯的低级编程接口，它允许发送在应用程序之间的数据流。网络编程接口API被广泛延伸并可以被认为是标准的低级别通信层因为有上几乎每一个网络协议网络编程接口实现。因此，网络编程接口已选择实施Java中的最低级网络通信。然而，Java网络编程接口通常缺乏高效的高速网络支持，因此不得不求助于全网络支持低效的TCP / IP仿真。 TCP / IP仿真的例子IP是在InfiniBand（IPoIB）上的，IPX的Myrinet的低级别库MX（Myrinet eXpress）的顶部，并在SCI中的SCIP里。Java有两个主要的网络编程接

13、口实现，其中包括广泛扩展的Java IO套接字，和Java NIO（New I / O）网络编程接口其中提供可扩展的非阻塞通信支持。然而，这两种实现方式不提供高速网络支持也不提供HPC剪裁。Ibis套机子解决了一部分这些问题，增加Myrinet的支持，并且以Ibis为基础 ，并行分布式计算框架java。然而，在JVM的接口程序库里限制实施它们的性能优势。Java快速套接字（JFS）是Java高性能计算领域的套接字实现。由于JVM IO / NIO的套接字不提供高速网络支持也不提供HPC剪裁，而JFS克服了这些限制： （1）用于增强共享内存（节点内）通信的重载的协议；（2）分别在SCI, Myr

14、inet 和 InfiniBand中的SCI套接字，Sockets-MX和套接字直接协议 (SDP)，支持高性能的本地网络编程接口通信，（3）避免需要原始数据类型数组序列的；（4）减少缓冲和不必要的副本。因此，JFS是能够显著减少JVM套接字通信开销。此外，它的互操作性和用户和应用程序的透明度通过反射允许其在广泛的并行和分布式目标应用直接适用性。2.3.java远程方法调用Java远程方法调用（RMI）协议允许在一个JVM中运行的对象调用另一个JVM中运行一个对象的方法，提供Java的功能相当于远程过程调用（RPC）程序之间的远程通信。这种方法的主要优点是它的简单性，但其主要缺点是由RMI协议

15、中所示的性能差。ProActive是一种并行，多线程和分布式计算集中在电网应用的基于RMI的中间件。ProActive是一个完全可移植的纯粹的Java（100的Java）的中间件，其编程模型是基于元对象协议。随着一组简单的原语的降低，这中间件简化的网格计算应用的编程：在工作站上的集群，分布在局域网（LAN），或者用于电网。此外，主动支持容错，负载平衡，流动性和安全性。然而，使用RMI作为其默认传输层增加显著开销该中间件的操作。RMI 协议的优化已经是几个项目的目标，例如KaRMI, RMIX, Manta ,Ibis RMI , 以及 Opt RMI .然而，使用非标准的API，存在缺乏便携性

16、，与架空减少不充分的缺点，比套接字潜伏期时间更长，限制了其适用性。因此，虽然Java的通信中间件（例如，消息传递库），使用是基于RMI的，当前Java通信库使用套接字是由于其开销较低。在这种情况下，在高性能计算密钥中，由于较低层次的API需要较高的编程来允许更高的吞吐量来实现。2.外文原文Java in the High Performance Computing arena: Research, practice and experiencea b s t r a c tThe rising interest in Java for High Performance Computing (H

17、PC) is based on the appealing features of this language for programming multi-core cluster architectures, particularly the built-in networking and multithreading support, and the continuous increase in Java Virtual Machine (JVM) performance. However, its adoption in this area is being delayed by the

18、 lack of analysis of the existing programming options in Java for HPC and thorough and up-to-date evaluations of their performance, as well as the unawareness on current research projects in this field, whose solutions are needed in order to boost the embracement of Java in HPC.This paper analyzes t

19、he current state of Java for HPC, both for shared and distributed memory programming, presents related research projects, and finally, evaluates the performance of current Java HPC solutions and research developments on two shared memory environments and two InfiniBand multi-core clusters. The main

20、conclusions are that: (1) the significant interest in Java for HPC has led to the development of numerous projects, although usually quite modest, which may have prevented a higher development of Java in this field; (2) Java can achieve almost similar performance to natively compiled languages, both

21、 for sequential and parallel applications, being an alternative for HPC programming; (3) the recent advances in the efficient support of Java communications on shared memory and low-latency networks are bridging the gap between Java and natively compiled applications in HPC. Thus, the good prospects

22、 of Java in this area are attracting the attention of both industry and academia, which can take significant advantage of Java adoption in HPC.1. IntroductionJava has become a leading programming language soon after its release, especially in web-based and distributed computing environments, and it

23、is an emerging option for High Performance Computing (HPC) 1,2. The increasing interest in Java for parallel computing is based on its appealing characteristics: built-in networking and multithreading support,object orientation, platform independence, portability, type safety, security, it has an ex

24、tensive API and a wide community of developers, and finally, it is the main training language for computer science students. Moreover, performance is no longer an obstacle. The performance gap between Java and native languages (e.g., C and Fortran) has been narrowing for the past years, thanks to th

25、e Just-in-Time (JIT) compiler of the Java Virtual Machine (JVM) that obtains native performance from Java bytecode. However, the use of Java in HPC is being delayed by the lack of analysis of the existing programming options in this area and thorough and up-to-date evaluations of their performance,

26、as well as the unawareness on current researchprojects in Java for HPC, whose solutions are needed in order to boost its adoption.Regarding HPC platforms, new deployments are increasing significantly the number of cores installed in order to meet the ever growing computational power demand. This cur

27、rent trend to multi-core clusters underscores the importance of parallelism and multithreading capabilities 3. In this scenario Java represents an attractive choice for the development of parallel applications as it is a multithreaded language and provides built-in networking support, key features f

28、or taking full advantage of hybrid shared/distributed memory architectures. Thus, Java can use threads in shared memory (intra-node) and its networking support for distributed memory (inter-node) communication. Nevertheless, although the performance gap between Java and native languages is usually s

29、mall for sequential applications, it can be particularly high for parallel applications when depending on inefficient communication libraries, which has hindered Java adoption for HPC. Therefore,current research efforts are focused on providing scalable Java communication middleware, especially on h

30、igh-speed networks commonly used in HPC systems, such as InfiniBand or Myrinet.The remainder of this paper is organized as follows. Section 2 analyzes the existing programming options in Java for HPC. Section 3 describes current research efforts in this area, with special emphasis on providing scala

31、ble communication middleware for HPC. A comprehensive performance evaluation of representative solutions in Java for HPC is presented in Section 4. Finally, Section 5 summarizes our concluding remarks.2. Java for High Performance ComputingThis section analyzes the existing programming options in Jav

32、a for HPC, which can be classified into: (1) shared memory programming; (2) Java sockets; (3) Remote Method Invocation (RMI); and (4) message-passing in Java. These programming options allow the development of both high-level libraries and Java parallel applications.2.1. Java shared memory programmi

33、ngThere are several options for shared memory programming in Java for HPC, such as the use of Java threads, OpenMP-like implementations, and Titanium.As Java has built-in multithreading support, the use of Java threads for parallel programming is quite extended due to its high performance, although

34、it is a rather low-level option for HPC (work parallelization and shared data access synchronization are usually hard to implement). Moreover, this option is limited to shared memory systems, which provide less scalability than distributed memory machines. Nevertheless, its combination with distribu

35、ted memory programming models can overcome this restriction. Finally, in order to partially relieve programmers from the low-level details of threads programming, Java has incorporated from the 1.5 specification the concurrency utilities, such as thread pools, tasks, blocking queues, and low-level h

36、igh performance primitives for advanced concurrent programming like CyclicBarrier.The project Parallel Java (PJ) 4 has implemented several high-level abstractions over these concurrency utilities,such as ParallelRegion (code to be executed in parallel), ParallelTeam (group of threads that execute a

37、ParallelRegion)and ParallelForLoop (work parallelization among threads), allowing an easy thread base shared memory programming.Moreover, PJ also implements the message -passing paradigm as it is intended for programming hybrid shared/distributed memory systems such as multi-core clusters.There are

38、two main OpenMP-like implementations in Java, JOMP 5 and JaMP 6. JOMP consists of a compiler (written in Java, and built using the JavaCC tool) and a runtime library. The compiler translates Java source code with OpenMP-like directives to Java source code with calls to the runtime library, which in

39、turn uses Java threads to implement parallelism. The whole system is pure Java (100% Java), and thus can be run on any JVM. Although the development of this implementation stopped in 2000, it has been used recently to provide nested parallelism on multi-core HPC systems 7. Nevertheless, JOMP had to

40、be optimized with some of the utilities of the concurrency framework, such as the replacement of the busy-wait implementation of the JOMP barrier by the more efficient java .util. concurrent CyclicBarrier. The experimental evaluation of the hybrid Java message-passing + JOMP configuration (being the

41、 message-passing library thread-safe) showed up to 3 times higher performance than the equivalent pure message-passing scenario. Although JOMP scalability is limited to shared memory systems, its combination with distributed memory communication libraries (e.g., message-passing libraries) can overco

42、me this issue. JaMP is the Java OpenMP-like implementation for Jackal 8, a software-based Java Distributed Shared Memory (DSM) implementation. Thus, this project is limited to this environment. JaMP has followed the JOMP approach,but taking advantage of the concurrency utilities, such as tasks, as i

43、t is a more recent project.The OpenMP-like approach has several advantages over the use of Java threads, such as the higher-level programming model with a code much closer to the sequential version and the exploitation of the familiarity with OpenMP, thus increasing programmability. However, current

44、 OpenMP-like implementations are still preliminary works and lack efficiency (busywait JOMP barrier) and portability (JaMP).Titanium 9 is an explicitly parallel dialect of Java developed at UC Berkeley which provides the Partitioned Global Address Space (PGAS) programming model, like UPC and Co-arra

45、y Fortran, thus achieving higher programmability. Besides the features of Java, Titanium adds flexible and efficient multi-dimensional arrays and an explicitly parallel SPMD control model with lightweight synchronization. Moreover, it has been reported that it outperforms Fortran MPI code 10, thanks

46、 to its source-to-source compilation to C code and the use of native libraries, such as numerical and high-speed network communication libraries. However, Titanium presents several limitations, such as the avoidance of the use of Java threads and the lack of portability as it relies on Titanium and

47、C compilers.2.2. Java socketsSockets are a low-level programming interface for network communication, which allows sending streams of data between applications. The socket API is widely extended and can be considered the standard low-level communication layer as there are socket implementations on a

48、lmost every network protocol. Thus, sockets have been the choice for implementing in Java the lowest level of network communication. However, Java sockets usually lack efficient high-speed networks support 11, so it has to resort to inefficient TCP/IP emulations for full networking support. Examples

49、 of TCP/IP emulations are IP over InfiniBand (IPoIB), IPoMX on top of the Myrinet low-level library MX (Myrinet eXpress), and SCIP on SCI.Java has two main sockets implementations, the widely extended Java IO sockets, and Java NIO (New I/O) sockets which provide scalable non-blocking communication s

50、upport. However, both implementations do not provide high-speed network support nor HPC tailoring. Ibis sockets partly solve these issues adding Myrinet support and being the base of Ibis 12, a parallel and distributed Java computing framework. However, their implementation on top of the JVM sockets

51、 library limits their performance benefits.Java Fast Sockets (JFS) 11 is our high performance Java socket implementation for HPC. As JVM IO/NIO sockets do not provide high-speed network support nor HPC tailoring, JFS overcomes these constraints by: (1) reimplementing the protocol for boosting shared

52、 memory (intra-node) communication; (2) supporting high performance native sockets communication over SCI Sockets, Sockets-MX, and Socket Direct Protocol (SDP), on SCI, Myrinet and InfiniBand, respectively; (3) avoiding the need of primitive data type array serialization; and (4) reducing buffering and unnecessary copies. Thus, JFS is able to reduce significantly JVM sockets communication overhead. Furthermore, its interoperability and user and application transparency through reflection allow for its immediate applicability on a wide