基于J2EE开源框架的业务组件代码生成器设计

根据J2EE体系结构特点,提出基于模板技术的代码自动生成模型,实现由业务模型描述文件到业务组件的自动生成。从分析J2EE结构入手,确定生成的目标代码,讨论基于模板技术的代码生成器原理和模型,设计模板文件,定义业务模型描述文件的规格,实现了代码生成器。介绍了应用代码生成器的开发模式。     

基于可视化程序设计语言的编译系统

采用面向对象技术设计可视化程序设计语言的编译系统,通过对复杂的可视化图片语法进行分析,将各语法现象以语法单元类的形式进行抽象分类,提出了编译器－编译器的设计策略,给出了从可视化图片设计语言到伪指令代码的解决方法。主要研究在面向对象的编辑环境中如何实现满足硬件设备控制器的稳定、高效的编译系统。通过将可视化程序语言分析器(VPLPG)和小型的类C编译(LCC)器配合使用最终实现可视化程序设计语言的编译系统。     

一种可视化代码生成器的研究及应用

代码生成器充分利用代码重用性,避免的繁琐的重复编码,为快速软件开发提供可靠的解决方案。目前,对于代码生成器的理论研究已经比较完善。但实际工程使用时,存在操作不灵活、使用不方便、功能整合能力不足。本文通过可视化拖、拉、拽等可视化操作,实现页面设计以及关键属性的设置,通过对页面内容解析、转换、以及基于模板代码生成技术,从而快速生成目标代码。实现了将代码生成器整合于应用系统开发平台,方便开发者使用代码生成器进行应用开发。     

基于边缘轮廓特征的实时车型分类

采用面向对象技术设计可视化程序设计语言的编译系统,通过对复杂的可视化图片语法进行分析,将各语法现象以语法单元类的形式进行抽象分类,提出了编译器-编译器的设计策略,给出了从可视化图片设计语言到伪指令代码的解决方法.主要研究在面向对象的编辑环境中如何实现满足硬件设备控制器的稳定、高效的编译系统.通过将可视化程序语言分析器(VPLPG)和小型的类C编译(LCC)器配合使用最终实现可视化程序设计语言的编译系统.     

面向电力系统的可视化页面编辑引擎

针对电力系统前端技术多样性和手工编码方式效率低无法满足需求的快速增长的问题,结合组件化设计思想、可视化和虚拟DOM技术,设计实现了一种面向电力系统的可视化低代码页面编辑引擎.页面构建过程中采用虚拟DOM技术,适用于绝大部分场景页面的高性能渲染,设计了统一数据模型实现异构多源数据的统一接入和多组件数据共享,并提出基于多类型模板的页面编辑思想,满足业务系统多样化集成需求.实践结果表明,该系统能够提供低代码、低门槛的敏捷高效开发,大大地提高了电力系统前端页面的开发效率.     

IA-64过程调用的逆向恢复技术

本文给出了对于IA-64体系结构可执行程序逆向恢复中过程识别和抽象的技术实现方法。采用自动机理论与模板匹配相结合的方法解决IA-64体系结构模板中不确定指令的识别问题。实现了基于数据流分析对过程调用的参数和返回值进行恢复的算法。有效地完成了过程调用的二进制代码向与硬件无关中间语言代码转换的恢复工作。     

基于XML的办公自动化系统可视化生成平台

现有的办公自动化系统在功能需求和实现机制上有较大范围的相似性,在开发过程中,可以应用软件复用技术避免重复劳动,提高开发效率。本论文提出了以可视化定制方式生成目标系统代码的复用方案,并基于谊方案实现了原型系统。为了实现将定制信息到目标代码的转换,论文设计了一种基于XML的用于描述系统页面定制信息的语言OADL,使用JAXP构建描述页面定制信息的OADL模型,应用XSLT技术将OADL描述的定制模型转化为目标代码。     

基于LabVIEW的电子罗盘的可视化实现

本阐述了基于LabVIEW的电子罗盘的可视化实现设计中采用LabVIEW软件，使用其图形编程语言、CIN(代码接口接点)与C语言接口等技术，结合上海朗尚科贸有限公司的LP3300三轴磁阻式双轴倾角补偿电子罗盘，实现其可视化。     

角色建模工具RModeler的设计与实现*

提倡在对象技术中基于角色识别对象及其协调关系,然后展开到类模型、接口模型、实体模型,同时对角色模型的形式化定义和表示方法进行了系统地研究,并在此基础上设计和实现了基于RML的可视化角色建模工具RModeler。RModeler目前完成了代码实现和测试工作,并在实际开发中使用,运行良好。RModeler支持业务过程中采用RML语言的建模,具备将RML模型转换为UML模型的功能,采用业界标准数据描述格式XMI来传递和共享建模信息。     

基于模板的BREW应用可视化界面设计及代码生成

本文提出了一种基于模板技术的BREW应用程序可视化用户界面设计以及代码自动生成的方法,从而改变了手工编写BREW应用的现状。本系统为提供一个可视化的图形界面设计工具,开发人员可以进行所见即所得的界面设计,同时根据用户的设计生成XML文件,接下来利用该XML文件及BREW程序框架模板自动生成应用代码。可视化的界面设计及自动代码生成提高BREW应用的开发效率。     

Compiler support for general-purpose computation on GPUs

In recent years, the GPU (graphics processing unit) has evolved into an extremely powerful and flexible processor, with it now representing an attractive platform for general-purpose computation. Moreover, changes to the design and programmability of GPUs provide the opportunity to perform general-purpose computation on a GPU (GPGPU). Even though many programming languages, software tools, and libraries have been proposed to facilitate GPGPU programming, the unusual and specific programming model of the GPU remains a significant barrier to writing GPGPU programs. In this paper, we introduce a novel compiler-based approach for GPGPU programming. Compiler directives are used to label code fragments that are to be executed on the GPU. Our GPGPU compiler, Guru, converts the labeled code fragments into ISO-compliant C code that contains appropriate OpenGL and Cg APIs. A native C compiler can then be used to compile it into the executable code for GPU. Our compiler is implemented based on the Open64 compiler infrastructure. Preliminary experimental results from selected benchmarks show that our compiler produces significant performance improvements for programs that exhibit a high degree of data parallelism.     

Integrating discrete controller synthesis into a reactive programming language compiler

We define a mixed imperative/declarative programming language: declarative contracts are enforced upon imperatively described behaviors. This paper describes the semantics of the language, making use of the notion of Discrete Controller Synthesis (DCS). We target the application domain of adaptive and reconfigurable systems: our language can serve programming closed-loop adaptation controllers, enabling flexible execution of functionalities w.r.t. changing resource and environment conditions. DCS is integrated into a1 programming language compiler, which facilitates its use by users and programmers, performing executable code generation. The tool is concretely built upon the basis of a reactive programming language compiler, where the nodes describe behaviors that can be modeled in terms of transition systems. Our compiler integrates this with a DCS tool, making it a new environment for formal methods. We define the trace semantics of our contracts language, describe its compilation and establish its correctness, and discuss implementation and examples.     

Efficient run-time dispatching in generic programming with minimal code bloat

Generic programming with C++ templates results in efficient but inflexible code: efficient, because the exact types of inputs to generic functions are known at compile time; inflexible because they must be known at compile time. We show how to achieve run-time polymorphism without compromising performance by instantiating the generic algorithm with a comprehensive set of possible parameter types, and choosing the appropriate instantiation at run time. Applying this approach naïvely can result in excessive template bloat: a large number of template instantiations, many of which are identical at the assembly level. We show practical examples of this approach quickly approaching the limits of the compiler. Consequently, we combine this method of run-time polymorphism for generic programming, with a strategy for reducing the number of necessary template instantiations. We report on using our approach in GIL, Adobe’s open source Generic Image Library. We observed a notable reduction, up to 70% at times, in executable sizes of our test programs. This was the case even with compilers that perform aggressive template hoisting at the compiler level, due to significantly smaller dispatching code. The framework draws from both the generic and generative programming paradigms, using static metaprogramming to fine tune the compilation of a generic library. Our test bed, GIL, is deployed in a real world industrial setting, where code size is often an important factor.     

Supporting OpenMP on Cell

The Cell processor is a heterogeneous multi-core processor with one power processing engine (PPE) core and eight synergistic processing engine (SPE) cores. There is a significant amount of ongoing research in programming models and tools that attempts to make it easy to exploit the computation power of the Cell architecture. In our work, we explore supporting OpenMP on the Cell processor. It is attractive to support OpenMP because programmers can continue using their familiar programming model, and existing code can be re-used. We base our work on IBM’s XL compiler, and developed new components in the XL compiler and a new runtime library. Three major issues are addressed: (1) synchronization support on heterogeneous cores; (2) code generation targeting the different instruction sets; (3) data transfers and implement the OpenMP memory model. We present experimental results for some SPEC OMP 2001 and NAS benchmarks to demonstrate the effectiveness of this approach. A visualization tool based on Paraver is also used to provide some insights into actual thread and synchronization behaviors.     

Issues in Ada compiler technology

The key technical issues involved in producing high-quality Ada compilers and related support tools are discussed. These include real-time issues, programming tools and environments, and code optimization. Also addressed are some important problems that compiler designers face, for example, determining which deficiencies of existing Ada systems can be attributed to the language and which are simply hard-to-implement features or unresolved issued in Ada compiler technology     

An integrated performance analysis tool for SPMD data-parallel programs

A new generation of data parallel languages have been proposed whereby a user specifies how data structures are to be distributed amongst the processor nodes of a distributed-memory machine. Based on this information, the compiler then generates code for the parallel application. Although this approach significantly simplifies the development of the initial version of a parallel application, selection of good data distributions leading to efficient computations is often quite difficult. Therefore, performance debuggers are needed to yield insights into the data distribution effects. On the other hand, most of the existing approaches to performance debugging are very general and thus do not provide the user feedback in terms of the high level programming model or the source code of the parallel application. In this paper, we describe a novel approach to performance debugging of data parallel programs. The design and implementation of a visual performance debugger is described that is specifically targeted to meet the performance debugging requirements of a data-parallel programming model based on user-specified data distributions. The performance debugger is part of an integrated programming environment, called EPPP, which also supports a data parallel compiler and a parallel architecture simulator. Thus development and performance debugging of an application may be done either on the real hardware or by using the simulator. The code for EPPP can be obtained free of cost (contact web address, http://www.crim.ca/apar).     

An integrated runtime and compile-time approach for parallelizingstructured and block structured applications

In compiling applications for distributed memory machines, runtime analysis is required when data to be communicated cannot be determined at compile-time. One such class of applications requiring runtime analysis is block structured codes. These codes employ multiple structured meshes, which may be nested (for multigrid codes) and/or irregularly coupled (called multiblock or irregularly coupled regular mesh problems). In this paper, we present runtime and compile-time analysis for compiling such applications on distributed memory parallel machines in an efficient and machine-independent fashion. We have designed and implemented a runtime library which supports the runtime analysis required. The library is currently implemented on several different systems. We have also developed compiler analysis for determining data access patterns at compile time and inserting calls to the appropriate runtime routines. Our methods can be used by compilers for HPF-like parallel programming languages in compiling codes in which data distribution, loop bounds and/or strides are unknown at compile-time. To demonstrate the efficacy of our approach, we have implemented our compiler analysis in the Fortran 90D/HPF compiler developed at Syracuse University. We have experimented with a multi-bloc Navier-Stokes solver template and a multigrid code. Our experimental results show that our primitives have low runtime communication overheads and the compiler parallelized codes perform within 20% of the codes parallelized by manually inserting calls to the runtime library     

BDL: a specialized language for per-object reactive control

The problem of describing the concurrent behavior of objects in object oriented languages is addressed. The approach taken is to let methods be the behavior units whose synchronization is controlled separate from their specification. Our proposal is a domain-specific language called BDL for expressing constraints on this control and actually implementing its enforcement. We propose a model where each object includes a so-called “execution controller”, programmed in BDL. This separates cleanly the concepts of what the methods do, the object processes, from the circumstances in which they are allowed to do it, the control. The object controller ensures that scheduling constraints between the object's methods are met. Aggregate objects can be controlled in terms of their components. This language has a convenient formal base. Thus, using BDL expressions, behavioral properties of objects or groups of interesting objects can be verified. Our approach allows, for example, deadlock detection or verification of safety properties, while maintaining a reasonable code size for the running controller. A compiler from BDL has been implemented, automatically generating controller code in an Esterel program, i.e., in a reactive programming language. From this code, the Esterel compiler, in turn, generates an automaton on which verifications are done. Then this automaton is translated into a C code to be executed. This multistage process typifies the method for successful use of a domain-specific language. This also allows high level concurrent programming