Java Servlet模式的WebGIS性能优化研究*

探讨了使用Java Servlet模式实现WebGIS的优势与方法,采用GeoServer与OpenLayers结合的方式设计并实现了一种Java Servlet模式的WebGIS系统.由于服务器端性能的优劣直接影响到客户端用户的使用和体验效果,因此对WebGIS服务器端性能问题进行了深入研究,提出了JVM(Java虚...     

Memory power optimization of Java-based embedded systems exploiting garbage collection information

Nowadays, Java is used in all types of embedded devices. For these memory-constrained systems, the automatic dynamic memory manager (Garbage Collector or GC) has been always a key factor in terms of the Java Virtual Machine (JVM) performance. Moreover, in current embedded platforms, power consumption is becoming as important as performance. Thus, in this paper we present an exploration, from an energy viewpoint, of the different possibilities of memory hierarchies for high-performance embedded systems when used by state-of-the-art GCs. This is a starting point for a better understanding of the interactions between the Java applications, the memory hierarchy and the GC.Hence, we subsequently present two techniques to reduce energy consumption on Java-based embedded systems, based on exploiting GC information. The first technique uses GC execution behavior to reduce leakage energy consumption taking advantage of the low-power mode of actual multi-banked SDRAM memories and it is intended for generational collectors. This technique can achieve a reduction up to 50% of SDRAM memory leakage.The second technique involves the inclusion of a software-controlled (scratch-pad) memory that stores GC instructions under the JVM control to reduce the active energy consumption and also improve the performance of the target embedded system and it is aimed at all kind of garbage collectors. For this last technique we have experimented with two different approaches for selecting the GC code to be stored in the scratchpad memory: one static and one dynamic. Our experimental results show that the proposed dynamic scratchpad management approach for GCs enables up to 63% energy consumption reduction and 25% performance improvement during the collector phase, which means, in terms of JVM execution, a global reduction of 29% and 17% for energy and cycles, respectively.Overall, this work outlines that the key for an efficient low-power implementation of Java Virtual Machines for high-performance embedded systems is the synergy between the GC choice, the memory architecture tuning, and the inclusion of power management schemes controlled by the JVM, exploiting knowledge of the GC behavior.     

Workload characterization of JVM languages

Originally developed with a single language in mind, the JVM is now targeted by numerous programming languages—its automatic memory management, just‐in‐time compilation, and adaptive optimizations—making it an attractive execution platform. However, the garbage collector, the just‐in‐time compiler, and other optimizations and heuristics were designed primarily with the performance of Java programs in mind. Consequently, many of the languages targeting the JVM, and especially the dynamically typed languages, are suffering from performance problems that cannot be simply solved at the JVM side. In this article, we aim to contribute to the understanding of the character of the workloads imposed on the JVM by both dynamically typed and statically typed JVM languages. To this end, we introduce a new set of dynamic metrics for workload characterization, along with an easy‐to‐use toolchain to collect the metrics. We apply the toolchain to applications written in six JVM languages (Java, Scala, Clojure, Jython, JRuby, and JavaScript) and discuss the findings. Given the recently identified importance of inlining for the performance of Scala programs, we also analyze the inlining behavior of the HotSpot JVM when executing bytecode originating from different JVM languages. As a result, we identify several traits in the non‐Java workloads that represent potential opportunities for optimization. © 2015 The Authors. Software: Practice and Experience Published by John Wiley & Sons Ltd.     

JN: OS for an embedded Java network computer

In early 1996, the Computer Science Department at UC Santa Cruz agreed with National Semiconductor to design a custom embedded operating system to support the Java Virtual Machine (JVM). Our goal was to tightly integrate Java with a realtime kernel on a small, single-chip, embedded PC attached to the Internet. By the end of 1996, we had succeeded in implementing the first operating system designed and developed in an academic environment specifically to support Java. This article reviews the lessons we learned from what is most likely the first custom designed operating system-other than JavaSoft's JavaOS-that runs the complete JVM. Our current system, the Java nanokernel (JN), supports a simple Web server written in Java and provides a Java interface to a color Connectix camera     

Enterprise computing: the Java factor

The ubiquitous availability of Web browsers on multiple platforms and user familiarity with browser technology provide numerous advantages: a uniform interface; support for multimedia and user interaction and collaboration; a simple communication protocol that has been implemented in all major hardware and software platforms; and support by almost all vendors who package Web engines within their products. Such factors have expedited the implementation of network centric computing as a productive infrastructure for corporate environments. The addition of Java, with its ability to build cross platform application logic into a browser, gives network centric computing the potential to better meet enterprise computing needs. Because it lets users interact with the application on the client rather than the server, Java enables better utilization of both the server and the client's computational capability. Java can also provide sessions state information (for client side session control and resource management) in an otherwise stateless Web world. Besides naturally decentralizing application execution, Java makes it possible to decentralize application deployment. In large enterprises, organization wide applications such as personnel timekeeping or document routing can benefit from Java implementations. One immediate impact is a noticeable reduction of the server load during peak hours. Finally, Java enabled browsers can provide greater functionality than HTML     

Web++ architecture,design and performance

We describe the design of a system for fast and reliable HTTP service which we call Web++. Web++ achieves high reliability by dynamically replicating web data among multiple web servers. Web++ selects the available server that is expected to provide the fastest response time. Furthermore, Web++ guarantees data delivery given that at least one server containing the requested data is available. After detecting a server failure, Web++ client requests are satisfied transparently to the user by another server. Furthermore, the Web++ architecture is flexible enough for implementing additional performance optimizations. We describe implementation of one such optimization, batch resource transmission, whereby all resources embedded in an HTML page that are not cached by the client are sent to the client in a single response. Web++ is built on top of the standard HTTP protocol and does not require any changes either in existing web browsers or the installation of any software on the client side. In particular, Web++ clients are dynamically downloaded to web browsers as signed Java applets. We implemented a Web++ prototype; performance experiments indicate that the Web++ system with 3 servers improves the response time perceived by clients on average by 36.6%, and in many cases by as much as 59%, when compared with the current web performance. In addition, we show that batch resource transmission can improve the response time on average by 39% for clients with fast network connections and 21% for the clients with 56 Kb modem connections. This revised version was published online in August 2006 with corrections to the Cover Date.     

Enterprise computing with Jini technology

You may think of Jini technology from Sun Microsystems as software for networking embedded systems-machines that contain a microprocessor and do a specific task. But more specifically, Jini software gives network devices self-configuration and self-management capabilities; it lets devices communicate immediately on a network without human intervention. These networks are also self-healing in that devices that leave the network for any reason (machine crashes or power surges, for example) do not affect the remaining devices' operation. A Jini client that loses contact with a server can recover and continue processing. Although it is precisely these advantages that make Jini technology attractive for embedded systems, why stop there? Network plug-and-play capabilities and self-configuration are also attractive for enterprise computing. Java, for example, was initially designed for embedded devices. But that hasn't stopped it from becoming a major force in enterprise computing. Does Java drive your Web server or backend application? At many companies, it does-not a bad accomplishment for an embedded system language. We contend that Jini technology's true promise lies in enterprise computing because it has unique abilities that extend beyond plug-and-play network connectivity     

Integrating Java 3D model and sensor data for remote monitoring and control

This paper presents a novel approach and a framework for web-based systems that can be used in distributed manufacturing environments. A prototype is developed to demonstrate its application to remote monitoring and control of a Tripod—one type of parallel kinematic machine. It utilizes the latest Java technologies (Java 3D and Java Servlets) as enabling technologies for system implementation. Instead of using a camera for monitoring, the Tripod is modeled using Java 3D with behavioral control nodes embedded. Once downloaded from its server, the 3D model behaves in the same way of its counterpart at client side. It remains alive by connecting with the Tripod through message passing, e.g., sensor signals and control commands transmissions. The goal of this research is to eliminate network traffic with Java 3D models, while still providing users with intuitive environments. In the near future, open-architecture devices will be web-ready having Java virtual machines embedded. This will make the approach more effective for web-based device monitoring and control.     

Efficiently Adapting Java Binaries in Limited Memory Contexts

This paper presents a compilation framework that allows executable code to be shared across different Java Virtual Machine (JVM) instances. Current compliant JVMs for servers are burdened with large memory footprints (because of the size of the increasingly complicated compilers) and high startup costs, while compliant JVMs for embedded devices typically rely on interpretation. This paper describes a quasi-static approach that allows execution of a read-only version of the code, enabling compiled Java binaries to be embedded in ROM in an embedded environment or shared across multiple applications in a server environment. We have implemented this approach in the Quicksilver quasi-static compiler for the Jikes RVM (Jikes Research Virtual Machine). On the SPECjvm98 benchmark suite, our approach gives writable memory space savings of between 82–89% over that of our previous (non-sharable, non-ROMable) quasi-static approach, while delivering performance that is typically within 1–7% of that approach, and is competitive with the performance of the Jikes RVM adaptive optimization system.     

基于Internet的计算机网络虚拟实验环境架构

提出了基于Internet的计算机网络虚拟实验室的开发模型。该模型的客户端是Java Applet，计算后台以NS为核心，辅以JavaBean来完成辅助计算，中间的通信桥梁是CORBA，通过CORBA实现NS与Java的数据传输。该模型具有Java语言的优点，客户端简单安全，服务器端利用了第三方工具NS，能够大大缩短开发周期，确保系统的正确性。     

Java编译系统的研究

文中综述了具有代表性的Ｊａｖａ编译系统：以采用的虚拟机技术来划分的三代Ｊａｖａ编译系统,以及为特定平台的服务器端Ｊａｖａ程序设计的编译系统,对它们的结构和工作原理进行了阐述,并分析指出了它们各自的优缺点,进行了一些比较,为实现基于我国国产系统平台ＣＯＳＡ／ＣＯＳＩＸ上的Ｊａｖａ编译系统提供了很好的借鉴。     

嵌入式JAVA虚拟机的加速改造

首先分析了Sun公司的嵌入式Java虚拟机KVM性能低效的原因,在此基础上引入两种Java虚拟机性能加速技术:JIT和Native线程。通过建立MVM模型,将这两种加速技术融合到了Java虚拟机中,并详细介绍了实现这两种加速技术的关键数据结构和算法。实验结果表明Java虚拟机的性能获得明显的提高。     

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.     

基于Java 2安全体系结构的安全扩展研究

Java虚拟机已经越来越频繁地作为动态Web服务的基本引擎。随着对这些网络资源的攻击的增多,更多的研究关注于网络环境下的安全性。但是在攻击者拥有主机的有效登入的情况下,如何确保Java Web服务器的安全的研究却很少。在介绍了Java安全机制的弱点之后,提出了一个基于Java2安全体系结构的安全扩展系统,并分析了系统的运行状态。该系统对Java应用服务器的正确操作和完整性提供了增强的保证。     

利用层次网格索引提高WebGIS性能

层次网格索引是在传统网格索引的基础上，进一步改进，减少了传统网格索引的冗余和索引的大小。在层次网格索引的基础上，利用客户端和服务器端的双缓冲机制，可以减轻网络传输和服务器的负担，提高WebGIS应用的整体性能。     

JaRec: a portable record/replay environment for multi‐threaded Java applications

This paper describes JaRec, a portable record/replay system for Java. It correctly replays multi‐threaded, data‐race free Java applications, by recording the order of synchronization operations, and by executing them in the same order during replay. The record/replay infrastructure is developed in Java, and does not require a modification of the Java Virtual Machine (JVM) if it provides the JVM Profiler Interface (JVMPI). If the JVM does not support JVMPI, which is used for intercepting the loaded classes, only a minor modification to the JVM is required in order to run the system. On ystems with limited memory resources, JaRec can be executed in a distributed fashion. This also makes it suitable to aid debugging of multi‐threaded applications on embedded systems. Copyright © 2004 John Wiley & Sons, Ltd.     

Using Bytecode Instruction Counting as Portable CPU Consumption Metric

Accounting for the CPU consumption of applications is crucial for software development to detect and remove performance bottlenecks (profiling) and to evaluate the performance of algorithms (benchmarking). Moreover, extensible middleware may exploit resource consumption information in order to detect a resource overuse of client components (detection of denial-of-service attacks) or to charge clients for the resource consumption of their deployed components. The Java Virtual Machine (JVM) is a predominant target platform for application and middleware developers, but it currently lacks standard mechanisms for resource management.In this paper we present a tool, the Java Resource Accounting Framework, Second Edition (J-RAF2), which enables precise CPU management on standard Java runtime environments. J-RAF2 employs a platform-independent CPU consumption metric, the number of executed JVM bytecode instructions. We explain the advantages of this approach to CPU management and present five case studies that show the benefits in different settings.     

The Object‐JavaScript language

Complex graphical user interfaces (GUIs) that support a large amount of user interaction require a fast response time, a rich set of building blocks for an esthetic look‐and‐feel, and a development environment that supports ongoing change. On the World Wide Web, client‐side technologies offer more of these features than do server‐side solutions. Java and JavaScript are the two most popular languages used for client‐side GUI implementations. Java implementations require a user to download a plug‐in that contains a virtual machine to execute the Java byte‐code. The installation and maintenance of this plug‐in is sometimes an unsurmountable barrier to using Java. JavaScript lacks some of the desirable features of Java, such as easy to use object‐oriented features and having a GUI class library, but does not require a plug‐in. We have enhanced JavaScript by implementing a new language Object‐JavaScript (OJS) and by providing an OJS library of GUI components, thus making it a viable alternative to Java. Copyright © 2000 John Wiley & Sons, Ltd.     

Web workload generation challenges – an empirical investigation

Workload generators are widely used for testing the performance of Web‐based systems. Typically, these tools are also used to collect measurements such as throughput and end‐user response times that are often used to characterize the QoS provided by a system to its users. However, our study finds that Web workload generation is more difficult than it seems. In examining the popular RUBiS client generator, we found that reported response times could be grossly inaccurate, and that the generated workloads were less realistic than expected, causing server scalability to be incorrectly estimated. Using experimentation, we demonstrate how the Java virtual machine and the Java network library are the root causes of these issues. Our work serves as an example of how to verify the behavior of a Web workload generator. Copyright © 2011 John Wiley & Sons, Ltd.     

Java虚拟机的硬件实现研究

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