Client ahead‐of‐time compiler for embedded Java platforms

Many embedded Java platforms execute two types of Java classes: those installed statically on the client device and those downloaded dynamically from service providers at run time. For achieving higher performance, the static Java classes can be compiled into machine code by ahead‐of‐time compiler (AOTC) in the server, and the translated machine code can be installed on the client device. Unfortunately, AOTC cannot be applicable to the dynamically downloaded classes. This paper proposes client‐AOTC (c‐AOTC), which performs AOTC on the client device using the just‐in‐time compiler (JITC) module installed on the device, obviating the JITC overhead and complementing the server‐AOTC. The machine code of a method translated by JITC is cached on a persistent memory of the device, and when the method is invoked again in a later run of the program, the machine code is loaded and executed directly without any translation overhead. A major issue in c‐AOTC is relocation because some of the address constants embedded in the cached machine code are not correct when the machine code is loaded and used in a different run; those addresses should be corrected before they are used. Constant pool resolution and inlining complicate the relocation problem, and we propose our solutions. The persistent memory overhead for saving the relocation information is also an issue, and we propose a technique to encode the relocation information and compress the machine code efficiently. We developed a c‐AOTC on Sun's CDC VM reference implementation, and our evaluation results indicate that c‐AOTC can improve the performance significantly, as much as an average of 12% for EEMBC and 4% for SpecJVM98, with a persistent memory overhead of 1% on average. Copyright © 2008 John Wiley & Sons, Ltd.     

Flow‐sensitive runtime estimation: an enhanced hot spot detection heuristics for embedded Java just‐in‐time compilers

Java just‐in‐time compilers often compile only hot methods because the compilation overhead is a part of the running time. This requires precise and efficient hot spot detection, which includes distinguishing hot methods from cold ones, detecting them as early as possible, and paying a small detection overhead. Hot spot detection is especially important in embedded applications because they show more of a start‐up phase behavior of a regular application where methods are not executed heavily, so the hot methods are not definite. Because a long‐running method is likely to be a hot method, we can detect a hot method by measuring its running time during interpretation. However, precise measurement of the running time during execution is too expensive, especially in embedded systems, so many counter‐based heuristics have been proposed to estimate it such as Oracle's HotSpot heuristic. One problem is that although the overhead of these heuristics is low, they do not estimate the running time precisely, which may lead to imprecise hot spot detection.This paper proposes a new hot spot detection heuristic called flow‐sensitive runtime estimation, which can estimate the running time more precisely than others with a relatively low overhead. It only counts important bytecode instructions dynamically, but it can obtain the precise count of all interpreted bytecode instructions with a simple arithmetic calculation. We also propose a static analysis technique to predict those hot methods which spends a huge execution time once invoked, so as to compile them at their first invocation. Our experimental results show that these techniques can improve the performance by as much as an average of 7.4% compared with the HotSpot heuristic for the benchmarks when they run once, which is often regarded as showing the start‐up phase behavior. Even for real embedded Java applications such as the digital TV Java Xlet applications, our techniques can improve the user response time by an average of 7.1%. Copyright © 2015 John Wiley & Sons, Ltd.     

Lightweight monitors for the Java virtual machine

Java supports the monitor construct for language‐level synchronization in the context of multi‐threading. This paper introduces the lightweight monitor, an efficient user‐level monitor implementation. The lightweight monitor is useful for single‐threaded Java programs as well as for multi‐threaded Java programs with little lock contention. A 32‐bit lock is embedded in each object for efficient lock access while other monitor data structures are managed using a hash table. We highly optimized the lock manipulation code, which is translated and inlined by a just‐in‐time (JIT) compiler. In the most probable cases, only nine SPARC instructions are spent for lock acquisition and five instructions are spent for lock release. Our experimental results indicate that the lightweight monitor is faster than the monitor implementation in the SUN JDK 1.2 RC1 by up to 21 times in the absence of lock contention and by up to seven times in the presence of lock contention. Copyright © 2004 John Wiley & Sons, Ltd.     

The moderating role of just‐in‐time on sociotechnical practices' effect over quality and workers' health

Sociotechnical (ST) theory emphasizes the notion that the design and performance of new systems can be improved, and can only work satisfactorily within an organization if the social and the technical aspects are brought together and treated as interdependent aspects of a work system. The implementation of lean manufacturing (LM) principles and practices has become popular, despite increasing demand on the current and emerging workforce to achieve higher levels of quality and flexibility with lower costs. Exploratory studies that investigate how LM practices influence the effect of ST practices on performance are still scarce, and a holistic view of such a relationship is needed. In this context, this study aims at verifying the moderating effect of just‐in‐time (JIT) practices on the relationship between ST practices and the performance of quality and workers' health. We carried out a survey with 144 different companies from Southern Brazil that are undergoing a lean implementation. Results indicate that ST practices have a positive significant relationship with such performance, and the concurrent adoption of JIT does not undermine quality and workers' health.     

Enhancing OSGi with real‐time Java support

OSGi was designed with embedded systems in mind, its current support is insufficient for coping with one main characteristic of many embedded systems: real‐time performance. This article analyzes different key issues in providing OSGi with real‐time Java performance covering motivational issues, and different integration ways and challenges stemming from the integration. It also contributes a general framework for introducing real‐time performance in OSGi, which is called the real‐time for OSGi framework. The framework uses real‐time Java virtual machines and the real‐time specification for Java. The adoption of this framework allows cyber‐physical systems to experience real‐time Java performance in their applications. The framework introduces several integration levels for OSGi and real‐time specification for Java, and specific real‐time OSGi services. An empirical implementation was carried out using standard software, which was extended with the new defined services. Copyright © 2012 John Wiley & Sons, Ltd.     

在嵌入式Java芯片中使用即时编译技术

Java虚拟机具有面向堆栈与面向对象的特点,不利于硬件有效支持字节码的直接执行,传统JIT也不适应嵌入式系统的应用环境,介绍了在自行设计的嵌入式Java芯片中使用JIT的技术途径,通过对Java虚拟机堆栈和复杂指令的支持,密切配合JIT软件,较好地解决了Java芯片设计中的问题。测试结果表明,相对于目前前界最好的picoJava-Ⅱ内核而言内核而言,JC401的编译后代码性能提高了1．2至1．9倍,在硬件复杂度、执行速度、内存开销等方面都有较大程度的改善,适合于嵌入式应用。     

EJVM: an economic Java run‐time environment for embedded devices

As network‐enabled embedded devices and Java grow in their popularity, embedded system researchers start seeking ways to make these devices Java‐enabled. However, it is a challenge to apply Java technology to these devices due to their shortage of resources. In this paper, we propose EJVM (Economic Java Virtual Machine), an economic way to run Java programs on network‐enabled and resource‐limited embedded devices. Espousing the architecture proposed by distributed JVM, we store all Java codes on the server to reduce the storage needs of the client devices. In addition, we use two novel techniques to reduce the client‐side memory footprints: server‐side class representation conversion and on‐demand bytecode loading. Finally, we maintain client‐side caches and provide performance evaluation on different caching policies. We implement EJVM by modifying a freely available JVM implementation, Kaffe. From the experiment results, we show that EJVM can reduce Java heap requirements by about 20–50% and achieve 90% of the original performance. Copyright © 2001 John Wiley & Sons, Ltd.     

Worst‐case execution time analysis for a Java processor

In this paper, we propose a solution for a worst‐case execution time (WCET) analyzable Java system: a combination of a time‐predictable Java processor and a tool that performs WCET analysis at Java bytecode level. We present a Java processor, called JOP, designed for time‐predictable execution of real‐time tasks. The execution time of bytecodes, the instructions of the Java virtual machine, is known to cycle accuracy for JOP. Therefore, JOP simplifies the low‐level WCET analysis. A method cache, which fills whole Java methods into the cache, simplifies cache analysis. The WCET analysis tool is based on integer linear programming. The tool performs the low‐level analysis at the bytecode level and integrates the method cache analysis. An integrated data‐flow analysis performs receiver‐type analysis for dynamic method dispatches and loop‐bound analysis. Furthermore, a model checking approach to WCET analysis is presented where the method cache can be exactly simulated. The combination of the time‐predictable Java processor and the WCET analysis tool is evaluated with standard WCET benchmarks and three real‐time applications. The WCET friendly architecture of JOP and the integrated method cache analysis yield tight WCET bounds. Comparing the exact, but expensive, model checking‐based analysis of the method cache with the static approach demonstrates that the static approximation of the method cache is sufficiently tight for practical purposes. Copyright © 2010 John Wiley & Sons, Ltd.     

Composing and scheduling service‐oriented applications in time‐triggered distributed real‐time Java environments

During the last decade, the number of distributed application domains with temporal requirements has significantly augmented, arising the necessity of exploring new concepts and paradigms that allow, on the one hand, the development of dynamic and flexible distributed applications and, on the other hand, the reusability of code. Service‐oriented paradigms have been successfully applied to distributed environments, increasing their flexibility and allowing the reusability of their components. Besides, distributed real‐time Java technologies have shown to be a good candidate to deploy real‐time distributed applications. This paper presents a model for service‐oriented applications on a time‐triggered distributed real‐time Java environment, focusing on the definition of the temporal model of an application and its schedulability, applying and evaluating this model in real‐time service‐oriented composition algorithms. Copyright © 2012 John Wiley & Sons, Ltd.     

FIRE/J—optimizing regular expression searches with generative programming

Regular expressions are a powerful tool for analyzing and manipulating text. Their theoretical background lies within automata theory and formal languages. The FIRE/J (fast implementation of regular expressions for Java) regular expression library is designed to provide maximum execution speed while remaining portable across different machine architectures. To achieve that, FIRE/J transforms each regular expression into a tailor‐made class file, which is compiled directly to Java virtual machine (JVM) bytecodes. The library is compatible with the POSIX standard. Copyright © 2007 John Wiley & Sons, Ltd.     

Exception handling in the development of dependable component‐based systems

Exception handling is a structuring technique that facilitates the design of software systems by encapsulating the process of error recovery. In this paper, we present a systematic approach for incorporating exceptional behaviour in the development of component‐based software. The premise of our approach is that components alone do not provide the appropriate means to deal with exceptional behaviour in an effective manner, hence the need to consider the notion of collaborations for capturing the interactive behaviour between components when error recovery involves more than one component. The feasibility of the approach is demonstrated in terms of the mining control system case study. Copyright © 2004 John Wiley & Sons, Ltd.     

Scheduling time‐critical requests for multiple data objects in on‐demand broadcast

On‐demand broadcast is an effective data dissemination approach in mobile computing environments. Most of the recent studies on on‐demand data broadcast assume that clients request only a single‐data‐object at a time. This assumption may not be practical for the increasingly sophisticated mobile applications. In this paper, we investigate the scheduling problem of time‐critical requests for multiple data objects in on‐demand broadcast environments and observe that existing scheduling algorithms designed for single‐data‐object requests perform unsatisfactorily in this new setting. Based on our analysis, we propose new algorithms to improve the system performance. Copyright © 2010 John Wiley & Sons, Ltd.     

Device level communication libraries for high‐performance computing in Java

Since its release, the Java programming language has attracted considerable attention from the high‐performance computing (HPC) community because of its portability, high programming productivity, and built‐in multithreading and networking support. As a consequence, several initiatives have been taken to develop a high‐performance Java message‐passing library to program distributed memory architectures, such as clusters. The performance of Java message‐passing applications relies heavily on the communications performance. Thus, the design and implementation of low‐level communication devices that support message‐passing libraries is an important research issue in Java for HPC. MPJ Express is our Java message‐passing implementation for developing high‐performance parallel Java applications. Its public release currently contains three communication devices: the first one is built using the Java New Input/Output (NIO) package for the TCP/IP; the second one is specifically designed for the Myrinet Express library on Myrinet; and the third one supports thread‐based shared memory communications. Although these devices have been successfully deployed in many production environments, previous performance evaluations of MPJ Express suggest that the buffering layer, tightly coupled with these devices, incurs a certain degree of copying overhead, which represents one of the main performance penalties. This paper presents a more efficient Java message‐passing communications device, based on Java Input/Output sockets, that avoids this buffering overhead. Moreover, this device implements several strategies, both in the communication protocol and in the HPC hardware support, which optimizes Java message‐passing communications. In order to evaluate its benefits, this paper analyzes the performance of this device comparatively with other Java and native message‐passing libraries on various high‐speed networks, such as Gigabit Ethernet, Scalable Coherent Interface, Myrinet, and InfiniBand, as well as on a shared memory multicore scenario. The reported communication overhead reduction encourages the upcoming incorporation of this device in MPJ Express ( http://mpj‐express.org ). Copyright © 2011 John Wiley & Sons, Ltd.     

An in‐cell capacitive touch sensor integrated in an LTPS WSVGA TFT‐LCD

This paper discusses an In‐cell capacitive touch sensor and its integration in an LTPS TFT‐LCD with 7‐inch screen size and WSVGA resolution. The operation of the newly developed sensor is based on capacitive coupling between user's finger and the detection electrode on the TFT substrate, and is purely capacitive. The sensors and the sensor driver circuits have been integrated in the TFT substrate of the prototype TFT‐LCD using LTPS technology. The prototype having 256x150 sensors shows advantages such as smooth operation with no touch force, high position accuracy, multi‐touch (10 or more), a thin and light LCD module, high display quality, and thus is suitable for various applications such as cell‐phones, smart‐phones, mobile‐PCs, and automotive‐use displays.     

A two‐level detector of short‐term unique changes in time series based on a similarity method

In the paper, a novel two‐level algorithm of time‐series change detection is presented. In the first level, to identify non‐stationary sequences in a processed signal, preliminary detection of events is performed with a short‐term prediction comparison. In the second stage, to confirm the changes detected in the first level, a similarity method aimed at identification of unique changes is employed. The detection of changes in a non‐stationary time series is discussed, implemented algorithms are described and the results produced on a sample four financial time series are shown. General conditions for implementing the proposed algorithm as an immune‐like event detector are discussed.     

Asymptotic stability in probability and stabilization for a class of discrete‐time stochastic systems

This paper investigates asymptotic stability in probability and stabilization designs of discrete‐time stochastic systems with state‐dependent noise perturbations. Our work begins with a lemma on a special discrete‐time stochastic system for which almost all of its sample paths starting from a nonzero initial value will never reach the origin subsequently. This motivates us to deal with the asymptotic stability in probability of discrete‐time stochastic systems. A stochastic Lyapunov theorem on asymptotic stability in probability is proved by means of the convergence theorem of supermartingale. An example is given to show the difference between asymptotic stability in probability and almost surely asymptotic stability. Based on the stochastic Lyapunov theorem, the problem of asymptotic stabilization for discrete‐time stochastic control systems is considered. Some sufficient conditions are proposed and applied for constructing asymptotically stable feedback controllers. Copyright © 2014 John Wiley & Sons, Ltd.     

Asymptotic stability in probability for discrete‐time stochastic coupled systems on networks with multiple dispersal

In this paper, we consider the asymptotic stability in probability for discrete‐time stochastic coupled systems on networks with multiple dispersal (DSCSM). We begin with modeling a DSCSM on multiple digraphs and consequently construct a global Lyapunov function based on the topological structure of multiple digraphs. Using the Lyapunov method combined with the graph theory and the supermartingale convergence theorem, several stability criteria for DSCSM are derived. In what follows, the given results are utilized to analyze a stochastic coupled oscillator model. Finally, 2 numerical examples are also given to demonstrate the feasibility of the proposed results.