Fig 1 - uploaded by Konstantinos Blekas
Content may be subject to copyright.
Source publication
Pattern-based Java bytecode compression techniques rely on the identification of identical instruction sequences that occur more than once. Each occurrence of such a sequence is substituted by a single instruction. The sequence defines a pattern that is used for extending the standard bytecode instruction set with the instruction that substitutes t...
Contexts in source publication
Context 1
... size of instruction opcodes or operands is 1 byte. As an example, consider the Java program given in Figure 1(a). This simple program comprises a class of objects that represent vectors in the 3-dimensional space. ...
Context 2
... vector is characterized by 3 coordinates (x, y, z, attributes) and provides a method, called distance, which calculates the Euclidean distance norm, d = x 2 + y 2 + z 2 , for the vector. The compiled bytecode for the distance method of our program is given in Figure 1(b). The overall size of the sequence is 34 bytes. ...
Context 3
... overall size of the sequence is 34 bytes. In the remainder of this section, we use the example of Figure 1(b) to highlight the main steps of the non-parameterized and the parameterized compression approaches, discussed in this section. In both cases, the overall compression process consists of the following steps: ...
Context 4
... to our example scenario, the bytecode for the dis- tance method (Figure 1(b)) constitutes a basic block as it does not comprise any branch operations. Alphabet Σ consists of 12 characters that encode the various opcodes (e.g., getfield, aload 0, etc.) and operands (e.g., 0, 2, 3, 4, 5) used in the basic block. ...
Context 5
... the first step of AC, n v = 1 and each row m of the θ v matrix contains one element equal to 1. The values of all the other elements of the m-th row are 0. Taking our example program of Figure 1, suppose that we search for patterns, whose maximum length is 9 bytes. AC must be applied in the different collections X 2 , . . . ...
Context 6
... this section, we provide further details regarding the experiments performed for the assessment of the parameterized pattern discovery technique discussed in this paper. Specifi- cally, Figures 10 and 11, provide details regarding the bytecode size reduction obtained per different MIDP class from the application of the first and the second heuristics in P param , P non−param , P 1w , P 2w , P 3w and P 4w . Similarly, Figures 12 and 13 give the bytecode size reduction obtained per different MIDP class from the application of the first and the second heuristics in P param , P non−param , P 1−2w , P 1−3w and P 1−4w . ...
Context 7
... cally, Figures 10 and 11, provide details regarding the bytecode size reduction obtained per different MIDP class from the application of the first and the second heuristics in P param , P non−param , P 1w , P 2w , P 3w and P 4w . Similarly, Figures 12 and 13 give the bytecode size reduction obtained per different MIDP class from the application of the first and the second heuristics in P param , P non−param , P 1−2w , P 1−3w and P 1−4w . Finally, Figures 14 and 15 detail the impact of increasing the maximum length of the patterns found in MIDP from 9 to 11, in the bytecode size reduction obtained and the time required for compressing each MIDP class. ...
Context 8
... Figures 12 and 13 give the bytecode size reduction obtained per different MIDP class from the application of the first and the second heuristics in P param , P non−param , P 1−2w , P 1−3w and P 1−4w . Finally, Figures 14 and 15 detail the impact of increasing the maximum length of the patterns found in MIDP from 9 to 11, in the bytecode size reduction obtained and the time required for compressing each MIDP class. ...
Similar publications
In the last decade the use of different mobile products such as mobile phones and Personal Digital Assistant (PDA) devices has increased rapidly. In parallel, the use of computerized-adaptive testing (CAT) has expanded mainly due to the advancements in communication and information technology. The introduction of mobiles devices into the learning p...
We address the problem of adaptive compression of natural language text, considering the case where the receiver is much less powerful than the sender, as in mobile applications. Our techniques achieve compression ratios around 32% and require very little effort from the receiver. Furthermore, the receiver is not only lighter, but it can als...
Mobile computing has experienced a rapid growth and there are nowadays many applications being developed. According to the literature, many of these applications are designed for collaborative work or learning and share the same requirements: they implement a peer-to-peer communication architecture, there are subgroups inside the group of participa...
We present two methods for lossy compression of normal vectors through quantization using "base" polyhedra. The first revisits subdivision-based quantization. The second uses fixed-precision barycentric coordinates. For both, we provide fast (de)compression algorithms and a rigorous upper bound on compression error. We discuss the effects of base p...
This paper presents an analysis tool for comparative and collaborative evaluation of mobile artefact usage. Three scenarios were envisioned for the comparative dimension ranging from simple artefact visualization to real-time monitoring. The collaborative dimension is detailed according to two scenarios: existence of a public display and the use of...
Citations
... For example, Huffman codes may be used to find shorter representations for frequently used instructions. Compression techniques require decompression at runtime, consuming computation resources on the device [56]. Thus, on small embedded devices, where memory and computing capabilities are limited, it is desirable that at runtime, a partial rather than full decompression is performed. ...
This thesis describes the TakaTuka Java virtual machine (JVM), which has been developed for microcontrollers with small RAM, storage and processing power. The TakaTuka optimizes storage requirements for the Java binary as well as the JVM interpreter, both of which are to be stored on an embedded device. On the average, Java binary size of the TakaTuka JVM can have a percentage reduction of more than 92 % of the size of traditional Java binary of a program. Furthermore, the interpreter size for a given program may be reduced to as small as 25 KB. Thus a mote with small flash storage executes a highly optimized Java binary and Java interpreter.
The ability of tiny motes to run large, feature-rich Java programs is constrained by the amount of RAM installed on such devices. The memory management for a Java program may be divided into two parts. First, the memory consumed by each object is managed by the Garbage Collection (GC), which is executed intermittently to reclaim that memory. Second, the memory consumed by the frame of a function is automatically reclaimed on the completion of function’s invocation. TakaTuka has an Offline GC to reduce the
aggregated memory requirements of objects during execution of a program. The Offline GC allows freeing an object that is still reachable but is guaranteed not to be used again in the program. The Offline GC is shown to increase the amount of RAM available to a program by up to 66% as compared with a typical online garbage collector. Another important feature of the TakaTuka JVM is variable Slot Size (VSS) scheme that reduces RAM requirements of the function’s frame.
TakaTuka storage and RAM optimizations also increase the speed of a program execution thus increasing the lifetime of the mote. The storage, performance and RAM consumption features of the TakaTuka JVM makes it an attractive platform for developing applications for wireless sensor networks employing microcontrollers and embedded devices.
... We also support threading, synchronized method calls, 8-byte data types and 4-byte floating point arithmetic on motes. Bytecode Optimization: The two primary methods for bytecode size reduction are compression and compaction [6] [5]. A typical compression technique requires partial or full decompression at runtime [6]. ...
... Bytecode Optimization: The two primary methods for bytecode size reduction are compression and compaction [6] [5]. A typical compression technique requires partial or full decompression at runtime [6]. Any decompression always results in computation and memory overhead. ...
We have developed TakaTuka, a Java Virtual Machine optimized for tiny embedded devices such as wireless sensor motes. TakaTuka
requires very little memory and processing power from the host device. This has been verified by successfully running TakaTuka
on four different mote platforms. The focus of this paper is TakaTuka’s optimization of program memory usage. In addition,
it also gives an overview of TakaTuka’s linkage with TinyOS and power management. TakaTuka optimizes storage requirements
for the Java classfiles as well as for the JVM interpreter, both of which are expected to be stored on the embedded devices.
These optimizations are performed on the desktop computer during the linking phase, before transferring the Java binary and
the corresponding JVM interpreter onto a mote and thus without burdening its memory or computation resources. We have compared
TakaTuka with the Sentilla, Darjeeling and Squawk JVMs.
... Most of the functionality in the standard library is unnecessary for the proposed system for example APIs for GUI programming, 3D acceleration , sound output and the like have little use on WSN hardware. @BULLET Optimize the Java bytecode for size -there has been previous research [14] into optimizing .class files to make them more suitable for embedded systems. ...
Wireless sensor networks and methods of developing user applications is an active research area with several unique challenges. In this paper we first present an overview of the current programming approaches. We then describe a system under development that adapts techniques from the distributed operating systems world to create a new method of programming wireless sensor networks.
... The size and organization of class files have a significant impact on the performance of JVMs, especially for those on the embedded platforms which are limited in both processing power and memory size. To reduce the sizes of class files, Saougkos et al. (2007) employed pattern-based compression algorithms while Rder Clausen et al. (2000) factorized commonly executed bytecode sequences. Haggett et al. extended the token-based linking approach in Java Card (Virtual Machine Specification, 2006) into the Java ME platform to simplify the method invocation (Haggett et al., 2007). ...
Hardware bytecode translation is a technique to improve the performance of the Java virtual machine (JVM), especially on the portable devices for which the overhead of dynamic compilation is significant. However, since the translation is done on a single bytecode basis, a naive implementation of the JVM generates frequent memory accesses for local variables which can be not only a performance bottleneck but also an obstacle for instruction folding. A solution to this problem is to add a small register file to the data path of the microprocessor which is dedicated for storing local variables. However, the effectiveness of such a local variable register file depends on the size and the local variable access behavior of the applications.In this paper, we analyze the local variable access behavior of various Java applications. In particular, we will investigate the fraction of local variable accesses that are covered by the register file of a varying size, which determines the chip area overhead and the operation speed. We also evaluate the effectiveness of the sliding register window for parameter passing in context of JVM and on-the-fly optimization of local variable to register file mapping.With two types of exceptions, a 16-entry register file achieves coverages of up to 98%. The first type of exception is represented by the SAXON XSLT processor for which the effect of cold miss is significant. Adding the sliding window feature to the register file for parameter passing turns 6.2–13.3% of total accesses from miss to hit to the register file for the SAXON with XSLTMark. The second type of exception is represented by the FFT, which accesses more than 16 local variables for most of method invocations. In this case, on-the-fly profiling is effective. The hit ratio of a 16-entry register file for the FFT is increased from 44% to 83% by an array of 8-bit counters.
Java Card is a Java running environment developed for low-end embedded systems such as smart cards. In this context of scarce resources, ROM size plays a very important role and compression techniques help reducing program sizes as much as possible. Dictionary compression is the most promising technique and has been taken in consideration in this field by several authors.
Java Card can adopt a dictionary compression scheme, substituting repeated sequences of bytecodes with new macros stored into a dictionary. This approach does not break the Java Card standard, but requires the use of an ad hoc Java virtual machine and an additional custom component in the converted applet (CAP) file. This paper presents two derived compaction techniques and discusses two scenarios: the first adopts an adaptive (dynamic) dictionary, while the second uses a static one. Although the base dictionary compression technique performs better with an adaptive dictionary, the two proposed techniques perform very close to the base one with a static dictionary. Moreover, we present a different compression mechanism based on re-engineering the CAP file through subroutines. This last technique achieves a higher compression rate, but it is fully compliant with the existing Java Card environments.
