多核环境下潮汐分析辅助软件并行绘制技术研究

为方便科研人员使用Baytap-G潮汐分析软件,基于C#.NET程序设计语言设计了一套潮汐分析辅助软件,实现了Baytap-G软件的封装,完成了输入数据格式的自动转换、输出数据的自动提取,以及水位、振幅、相位数据的可视化展示;在介绍C#.NET语言中任务(TASK)并行编程模型的基础上,详细讨论了绘制振幅、相位图任务分解、并行化程序设计考虑及其实现;实验结果表明,合理设计并行程序可以充分利用多核计算机的计算资源,提升程序运行效率,但是过多的任务数、不均匀的工作负载通常会影响并行程序的效率。     

Teapot: a domain-specific language for writing cache coherenceprotocols

In this paper, we describe Teapot, a domain-specific language for writing cache coherence protocols. Cache coherence is of concern when parallel and distributed systems make local replicas of shared data to improve scalability and performance. In both distributed shared memory systems and distributed file systems, a coherence protocol maintains agreement among the replicated copies as the underlying data are modified by programs running on the system. Cache coherence protocols are notoriously difficult to implement, debug, and maintain. Moreover, protocols are not off-the-shelf, reusable components, because their details depend on the requirements of the system under consideration. The complexity of engineering coherence protocols can discourage users from experimenting with new, potentially more efficient protocols. We have designed and implemented Teapot, a domain-specific language that attempts to address this complexity. Teapot's language constructs, such as a state-centric control structure and continuations, are better suited to expressing protocol code than those of a typical systems programming language. Teapot also facilitates automatic verification of protocols, so hard to find protocol bugs, such as deadlocks, can be detected and fixed before encountering them on an actual execution. We describe the design rationale of Teapot, present an empirical evaluation of the language using two case studies, and relate the lessons that we learned in building a domain-specific language for systems programming     

The Distributed Logical Reasoning Language D_Tuili and Its Implementation on Microcomputer Network

D－Tuili,having been implemented on microcompute network,is a distributed logical reasoning programming language.D-Tuili supports parallel programming on the language level,and couples loosely with the distributed database management system,so data in distributed databases can be used in the distributed logic programs.In this paper,we mainly introduce the components of D-Tuili used to design distributed logic programs.Furthermore,the main principles to implement D-Tuili and the main technologies adopted in the implemented system of D-Tuili are described.     

Application execution path analysis for the automatic parallelisation of binary codes in the Intel x86 platform

Traditionally, computer programs have been developed using the sequential programming paradigm. With the advent of parallel computing systems, such as multicore processors and distributed environments, the sequential paradigm became a barrier to the utilisation of the available resources, since the program is restricted to a single processing unit. To address this issue, we propose a transparent automatic parallelisation tool with a binary rewriter. The steps of our approach are: the disassembly of the Intel x86 application, its transformation into an intermediary language; the analysis of this intermediary representation to obtain the flow and dependency graphs; the partitioning of the application into parallel units, using the obtained graphs; and, finally, the reassembly of the application back into the original Intel x86 architecture. By transforming the compiled application software, we aim at obtaining a program which can better explore the parallel resources, with no extra effort required from users or developers.     

基于标记语言的跨平台并行编程框架设计

大量遗留的串行代码需要进行并行化改造,而并行程序复杂性及并行计算平台多样性导致改造成本较高.为此,设计了一种基于标记语言的三层并行编程框架,完成了从串行程序层到并行中间代码层、并行中间代码层到目标并行编程语言程序层的二个转换阶段.采用对串行代码进行语言标记的方法来实现并行中间代码层,该代码层实际是共享存储、分布式存储并行平台编程语言的一种抽象.该框架还实现了一种性能标记方法,可用于并行参数自动寻优.用于雷达数据处理的实验结果表明,实现了对应并行代码的生成,且并行加速比与人工实现的并行代码相当.     

Pardis: a process calculus for parallel and distributed programming in Haskell

Parallel programming and distributed programming involve substantial amounts of boilerplate code for process management and data synchronisation. This leads to increased bug potential and often results in unintended non-deterministic program behaviour. Moreover, algorithmic details are mixed with technical details concerning parallelisation and distribution. Process calculi are formal models for parallel and distributed programming but often leave details open, causing a gap between formal model and implementation. We propose a fully deterministic process calculus for parallel and distributed programming and implement it as a domain-specific language in Haskell to address these problems. We eliminate boilerplate code by abstracting from the exact notion of parallelisation and encapsulating it in the implementation of our process combinators. Furthermore, we achieve correctness guarantees regarding process composition at compile time through Haskell’s type system. Our result can be used as a high-level tool to implement parallel and distributed programs.     

Parallel Array Object I/O Support on Distributed Environments

This paper presents a parallel file object environment to support distributed array store on shared-nothing distributed computing environments. Our environment enables programmers to extend the concept of array distributions from memory levels to file levels. It allows parallel I/O that facilitates the distribution of objects in an application. When objects are read and/or written by multiple applications using different distributions, we present a novel scheme to help programmers to select the best data distribution pattern according to a minimum amount of remote data movements for the store of array objects on distributed file systems. Our selection scheme, to the best of our knowledge, is the first work to attempt to optimize the distribution patterns in the secondary storage for HPF-like programs with inter-application cases. This is especially important for a class of problems called multiple disciplinary optimization (MDO) problems. Our test bed is built on an 8-node DEC Farm connected with an ethernet, FDDI, or ATM switch. Our experimental results with scientific applications show that not only our parallel file system can provide aggregate bandwidths, but also our selection scheme effectively reduces the communication traffic for the system.     

Visual Parallel Programming and Determinancy: A Language Specification,an Analysis Technique,and a Programming Tool

Phred is a visual parallel programming language in which programs can be statically analyzed for deterministic behavior. This paper presents the Phred language, techniques for analyzing the language, and a programming environment which supports Phred programming. There are many methods for specifying synchronization and data sharing in parallel programs. The Phred programmer uses graph constructs for describing parallelism, synchronization, and data sharing. These graphs are formally described in this paper as a graph grammar. The use of graphs in Phred provides an intuitive and visual representation for parallel computations. The inadvertent specification of nondeterministic computations is a common error in parallel programming. Phred addresses the issue of determinacy by visually indicating regions of a program where nondeterminacy may exist. This analysis and its integration into a programming environment is presented here. The Phred programming environment supports the specification, analysis, and execution of Phred programs. The distribution of the programming environment itself over several workstations is also described.     

Practical uses of synchronized clocks in distributed systems

Summary Synchronized clocks are interesting because they can be used to improve performance of a distributed system by reducing communications. Since they have only recently become a reality in distributed systems, their use in distributed algorithms has received relatively little attention. This paper discusses a number of distributed algorithms that make use of synchronized clocks and analyzes how clocks are used in these algorithms Barbara Liskov received her B.A. in mathematics from the University of California at Berkeley and her M.S. and Ph.D. in computer science from Stanford University. She is currently a member of the faculty at the Massachusetts Institute of Technology, where she is NEC Professor of Software Science and Engineering. Her research and teaching interests include programming languages, programming methodology, distributed computing, and parallel computing. Her work on data abstraction led to the development of the CLU programming language and to a programming methodology based on data abstraction and specifications. This work is described in her book Abstraction and Specification in Program Development. Her subsequent research in distributed computing resulted in the Argus programming language, which supports robust distributed programs that survive hardware failures, and the Mercury communications mechanism, which supports efficient communication in a heterogeneous distributed system. At present Prof. Liskov is continuing her work in distributed computing, including development of replication algorithms for implementing highly-available systems. She is working on Harp, a replicated Unix file system for use via NFS, and on the design and implementation of Thor, a highly available object repository for use in a heterogeneous distributed environment. She is a member of ACM, IEEE, the National Academy of Engineering, and is a fellow of the American Academy of Arts and Sciences.This research was supported in part by the Advanced Research Projects Agency of the Department of Defense, monitored by the Office of Naval Research under contract N00014-89-J-1988, and in part by the National Science Foundation under grant CCR-8822158.     

pC++:一个分布式的对象并行语言

介绍了一种比较有代表性的分布式对象并行编码语言－ｐＣ＋＋,它使得用人享存储的编程方法来编写运行于分布式系统的程序。同时,本文描述了其对象并行扩充结构－Ｃｏｌｌｅｃｔｉｏｎ,并同了其对象并行机制,最后讨论了对象并行机制的库函数实现方法。     

A configuration approach to parallel programming

This paper advocates a configuration approach to parallel programming for distributed memory multicomputers, in particular, arrays of transputers. The configuration approach prescribes the rigorous separation of the logical structure of a program from its component parts. In the context of parallel programs, components are processes which communicate by exchanging messages. The configuration defines the instances of these processes which exist in the program and the paths by which they are interconnected.

The approach is demonstrated by a toolset (Tonic) which embodies the configuration paradigm. A separate configuration language is used to describe both the logical structure of the parallel program and the physical structure of the target multicomputer. Different logical to physical mappings can be obtained by applying different physical configurations to the same logical configuration. The toolset has been developed from the Conic system for distributed programming. The use of the toolset is illustrated through its application to the development of a parallel program to compute Mandelbrot sets.     

CC$:一种面向分布式众核平台的并行编程语言

CC$是一种并行编程语言,目的是解决分布式众核并行计算机的编程困难。CC$的编程模型以Multi BSP 模型为基础,将分布式众核并行计算机的硬件架构抽象为3层。数据按照存储的层次和共享范围分为5类,以便在不 同层次上提供共享。LL$还提出一类虚拟指令来解决不同层次之间的数据交换,实现数据访问的逻辑化描述。并行 程序按照3层Multi BSP超步嵌套执行。CC$具有统一的编程风格、内建的多层会共地址空间、数据访问请求的表达 式描述和数据传输编译优化4大特点。测试表明,CC$程序的运行效率高,易学易用,大幅地缩短了开发周期。     

基于网络的分布并行虚拟计算机DPVM的总体设计

基于网络的分布式并行计算技术提供高性能、低成本的计算资源。该文介绍所构造的一个基于网络的分布并行虚拟计算机DPVM。它由虚拟机层、通信层和基本类层组成,以浏览器方式提供用户界面;允许计算机加入系统,提供空闲计算资源,或登录到系统上,获得计算资源;采用Java作为程序设计语言,支持平台无关的分布并行计算。     

Engineering parallel symbolic programs in GPH

We investigate the claim that functional languages offer low-cost parallelism in the context of symbolic programs on modest parallel architectures. In our investigation we present the first comparative study of the construction of large applications in a parallel functional language, in our case in Glasgow Parallel Haskell (GP H). The applications cover a range of application areas, use several parallel programming paradigms, and are measured on two very different parallel architectures. On the applications level the most significant result is that we are able to achieve modest wall-clock speedups (between factors of 2 and 10) over the optimised sequential versions for all but one of the programs. Speedups are obtained even for programs that were not written with the intention of being parallelised. These gains are achieved with a relatively small programmer-effort. One reason for the relative ease of parallelisation is the use of evaluation strategies, a new parallel programming technique that separates the algorithm from the co-ordination of parallel behaviour. On the language level we show that the combination of lazy and parallel evaluation is useful for achieving a high level of abstraction. In particular we can describe top-level parallelism, and also preserve module abstraction by describing parallelism over the data structures provided at the module interface (‘data-oriented parallelism’). Furthermore, we find that the determinism of the language is helpful, as is the largely implicit nature of parallelism in GP H. Copyright © 1999 John Wiley & Sons, Ltd.     

DPOS: A metalanguage and programming environment for parallel processing

This paper describes and illustrates a structured programming metalanguage (DPOS) and graphical programming environment for generating and debugging high-level distributed MIMD parallel programs. DPOS introduces an innovative message-passing model and also recursive graphical definition of parallel process networks. It also provides programming and debugging at the meta language level that is portable across implementation languages. The initial development focus of DPOS is to provide a parallel development system for Lisp-based, symbolic and artificial intelligence programs as part of the MAYFLY parallel processing project. The DPOS environment also generates source code and provides a simulation system for graphical debugging and animation of the programs in graph form.     

A graphical development and debugging environment for parallel programs

To provide high-level graphical support for PVM (Parallel Virtual Machine) based program development, a complex programming environment (GRADE) is being developed. GRADE currently provides tools to construct, execute, debug, monitor and visualize message-passing parallel programs. It offers a high-level graphical programming abstraction mechanism to construct parallel applications by introducing a new graphical language called GRAPNEL. GRADE also provides the programmer with the same graphical user interface during the program design and debugging stages. A distributed debugging engine (DDBG) assists the user in debugging GRAPNEL programs on distributed memory computer architectures. Tape/PVM and PROVE support the performance monitoring and visualization of parallel programs developed in the GRADE environment.     

Extension of scala language by distributed and parallel computing tools with Linda coordination system

The paper describes a new library developed for Linda language implementation for Scala programming language (language support of the component programming software). The library uses client-server architecture and a database for the tuple space representation. It implements the search for similarities and “primitive” and additional operations. The library can be used for distributed and parallel application development.     

浅析基于C语言的文件处理

文件是计算机领域中一个重要的概念,用户的程序和数据都是以文件的形式保存的。文章简要介绍了C语言中与文件操作相关的各种常用函数,利用这些函数,程序员可以很方便地实现文件的创建、打开、关闭、读、写等诸多操作。     

Data race avoidance and replay scheme for developing and debugging parallel programs on distributed shared memory systems

Distributed shared memory (DSM) allows parallel programs to run on distributed computers by simulating a global virtual shared memory, but data racing bugs may easily occur when the threads of a multi-threaded process concurrently access the physically distributed memory. Earlier tools to help programmers locate data racing bugs in non-DSM parallel programs are not easily applied to DSM systems. This study presents the data race avoidance and replay scheme (DRARS) to assist debugging parallel programs on DSM or multi-core systems. DRARS is a novel tool which controls the consistency protocol of the target program, automatically preventing a large class of data racing bugs when the parallel program is subsequently run, obviating much of the need for manual debugging. For data racing bugs that cannot be avoided automatically, DRARS performs a deterministic replay-type function on DSM systems, faithfully reproducing the behavior of the parallel program during run time. Because one class of data racing bugs has already been eliminated, the remaining manual debugging task is greatly simplified. Unlike previous debugging methods, DRARS does not require that the parallel program be written in a specific style or programming language. Moreover, DRARS can be implemented in most consistency protocols. In this paper, DRARS is realized and verified in real experiments using the eager release consistency protocol on a DSM system with various applications.