C遗留代码到Matlab的封装

C2M是一个把C语言遗留代码转换为Matlab中使用的mex封装文件的半自动化系统.该系统主要由C2Mmap和C2Mrule这两个彼此独立但又相关的工具构成.C2Mmap是一个半自动化转换工具,帮助用户在Matlab与C语言之间建立映像;C2Mrule为C函数自动生成相关的封装文件.描述了C2Mmap和C2Mrule,用例说明了封装代码的实际过程.     

Migrating legacy scientific applications towards CORBA‐based client–server architectures

A distributed object is a reusable, self‐contained piece of software that cooperates with other objects on the same machine or across a network in a plug‐and‐play fashion via a well‐defined interface. The Numerical Propulsion System Simulation (NPSS) attempts to provide a collaborative aircraft engine design and simulation environment based on this concept. Many scientific applications in aerodynamics and solid mechanics are written in Fortran. Refitting this legacy Fortran code with distributed objects can increase code reusability. In this paper, we focus on the novel use of a remote variable scheme to help programmers migrate the Fortran code towards a client–server architecture. This scheme gives the client the capability of accessing variables at the server site and makes it easier for programmers to couple component engine code. Through the operator overloading features in C++, remote variables can be used in much the same way as traditional variables. The remote variable scheme adopts the lazy update approach and the prefetch method. Preliminary performance evaluation shows that communication overhead can be greatly reduced. Copyright © 2001 John Wiley & Sons, Ltd.     

A comparative study of Java and C performance in two large‐scale parallel applications

In the 1990s the Message Passing Interface Forum defined MPI bindings for Fortran, C, and C++. With the success of MPI these relatively conservative languages have continued to dominate in the parallel computing community. There are compelling arguments in favour of more modern languages like Java. These include portability, better runtime error checking, modularity, and multi‐threading. But these arguments have not converted many HPC programmers, perhaps due to the scarcity of full‐scale scientific Java codes, and the lack of evidence for performance competitive with C or Fortran. This paper tries to redress this situation by porting two scientific applications to Java. Both of these applications are parallelized using our thread‐safe Java messaging system—MPJ Express. The first application is the Gadget‐2 code, which is a massively parallel structure formation code for cosmological simulations. The second application uses the finite‐domain time‐difference method for simulations in the area of computational electromagnetics. We evaluate and compare the performance of the Java and C versions of these two scientific applications, and demonstrate that the Java codes can achieve performance comparable with legacy applications written in conventional HPC languages. Copyright © 2009 John Wiley & Sons, Ltd.     

Web遗留系统的服务包装器环境设计

Web遗留系统的白盒服务迁移需要侵入原有系统修改代码,因此会产生运行风险。针对该问题,设计并实现一种黑盒包装器环境。通过为遗留系统配置包装器,忽略原系统内部的复杂性,并在不改变系统部署和运行状态的情况下,将遗留的Web应用转化为Web服务。应用结果表明,基于外部包装和规则配置的黑盒方法更具可控性。     

Rapid prototyping frameworks for developing scientific applications: A case study

In this paper, we describe a Python-based framework for the rapid prototyping of scientific applications. A case study was performed using a problem specification developed for Marmot, a project at the Los Alamos National Laboratory aimed at re-factoring standard physics codes into reusable and extensible components. Components were written in Python, ZPL, Fortran, and C++ following the Marmot component design. We evaluate our solution both qualitatively and quantitatively by comparing it to a single-language version written in C. Los Alamos National Laboratory is operated by the University of California for the National Nuclear Security Administration of the United States Department of Energy under contract W-7405-ENG-36, LA-UR-04-4655.     

An experimental approach to the performance penalty of the use of classes in Fortran 95

Fortran 95 is used often for “number crunching”: scientific and engineering applications where performance is important and which operate with large datasets. The language allows the implementation of certain elements of object oriented design, which facilitate code expansion, reuse and maintenance. In this paper we discuss two series of tests to measure how different object oriented design elements of Fortran 95 affect overall performance. The first series of tests consists of several implementations for multiplying two matrices. These tests are focused exclusively on computation time, not considering other parts of the object life cycle such as construction and destruction. The second series consists of computing a finite element matrix for a diffusion term. A more complex environment with different classes is studied. Here, we consider not only the time spent doing useful computations but the integral object life cycle. Results show that object oriented design comes at a cost in all cases. However, given the right compiler, using the right compiler optimization techniques and keeping the amount of objects and method calls low, Fortran 95 designs can benefit from object oriented design techniques with a less than 10% running time increase.     

Panel session: future directions and challenges for Java implementations of numeric-intensive industrial applications

This panel session focuses on utilization of Java for numeric-intensive applications, including the advantages and disadvantages of Java for future use with industrial independent software vendor (ISV)-based finite element methods (FEM) codes. Discussion will address both partial use of Java and/or complete code implementation; activities in this area are already in progress and have been reported by the Java Grande Forum (see http://www.javagrande.org). Some of the issues that will be discussed by the panelists and audience include: performance comparisons of Java, Fortran, C, and C++; primary deficiencies of Java with respect to future development of competitive commercial ISV-based FEM codes; Java standardization bottlenecks; strategies for transitioning to Java from existing large legacy commercial codes; current and future numeric-intensive benchmarks; actions to improve Java floating-point performance. This session is represented by biographical sketches of the panel participants, their individual reflections on the panel theme, and a list of related Internet references.     

Design and implementation of a framework for building distributed smart object systems

A smart object system encompasses the synergy between computationally augmented everyday objects and external applications. This paper presents a software framework for building smart object systems following a declarative programming approach centered around custom written documents that glue the smart objects together. More specifically, in the proposed framework, applications’ requirements and smart objects’ services are objectified through structured documents. A runtime infrastructure provides the spontaneous federation between smart objects and applications through structural type matching of these documents. There are three primary advantages of our approach: firstly, it allows developers to write applications in a generic way without prior knowledge of the smart objects that could be used by the applications. Secondly, smart object management (locating, accessing, etc.) issues are completely handled by the infrastructure; thus application development becomes rapid and simple. Finally, the programming abstraction used in the framework allows extension of functionalities of smart objects and applications very easily. We describe an implemented prototype of our framework and show examples of its use in a real life scenario to illustrate its feasibility.     

VAX／RGL的C语言接口设计

异种语言编写的程序相互调用，是程序设计者为利用已有软件资源而经常涉及的实用技巧，本文基于Ｃ应用程序调用ＶＡＸ／ＲＧＬ图形库绘图的实践，探讨ＶＡＸ／ＶＭＳ环境中Ｃ语言与ＦＯＲＴＲＡＮ语言的接口方法，其关键在于弥补两者采用的ＶＡＸ过程调用参数机构上的差异。然后介绍笔者利用该方法为ＲＧＬ实现的一个Ｃ程序接口软件。     

A wrapping approach for migrating legacy system interactive functionalities to Service Oriented Architectures

Software systems modernisation using Service Oriented Architectures (SOAs) and Web Services represents a valuable option for extending the lifetime of mission-critical legacy systems.This paper presents a black-box modernisation approach for exposing interactive functionalities of legacy systems as Services. The problem of transforming the original user interface of the system into the request/response interface of a SOA is solved by a wrapper that is able to interact with the system on behalf of the user. The wrapper behaviour is defined in the form of Finite State Machines retrievable by black-box reverse engineering of the human-computer interface.The paper describes our wrapper-based migration process and discusses the results of case studies showing process effectiveness and quality of resulting services.     

AGRIF: Adaptive grid refinement in Fortran

Adaptive grid refinement in Fortran (AGRIF) is a Fortran90 package for the integration of adaptive mesh refinement (AMR) features within existing finite difference codes. The package first provides model-independent Fortran90 procedures containing the different operations in an AMR process: time integration of grid hierarchy, clustering, interpolations, updates, etc. The package then creates the Fortran90 model-dependent part of the code based on an entry file written by the user.The basic idea of AGRIF is to make use of Fortran90 pointers to successively address the variables of the different grids of an AMR process. As pointers can be used exactly like other (static) variables in Fortran, most of the original code will remain unchanged.     

基于CORBA消息服务的容错机制研究

CORBA逐渐成为面向对象分布式应用中间件的主要标准，但是CORBA当前没有为容错提供相应的机制，该文在比较各种容错方法的基础上，讨论了一种基于异步消息服务回调和查询模型的容错方法，该方法使服务对象的副本可以并行地处理客户请求，提高了容错的性能，该方法具有对服务对象透明，可以满足用户不同容错要求等特点，文中还给出了这种方法在为遗留应用增加容错能力时的应用实例。     

Nested Parallelization with OpenMP

OpenMP is widely accepted as a de facto standard for shared memory parallel programming in Fortran, C and C++. Nested parallelization has been included in the first OpenMP specification, but it took a few years until the first commercially available compilers supported this optional part of the specification. We employed nested parallelization using OpenMP in three production codes: a C++ code for content-based image retrieval, a C++ code for the computation of critical points in multi-block CFD datasets, and a multi-block Navier-Stokes solver written in Fortran90. In this paper we discuss the opportunities as well as the deficiencies of the nested parallelization support in OpenMP.     

Leveraging legacy codes to distributed problem‐solving environments: a Web services approach

This paper presents WSOWG, a Web‐services‐oriented wrapper generator for automatically wrapping non‐networked legacy codes as Web services for reuse in distributed problem‐solving environments. Using WSOWG, a finite element based computational fluid dynamics (CFD) legacy code has been wrapped as a Web service. A problem‐solving environment for simulating incompressible Navier–Stokes flows has also been implemented. A user makes use of the CFD service through a Web page without knowing the exact implementation of the service. In this way, a user's computing environment can be extended to a heterogeneous distributed computing environment. Performance evaluation shows that the overhead to invoke the CFD Web service generated by WSOWG using Simple Object Access Protocol (SOAP) and CORBA Internet Inter‐ORB Protocol (IIOP) is reasonable compared with that of invoking another CFD Web service manually wrapped from the CFD legacy code using SOAP only. Copyright © 2004 John Wiley & Sons, Ltd.     

Extracting objects from Ada83 programs: A case study

Reengineering legacy systems written in conventional procedural languages to equivelent OO systms makes software more maintainable and reliable.This paper proposes a method for extracting objects from legacy Ada83 systems using module features.Firest.metrics are developed to measure module cohesion.Then,effects on cohesion from changing module components are analyzed and rules about how to extract inheritance relations among objects are given.At the end of this paper,an object-extracting algorithm usin module features is proposed.     

A web-based distributed problem-solving environment for engineering applications

In this study, a prototype of web-based distributed problem-solving environment (W-DPSE) is presented to facilitate computer aided engineering (CAE) technologies. This system provides an effective approach to distributed modeling and simulation, and in addition, to support networked collaboration such that scientists around the world could interactively, visually and experimentally explore their daily design work through the proposed system. The W-DPSE system is constructed as a three-tiered architecture, consisting of three major layers: a web client presentation interface (WCPI), computing solver servers (CSS), and a system management server (SMS). All the components within this architecture are implemented with an object-oriented approach—Java while transparent communication across these three layers is attained through the remote method invocation (RMI) technology. To generalize the applicability of the system so as to accommodate interdisciplinary and diversified applications, a novel and efficient interface is developed for wrapping legacy computation codes, including C and FORTRAN etc., as a Java component. Note that in the interface, the communication mechanisms between Java objects and legacy codes are implemented by way of java native interface (JNI) and Unix inter-process communication (IPC) provided by OS. At last, the applicability of the W-DPSE system is extensively confirmed through the practices of two engineering applications: topology optimization of structures and pollutant transport simulations of coastal waters.     

一种基于后缀树的包装器自动生成方法研究

包装器是一种能够从网页中自动抽取数据并将其转换为结构化数据的软件程序。现有的包装器生成系统多是半自动化的,需要用户具有关于目标页面的先验知识,而且大多只能处理简单结构数据,而不能很好地处理具有嵌套结构的数据。提出了一种基于后缀树的包装器自动生成方法,生成的包装器不仅可以处理简单结构数据,还可以处理嵌套结构数据,具有较低的时间复杂度,有一定的实用价值。     

支持对象间关系的程序设计语言研究

在论述了面向对象技术中对象间的关系作为第一级建模概念的重要性之后,该文设计并实现了显式支持对象间关系的RCPP(relational C++)语言.它提供了显式描述对象间关系特性和语义的机制,利用关系来动态地控制对象行为的作用和传播.它的运行是通过一个转换器把RCPP代码翻译成C++代码,再经C++环境编译后,形成可执行程序而实现的.文章对RCPP语言的模型、语言提供的服务以及具体系统的描述和实现作了深入阐述.     

Experience with Traits in the Xerox Star Workstation

The Xerox Star (8010) is an integrated office workstation. Its software is written in an object-oriented style. Often, different applications will impose slightly different requirements on nominally similar objects which they use. Customization of object definitions for different applications is achieved by attaching modifiers called traits to pre-existing object defintions. This paper describes the approach and recounts our experience with traits.     

A form driven object-oriented reverse engineering methodology

Legacy applications are valuable assets that should be integrated into business systems in succeeding generations. In order to take advantage of these applications, progressive companies seek to improve current operations by reverse engineering. This paper proposes the form driven object-oriented reverse engineering (FORE) methodology by using forms to recover semantics of legacy applications. Forms are exceptionally easy to understand because of the user-oriented nature of the contents of business. This form driven object-oriented reverse engineering methodology consists of five different phases: form usage analysis, form object slicing, object structure modeling, scenario design, and model integration. Knowledge of the form structure and the user's interaction between legacy application is compiled to extract the design semantics. This application demonstrates the practical usability of the FORE methodology by transforming the resulting object models into well-known UML-based models.