Runtime Implementation Research Articles

CHARMS: 하드웨어-소프트웨어 통합설계의 최적 분할 탐색을 위한 매핑 휴리스틱

하드웨어-소프트웨어 통합설계에서 다양한 설계제약 조건을 만족하는 임베디드 시스템 개발을 효율적으로 완료하기 위하여 하드웨어와 소프트웨어의 최적분할을 빠른 시간 안에 탐색하는 핵심기술이 필요하다. 본 논문에서는 다양한 하드웨어-소프트웨어 분할에 따른 매핑 조합 중 최적분할에 해당할 수 없는 조합들은 미리 선별하여 탐색대상에서 제외하는 것을 가능하게 하는 맞춤형 매핑 휴리스틱, CHARMS을 제시한다. CHARMS은 응용프로그램의 여러 태스크를 하드웨어 또는 소프트웨어로 매핑하면서, 단위시간 안에 처리되는 태스크의 수인 Parallelism과 일의 양인 Workload 로 Throughput을 예측하고 최적의 분할대상을 선별하는 기존의 휴리스틱보다 향상된 방법으로, 태스크들의 계산 복잡도를 고려하였으며, 설계제약 조건의 중요도를 다양하게 표현할 수 있는 weighted combo-metric을 활용한다. H.263 인코더 설계에서 CHARMS을 이용할 경우 매핑조합의 95.17%를 탐색 대상에서 제외할 수 있었음을 실험을 통하여 보였다. The key challenge in HW/SW co-design is how to choose the appropriate HW/SW partitioning from the vast array of possible options in the mapping set. In this paper we present a unique and efficient approach for addressing this problem known as Customized Heuristic Algorithm for Reducing Mapping Sets(CHARMS). CHARMS uses sensitivity to individual task computational complexity as well the computed weighted values of system performance influencing metrics to streamline the mapping sets and extract the most optimal cases. Using H.263 encoder, we show that CHARMS sieves out 95.17% of the sub-optimal mapping sets, leaving the designer with 4.83% of the best cases to select from for run-time implementation.

Toward Correctness in the Specification and Handling of Non-Functional Attributes of High-Integrity Real-Time Embedded Systems

In high-integrity systems, the focus of the development process is geared to assuring that the assertions made on the system are both correct (i.e., semantically sustainable) and feasible (i.e., true at run time). Some of those assertions take effect in the non-functional domain, that is, in how the system is realized and behaves in time, space and communication during execution; others in the functional domain, and thus concern what outputs the system produces for its inputs. In this paper, we address the problem of achieving correct specification and handling of non-functional attributes, with particular regard to the concurrent structure of the system, the safeness of the interaction protocols engaged in it, and the guarantee that its timing feasibility can be statically verified. Our approach is based on a Model-Driven Engineering methodology, in which correctness can be ensured by construction or verified at a high level of abstraction, while the runtime implementation structure and code are automatically generated. We employ the Ravenscar Computation Model (RCM) and focus, in particular, on aerospace applications, which impose stringent requirements on correctness properties. We discuss an algebraic formalization of our model based on graph theory which we use to prove safe termination in systems compliant with RCM, and show how to use the MAST+ static analyzer to verify the timing aspects. We finally illustrate the results of a prototype tool that was developed for evaluation by major industrial players in the European space industry.

Supervisory Control of Software Execution for Failure Avoidance: Experience from the Gadara Project

We discuss our experience in the Gadara project, whose objective is to control the execution of software to avoid potential failures using discrete-event control techniques. We summarize our accomplishments so far and discuss future challenges. After initial work on safety of workflow scripts via supervisory control techniques, we have focused our efforts on deadlock avoidance in multithreaded C programs that use locking primitives to control access to shared data. We describe how we automatically construct automata models of workflows and Petri net models of concurrent programs. In the case of multithreaded C programs, the resulting models characterize a new class of resource-allocation Petri nets called Gadara nets. These nets enjoy structural properties that facilitate the synthesis of liveness-enforcing control policies that are maximally-permissive. We describe our strategy for run-time implementation of these control policies, especially by a technique known as code instrumentation. It is hoped that the lessons learned so far in the Gadara project will be useful in other application areas and will suggest avenues for future theoretical investigations.

A RUN-TIME EFFICIENT IMPLEMENTATION OF COMPRESSED PATTERN MATCHING AUTOMATA

We present a run-time efficient implementation of compressed pattern matching automata (CPMA) of Kida et al. (2003), where a text is given as a truncation-free collage system [Formula: see text] such that variable sequence [Formula: see text] is encoded by any prefix code. We first build CPMA directly from P and [Formula: see text] in [Formula: see text] time and space, and then convert it into the decoder-embedded CPMA (DECPMA), where |P| is the pattern length and [Formula: see text] is the number of variables defined in [Formula: see text]. The bound [Formula: see text] improves the bound [Formula: see text] achieved by a straightforward application of the method of Kida et al. We experimentally show that a combination of recursive-pairing compression and byte-oriented Huffman coding allows both a high compression ratio and a high speed CPM.

Programming model for a heterogeneous x86 platform

The client computing platform is moving towards a heterogeneous architecture consisting of a combination of cores focused on scalar performance, and a set of throughput-oriented cores. The throughput oriented cores (e.g. a GPU) may be connected over both coherent and non-coherent interconnects, and have different ISAs. This paper describes a programming model for such heterogeneous platforms. We discuss the language constructs, runtime implementation, and the memory model for such a programming environment. We implemented this programming environment in a x86 heterogeneous platform simulator. We ported a number of workloads to our programming environment, and present the performance of our programming environment on these workloads.

RETRIEVAL FROM SHAPE DATABASES USING CHANCE PROBABILITY FUNCTIONS AND FIXED CORRESPONDENCE

Similarity-based retrieval from shape databases typically employs a pairwise shape matcher and one or more indexing techniques. In this paper, we focus specifically on the design of a pairwise matcher for retrieval of 2-D shape contours. In the past, the matchers used for the one-to-many problem of shape retrieval were often designed for the problem of matching an isolated pair of shapes. This approach fails to exploit two characteristics of the one-to-many matching problem that distinguish it from the one-to-one matching problem. First, the output of shape retrieval systems tends to be dominated by matches to relatively similar shapes. In this paper, we demonstrate that by not expending computational resources on unneeded accuracy of matching, both the speed and the accuracy of retrieval can be increased. Second, the shape database is a large statistical sample of the population of shapes. We introduce a probabilistic model for exploiting that statistical knowledge to further increase retrieval accuracy. The model has several benefits: (1) It does not require class labels on the database shapes, thus supporting unlabeled retrieval. (2) It does not require feature independence. (3) It is parameter-free. (4) It has a fast runtime implementation. The probabilistic model is general and thus potentially applicable to other one-to-many matching problems.

Fuzzy configuration of matching runtime implementation strategies

With applications currently growing in complexity and range, increasing numbers of configuration problems are arising in compilers. Already many software systems offer multiple specialized implementation strategies and substrategies, differing in terms of applicability and/or cost, depending on the application context. Configurations then have to be created from the different strategies available in accordance with the application characteristics, the global optimization objective, and potential constraints on the strategies' combinability. In many cases, this results in a combinatorial, i.e., discrete, optimization problem. Proper solutions for automating the configuration while limiting the complexity of the solution search are still being sought. We address here the field of parallel/distributed processing and the configuration of runtime implementation strategies, such as for communication or dynamic load balancing. We present a rule-based approach, integrating fuzzy methodologies for the classification of application characteristics and for gradual selection preference in rules. In this way we exploit available knowledge about the correlation of the problem and solution space, and apply soft computing methods to obtain an approximate, rather than perfect, solution approach, thus helping to limit the configuration complexity. Our approach extends standard fuzzy inference by a multistage organization, and – with proper organization of rules, characteristics and strategies – performs hierarchical fuzzy inference. The approach is demonstrated on concrete configuration examples in parallel compilers.

A Modula-2 implementation of a real-time process abstraction

A process abstraction, in Modula-2, is defined that is aimed at providing the primitives needed in the real-time domain. A concurrency model based upon occam is used but this is enhanced by a comprehensive set of selective wait constructs. All processes have identities and priorities; a run-time implementation kernel provides for preemptive scheduling. Significant parts of this implementation are illustrated and short examples of the use of the process abstraction are given.

Simulated annealing: A review of the thermodynamic approach

Recent results using thermodynamic properties of a simulated annealing problem are reviewed. The results include an efficient schedule, a runtime implementation, a criterion for optimizing ensemble size and information theoretic bounds on the performance of the algorithm.

Ada runtime environment working group—a framework for describing Ada runtime environment

The concept of a runtime environment to support program execution has always been associated with application software - it has only been with programming languages like Ada that the concept has become more apparent and significant to application effectiveness. The purpose of this paper is to explain the basic elements of Ada runtime environments in order to support the presentation of ARTEWG documents, such as the Catalogue of Runtime Implementation Dependencies. Additionally, this paper may be useful as a framework (or common vocabulary) for buyers and builders of Ada runtime environments to discuss details of Ada runtime environments.The paper begins with a historical perspective on runtime environments to show how the technology evolved to the current state exhibited by Ada runtime environments. This leads into a proposed framework for describing runtime environments, including a taxonomy. A concise and consistent set of terms, which are summarized in a glossary, explains different elements of Ada runtime environments.

Implementation implications of Ada generics

Generic program units as defined in Ada pose several important design issues for compilers, both in semantic analysis and in runtime implementation. Chief among these issues are separate compilation of generic bodies and the sharing of code among several instantiations of a generic. An implementation is described that allows separate compilation of generic bodies with full semantic checking and that automatically shares instance bodies based on the characteristics of the actual parameters. A single instance body is generated for each "Instance class". Instance classes are formed by actual parameters with the same representation attributes.

A Topology Reconfiguration Mechanism for Distributed Computer Systems

A topology reconfiguration algorithm for a densely distributed computer structure composed of computers of low cost/performance ratio (e.g. microcomputers) is given. A distributed routing mechanism based on Baran's 'hot potato' heuristic routing algorithm is discussed. This mechanism is applied to a multicomputer system (VTM—Variable Topology Multicomputer system) proposed to be reconfigurable according to the application requirements. An analysis of the algorithm regarding the initialization of a distributed computer system is given and the preliminary system performance results in applying this algorithm are shown. The results of a run time implementation are also compared with those of a traffic-load balancing algorithm which is basically a static fixed routing algorithm, suggested by the authors for densely and uniformly distributed computer systems.

Microcomputers for non-professionals

Microcomputers are beginning to invade the lives of non-professionals. In the near future most people will be using them for entertainment and education both at home and in school. Undoubtedly many of them will soon discover that one of the main attractions of computers is the programming of them. This development is going to occur sooner if the programming environment is appropriate for non-professional users. In order for this to be a positive development from the point of view of professionals the environment must satisfy appropriately defined specifications. This presentation attempts to outline some of the basic desirable features of the non-professional user's environment. It then shows the implications of this specification for one of the essential components of these environments, the definition, translation, and run-time implementation of the preferred programming language. It is postulated that if the environment is defined to “optimally” reflect user's needs and professional's insights it will be accepted by the general public.