High-Level Timed Petri Nets as a kernel for executable specifications

One of the goals of the IPTES environment is to provide a highly usable and formally based specification support environment for real-time applications. Therefore the environment is built upon a formal language that provides a sound, and mathematically well-defined kernel for IPTES. The language provides a means for formulating unambiguous specifications that can be formally verified at any stage of the project. The ability of verifying the specifications from the early stages of the project is very important for revealing errors when their correction can be done at a much lower cost compared with the cost of removing the same errors in later phases.The formal kernel of IPTES is a class of high-level Petri nets, called HLTPNs (High-Level Timed Petri Nets), that allow specifications to be executed, simulated, tested and formally proved.HLTPNs come in two forms: the internal form (HLTPN _i ) and the abstract form (HLTPN _a ).HLTPN _i may be viewed as the machine language of the abstract machine underlying the IPTES environment.HLTPN _a provides a higher-level intermediate notation that allows to deal explicitly with aspects related to scheduling of the modeled system.This material is based upon work supported by the esprit project IPTES and by CNR—Progetto Finalizzato Sistemi Informatici e Calcolo Parallelo.     

Do you trust your compiler?

As our society becomes more technologically complex, computer systems are finding an alarming number of uses in safety-critical applications. In many such systems, the software component's reliability is essential to the system's safe operation, so it becomes natural to ask, “How can software be made to behave correctly when executed?” Using program transformations to produce trusted software simplifies verification. Program transformations use proven laws to manipulate programs in a manner analogous to algebraic transformations. The authors sketch how a formal method based on program transformations can be used to construct a verified compiler. Such a compiler has been proved to correctly compile any correct program into assembly language. While the compiler itself may not execute efficiently-after all, you need only use the verified compiler the last time you compile a program-the transformational approach should enable the verified compiler to produce efficient assembly code     

Executable object modeling with statecharts

Statecharts, popular for modeling system behavior in the structural analysis paradigm, are part of a fully executable language set for modeling object-oriented systems. The languages form the core of the emerging Unified Modeling Language. The authors embarked on an effort to develop an integrated set of diagrammatic languages for object modeling, built around statecharts, and to construct a supporting tool that produces a fully executable model and allows automatic code synthesis. The language set includes two constructive modeling languages (languages containing the information needed to execute the model or translate it into executable code)     

Scalarization Using Loop Alignment and Loop Skewing

Array syntax, which is supported in many technical programming languages, adds expressive power by allowing operations on and assignments to whole arrays and array sections. To compile an array assignment statement to a uniprocessor, the language processor must convert the statement into a loop that has the same meaning. This process is called scalarization.Scalarization presents a significant technical problem because an array assignment needs to be implemented as if all inputs are fetched before any outputs are stored. Since a loop intermixes loads and stores, the compiler typically allocates a temporary array to hold the intermediate result. Because these extra temporary arrays can cause performance problems in cache, many techniques have been developed to avoid their use or minimize their size.In this paper, we present a novel application of two compiler strategies—loop alignment and loop skewing—to address this problem. We show that these strategies can achieve the asymptotically minimal memory allocation for stencil computations. Our experiments with loop alignment and loop skewing demonstrate that it is extremely effective in improving memory hierarchy performance of Fortran 90 array code on standard uniprocessors. The result should be applicable to other array languages, such as MATLAB.     

脚本引擎的简单实现

脚本是使用一种特定的描述性语言,依据一定的格式编写的可执行文件,又称作宏或批处理文件.脚本引擎对脚本进行编译和执行.一个脚本引擎通常包括的组件有:符号表、词法分析器、语法分析器、语义检查器、中间代码生成器、代码优化器、代码生成器、虚拟机.通过对一个简单脚本引擎实现过程的分析,可以深入理解各组件的实现方法.将以上组件合起来,就可以执行脚本语言.脚本语言可以通过调用软件的COM来扩展功能,实现软件的定制,也可以实现软件的自动化.     

基于Direct3D的 HLSL高层着色语言实现图形着色效果*

高层着色语言（HighLevel Shader Language,HLSL）是DirectX 9.0最强有力的新组件之一。HLSL将程序员从复杂的Shader指令集中解放出来,着力于更重要的算法而不用再去理会一些硬件细节,从而创建出更多的极具震撼力的渲染效果。论述了HLSL语言基础及编译,并给出了一个实现凹凸映射效果的实例。     

The Syrinx Spoken Language System

This paper describes the Syrinx Spoken Language System (Sylan), an automated dialogue system that is fully integrated with the Syrinx Large Vocabulary Speech Recogniser (Sycon) into the Syrinx SpeechMaster platform. This platform combines speech recognition, natural language processing, dialogue management, telephony and database integration into a robust and flexible Voice User Interface that permits the deployment of natural language dialogue systems in automated call centres. We first describe the architecture of Sylan which, being modular, allows us to build a system whose domain-independent components are reusable from application to application. We then present those components from the point of view of application developers, describing the data structures used by the system and the utilities to build them. The two prototypes that have already been developed using Sylan are briefly presented, and we conclude by drawing the lessons learned along the way and pointing to further research directions.     

Compiling Esterel into Static Discrete-Event Code

Executing concurrent specifications on sequential hardware is important for both simulation of systems that are eventually implemented on concurrent hardware and for those most conveniently described as a set of concurrent processes. As with most forms of simulation, this is easy to do correctly but difficult to do efficiently. Solutions such as preemptive operating systems and discrete-event simulators present significant overhead.In this paper, we present a technique for compiling the concurrent language Esterel into very efficient C code. Our technique minimizes runtime overhead by making most scheduling decisions at compile time and using a very simple linked-list-based event queue at runtime.While these techniques work particularly well for Esterel with its high-level concurrent semantics, the same technique could also be applied to efficiently execute other concurrent specifications.     

Timed Semantics of Message Sequence Charts Based on Timed Automata

Message Sequence Charts (MSCs) provide a way for quick and easily understandable modelling of concurrent systems. Apart from their intuitive semantics easily deduced from their visual syntax, there is a formally defined semantics—Unfortunately, the semantics intuitively assigned to them is sometimes at odds with the formal semantics. In this paper, we will show an alternative approach to the semantics of MSCs, which will enable us to formally model their timed behaviour. Furthermore, we show how some generalizations of ordering events can lead to a language better suited to model real-world requirements. To ease the task of analyzing (High-Level) MSCs, we identify a subclass of those which can be translated into finite (timed of untimed) automata and specify the translation, thus laying the foundation for model checking.     

An analysis of programming language statement frequency in C,C++, and Java source code

Statement frequency data can inform programming language research and provide a solid basis for frequency‐based code analysis. This paper presents an analysis of programming language statement frequency in a large corpus of C, C++, and Java source code, comprised of more than 54 million lines of code. Across these languages, the top four work‐performing statement types are Method/Function Call, Assignment, If, and Return. As compared to studies of Formula Translating System, Common Business Oriented Language and Programming Language One in the 1970s, the main change is the prevalence of method/function calls. Statement use frequency across languages is remarkably similar, and within each individual language, most statement types have a frequency distribution that occupies a small range. A more detailed examination of assignment and looping statement types shows that many assignments simply involve copying of data and that C++/Java use for statements more than C. Copyright © 2014 John Wiley & Sons, Ltd.     

Debugging mixed‐environment programs with Blink

Programmers build large‐scale systems with multiple languages to leverage legacy code and languages best suited to their problems. For instance, the same program may use Java for ease of programming and C to interface with the operating system. These programs pose significant debugging challenges, because programmers need to understand and control code across languages, which often execute in different environments. Unfortunately, traditional multilingual debuggers require a single execution environment. This paper presents a novel composition approach to building portable mixed‐environment debuggers, in which an intermediate agent interposes on language transitions, controlling and reusing single‐environment debuggers. We implement debugger composition in Blink, a debugger for Java, C, and the Jeannie programming language. We show that Blink is (i) simple: it requires modest amounts of new code; (ii) portable: it supports multiple Java virtual machines, C compilers, operating systems, and component debuggers; and (iii) powerful: composition eases debugging, while supporting new mixed‐language expression evaluation and Java native interface bug diagnostics. To demonstrate the generality of interposition, we build prototypes and demonstrate debugger language transitions with C for five of six other languages (Caml, Common Lisp, C#, Perl 5, Python, and Ruby) without modifications to their debuggers. Using real‐world case studies, we show that diagnosing language interface errors require prior single‐environment debuggers to restart execution multiple times, whereas Blink directly diagnoses them with one execution. Copyright © 2014 John Wiley & Sons, Ltd.     

A project for Latin Lexicography: 1. Automatic lemmatization and word-list

A cooperative team of researchers from various Italian universities are collaborating on a project for Latin lexicography. This article describes the linguistic work being done on the Latin language. The various problems — and their solutions — are discussed: allographs, homographs, source material and classification methods, word searching, etc. Nino Marinone taught Latin literature at the University of Turin, was professor of Classical Philology the University of Padua, and now is a permanent member of staff at Turin University where he has the chair of History of the Latin Language. His interests are both classical languages and electronic proceedings in the analysis of Latin. His publications include Berenice da Callimaco a Catullo, Roma: Edizione dell' Ateneo, 1984, 320 pp.; and Index Grammaticus (with V. Lomanto), 3 vols., Hildesheim: Olms — Weidmann, 1990.     

Programming by successive refinement of data abstractions

The Model Programming Language implements a form of data abstraction that has been used in a large programming project, the Demos Operating System. The use of the abstraction mechanism suggests a particular programming style that has evolved over an extensive period of gaining experience with the language. The programming style and Model's approach to data abstraction are both documented here using an example designed to illustrate several of the more important issues. The goal of the paper is to demonstrate a programming style and an approach to data abstraction in a programming language that has proved useful in a significant systems programming application.     

粤-普机器翻译中的词处理

粤语和普通话之间的机器翻译研究应首先考虑由粤语到普通话的书面语翻译,并以单词为突破口。本文重点讨论粤-普书面语机器翻译中的词处理,尤其是方言词处理,包括方言词的识别和方言词的翻译两方面,同时介绍一个已经初步实现了的单词级粤-普机器翻译试验系统。文章最后将给出结论和讨论。     

SOL: A Verifiable Synchronous Language for Reactive Systems

SOL (Secure Operations Language) is a synchronous programming language for implementing reactive systems. The utility of SOL hinges upon the fact that it is a secure language, i.e., most programs in SOL are amenable to fully automated static analysis techniques, such as automatic theorem proving using decision procedures or model checking. Among the unique features of SOL is the ability to express a wide class of enforceable safety and security policies (including the temporal aspects of software component interfaces) in the language itself, thereby opening up the possibility of eliminating runaway computations and malicious code, such as worms and viruses.     

C++在嵌入式系统中的应用研究

本文介绍C++在嵌入式系统中的应用研究,并介绍C++编程语言以及嵌入式系统,分析怎样在嵌入式应用中编写优秀的C++代码,最后简明分析了C++在嵌入式领域的发展前景。     

Java虚拟机的硬件实现研究

Java语言的平台无关性使其正在进入嵌入式系统领域，但Java的性能问题一直是Java应用关注的焦点。JIT技术的运用在一定程度上提高了Java的执行速度，但在对实时性要求高和存储受限的嵌入式等系统的运用中仍然难以满足其要求。文章提出了一种基于硬件的解决方法——Java处理器，它能直接执行Java字节码，从而提高Java的性能，以用于实时及嵌入式系统。