一种基于并行对象的可视化描述

一、前言随着并行计算机应用的深入,人们对并行程序的开发需求不断增加。相对于串行程序而言,并行程序必须考虑同步、互斥、通信等问题,使得并行程序设计难度较大,要求科技研究人员具备编写高效的并行程序的能力,影响了并行机的应用水平。将并行机制引入面向对象语言构成并行面向对象语言已成为当前面向对象技术的一个重要研究方向。利用面向对象的特点来有效实现并行任务的划分、数据的分配、并行进程间的通信和同步,可以降低并行程序设计难度。我们设计的适用于MPP机或集群系统的并行C~++语言(SPC~++),是一个面向对象的并行程序设计语言,充分体现了C~++语言面向对象的程序设计思想和特点,将对象机制和并行机制有机结合起来,大大降低并行程序设计难度。SPC~++利用了C~++语言的对象封装性、函数重载、操作符重载等功能对对象消息传递模型进行抽象,简化消息函数的使用。     

并行面向对象可视化开发环境的研究与实现

提出了基于并行对象的可视化开发环境，该环境充分体现了C 语言面向对象的程序设计思想和特点，将对象机制和并行机制有机结合起来，大大降低并行软件开发难度。片同时借助于可视化开发方法，用可视语法来解决实现的复杂性，使问题求解的难度进一步降低。     

pC++语言中数据划分算法的研究与改进

大规模并行计算是当前该领域研究的一大热点.由于大多数应用问题是数据并行问题,所以人们更多地采用数据并行计算方法来解决实际问题.在数据并行计算中,影响计算速度的一个重要因素是数据的划分状况.该文针对一种较为流行的面向对象数据并行语言——pC++的数据划分算法进行了分析,并指出了其不足之处,同时提出了一种改进的数据划分算法.实验表明,此算法与原有算法相比具有明显的优越性.     

一种CMP结构上的事务存储编程模型设计

多核结构上采用由用户显式制导的并行程序设计模型,使用锁和同步变量来实现同步.事务存储模型能够解决由锁机制带来的一系列问题,提高程序的并发性.介绍了在文中提出的一种基于事务存储模型的多核结构(Transactional-Memory based Chip Multiple-Superscaler,TMCMS)上的并行编程模型,以及针对循环程序的执行模型;以FFT程序为例具体介绍了循环结构的并行化方法和编译转换过程.在初步的实验中,将处理单元从1增加到16个时,在所设计的编程模型的支持下,IPC(Instruction Per Cycle)有接近线性的增长,说明该并行编程模型能够充分发掘程序中潜在的细粒度线程级并行性,同时保持并行程序设计的简单性.     

面向对象有限元并行计算框架PANDA的并行机制

为实现面向对象有限元并行计算框架PANDA对高性能计算的支持,分别从并行计算流程、区域分解、分区信息和通信封装等部分设计PANDA框架在并行计算方面的数据结构.在计算流程中建立区域分解和并行求解器的配合协作方式,进而描述进行区域分割的3种网格剖分方法;对分区边界单元和节点信息的组织以及对并行通信操作的封装使复杂的并行通...     

基于TSpaces的并行计算环境

讨论TSpaces技术的通讯和同步机制,提出一种基于TSpaces的并行计算模型,设计基本并行函数。实验结果表明该并行计算环境的可行性、实用性。     

基于双层类结构的继承异常处理方法

继承异常是并发面向对象语言中的一个很重要而且也是处理起来很困难的问题,它会使同步代码难以重用.为解决此问题,文章提出了一种新的双层类结构模型的方法,来解决继承异常问题,它可对同步代码的复用提供全方位的支持.     

一种并发面向对象同步模型研究

同步是并发语言的一个重要特征,然而在面向对象的框架下,同步约束的存在可能导致不期望的方法的重定义.基于并发面向对象规约语言VDM++(Vienna development method)的两种同步机制,提出一种适合于并发面向对象广谱规约语言的同步模型-卫式路径结构.它不但可以支持一般代码的复用,而且可以全方位地支持对同步代码的复用.     

C^＋＋与面向对象的并行程序设计

C~(++)是目前流行功能较强的面向对象语言。而面向对象的并行程序设计作为一种新的程序设计方法.正需要一种易于接受的语言来支持。本文在Bofland C~(++)V2.0基础上扩充了并行内容。使其能用来编写面向对象的并行程序。     

一种基于移动Agent的分布式并行计算模型

针对传统的分布式并行计算方案所存在的缺点,提出了一种基于移动Agent技术的分布式并行计算模型.在简单介绍移动Agent技术后,给出了基于移动Agent的分布式并行计算模型,并详细叙述了该模型的具体工作过程和实现方案.模型没计完成后,用此模型来解决计算量很大的数值计算问题.首先利用数学工具分析设计出该问题的适合于分布式并行计算的方案,然后依照模型实现实验程序.实验测试表明根据该模型实现的分布式并行计算程序具有较高的加速比和并行效率,并有效地提高了分布式并行计算的稳定性、灵活性、可扩展性和移动性.     

Using B SP and Python to simplify parallel programming

Scientific computing is usually associated with compiled languages for maximum efficiency. However, in a typical application program, only a small part of the code is time-critical and requires the efficiency of a compiled language. It is often advantageous to use interpreted high-level languages for the remaining tasks, adopting a mixed-language approach. This will be demonstrated for Python, an interpreted object-oriented high-level language that is well suited for scientific computing. Particular attention is paid to high-level parallel programming using Python and the BSP model. We explain the basics of BSP and how it differs from other parallel programming tools like MPI. Thereafter we present an application of Python and BSP for solving a partial differential equation from computational science, utilizing high-level design of libraries and mixed-language (Python–C or Python–Fortran) programming.     

MODELS AND TRENDS IN PARALLEL PROGRAMMING

This paper introduces and discusses programming models for parallel processing and recent trends in the area of parallel programming. The paper discusses different parallel programming languages and tools that reflect various parallel computation models. These language differ in expressiveness, portability and performance. Software design and implementation largely varies by using different languages that make the programmer task easy or complex. We describe here the design goals and the main issues of parallel programming models and languages belonging to the following categories: shared-space based languages, message-based languages, parallel toolkits, data-parallel languages, parallel declarative languages, parallel object-oriented languages, and parallel composition-based languages. Tools and languages such as HPF, Linda, Java, OpenMP, PVM, MPI, Parallel C+ +, Sisal, Orca, Mentat, SkieCL, BSP and others are described in some detail. Their main features for design and implementation of high performance applications are discussed. Finally, we outline directions of research and development in the parallel programming area with a special attention to novel approaches based on high-level programming structures that make transparent to the users the architectural details of parallel computing machines.     

simpA: An agent-oriented approach for programming concurrent applications on top of Java

More and more aspects of concurrency and concurrent programming are becoming part of mainstream programming and software engineering, due to several factors such as the widespread availability of multi-core/parallel architectures and Internet-based systems. This leads to the extension of mainstream object-oriented programming languages and platforms-Java is a main example-with libraries providing fine-grained mechanisms and idioms to support concurrent programming, in particular for building efficient programs. Besides this fine-grained support, a main research goal in this context is to devise higher-level, coarse-grained abstractions that would help building concurrent programs, as pure object-oriented abstractions help building large component-based programs. To this end, in this paper we present simpA, a Java-based framework that provides programmers with agent-oriented abstractions on top of the basic OO layer, as a means to organize and structure concurrent applications. We first describe the application programming interface (API) and annotation framework provided to Java programmers for building simpA applications, and then we discuss the main features of the approach from a software engineering point of view, by showing some programming examples. Finally, we define an operational semantics formalizing the main aspects of this programming model.     

From Design Patterns to Parallel Architectural Skeletons

The concept of design patterns has been extensively studied and applied in the context of object-oriented software design. Similar ideas are being explored in other areas of computing as well. Over the past several years, researchers have been experimenting with the feasibility of employing design-patterns related concepts in the parallel computing domain. In the past, several pattern-based systems have been developed with the intention to facilitate faster parallel application development through the use of preimplemented and reusable components that are based on frequently used parallel computing design patterns. However, most of these systems face several serious limitations such as limited flexibility, zero extensibility, and the ad hoc nature of their components. Lack of flexibility in a parallel programming system limits a programmer to using only the high-level components provided by the system. Lack of extensibility here refers to the fact that most of the existing pattern-based parallel programming systems come with a set of prebuilt patterns integrated into the system. However, the system provides no obvious way of increasing the repertoire of patterns when need arises. Also, most of these systems do not offer any generic view of a parallel computing pattern, a fact which may be at the root of several of their shortcomings. This research proposes a generic (i.e., pattern- and application-independent) model for realizing and using parallel design patterns. The term “parallel architectural skeleton” is used to represent the set of generic attributes associated with a pattern. The Parallel Architectural Skeleton Model (PASM) is based on the message-passing paradigm, which makes it suitable for a LAN of workstations and PCs. The model is flexible as it allows the intermixing of high-level patterns with low-level message-passing primitives. An object-oriented and library-based implementation of the model has been completed using C++and MPI, without necessitating any language extension. The generic model and the library-based implementation allow new patterns to be defined and included into the system. The skeleton-library serves as a framework for the systematic, hierarchical development of network-oriented parallel applications.     

What is object-oriented programming?

The meaning of the term `object oriented' is examined in the context of the general-purpose programming language C++. This choice is made partly to introduce C++ and partly because C++ is one of the few languages that supports data abstraction, object-oriented programming, and traditional programming techniques. The support of programming paradigms by languages is discussed and four paradigms are examined: procedural, data hiding, data abstraction, and object-oriented programming. The support of the latter two by C++ is discussed in some detail     

Should ML be Object-Oriented?

At a fundamental level, functional and object-oriented programming languages are all ‘higher-order’, in the sense that they support computing with values that are themselves pieces of program code encapsulated with a local environment. In functional languages these ‘active’ values are functions, while in object-oriented languages they are objects. Both styles of higher-order language claim to provide good support for writing adaptable programs, but functional and object-oriented languages achieve this adaptability in different ways: functional programs rely on parameterisation at the value, type and module level, while object-oriented languages rely primarily on subtyping and implementation inheritance. Here we compare these two approaches, mainly in terms of the features and properties of their type systems, and consider the benefits and disadvantages of unifying (or merging) the two paradigms by adding object-oriented features to ML as a base language. We argue that while some of the simpler aspects of object-oriented languages are compatible with ML, adding a full- edged class-based object system to ML leads to an excessively complex type system and relatively little expressive gain, especially if we aim to preserve that mostly functional style of programming that is a major advantage of ML. Received March 2002 / Accepted in revised form April 2002     

Performance of multi-tasking and synchronization mechanisms in the programming language SR

High-level language primitives for concurrent programming exist in languages such as Ada and Modula-2. However, each of these languages provides only a single means for specifying multitasking and synchronization, essential in the implementation of concurrent systems. The SR language provides several mechanisms for specifying multi-tasking and synchronization, so it can be used to explore the performance of various communication techniques. This paper presents performance results for SR's multi-tasking and synchronization mechanisms and discusses the effects of the generated code, the run-time support and the hardware on these results. These results are compared with those for similar mechanisms in other languages, leading to some general conclusions about the performance of process communication primitives. These performance results can be used by programmers to make design choices that allow systems programs written in high-level languages to meet real-time performance specifications.     

基于Julia语言的并行计算方法初探

Julia语言是一种在MIT许可证下免费的开发中脚本语言(beta 0.2.0),目标是降低并行程序的编程难度.基于Julia现有语法机制,逐步增强Julia语法特性,结合公交线路的平均走行时间统计案例,研究Julia并行编程框架和程序逐步精化的方法.Julia程序支持本地多核心/多CPU并行计算.为充分发挥实验平台的计算潜能,尝试了提高Julia程序计算性能的策略.对案例程序的实验分析表明,Julia并行程序在管理计算核心方面耗费了一定的工作时间,但随着问题规模的增大,其影响可逐渐忽略,从而可获得接近线性的加速比.     

JavaLog: a framework-based integration of Java and Prolog for agent-oriented programming

Intelligent agent development has imposed new challenges on the necessary language support. Object-oriented languages have been proposed as an appropriate tool, although logic-oriented languages are more adequate for managing mental attitudes. Multi-paradigm languages supporting encapsulation of actions, hiding of private knowledge and flexible manipulation of knowledge are, certainly, a good alternative for programming agents. However, a unique language to support flexible and efficient development of multi-agent systems confronts with the tradeoffs imposed by expressive power, efficiency and support technology. An alternative to conciliate these tradeoffs is not to think about a single language but an incrementally compatible family of agent-oriented multi-paradigm languages. In this work we present an approach based on object-oriented framework technology for integrating object and logic paradigms in such a way that new language features can be incrementally added to the core language. This core language is based on logic modules integrated as object abstractions in the object paradigm. JavaLog is a materialization of this framework integrating Java and Prolog. This core was extended to provide multi-threading support, mobility and temporal-logic operators to Prolog. MoviLog, the mobile part of the family provides a novel mobility mechanism, reactive mobility by failure, which enables virtual Prolog databases distributed across Web sites.     

Object programming for CAD

The use of object-oriented programming to simplify the design and implementation of CAD systems is discussed. The three features common to all languages that support object-oriented programming data abstraction, inheritance, and runtime-function determination are examined. Examples are given to illustrate the advantages of object-oriented methods. How to build an embryonic CAD framework and when to use an object-oriented language are addressed. Object-oriented databases are defined