一种基于Java虚拟机的动静结合自适应优化方法

动态语言可以利用程序运行时获取的动态信息,指导程序进行各种优化。但是,现有的Java虚拟机没有将运行过程中收集的信息有效利用,而是在运行结束后直接丢弃,下一次执行程序的时候重新监测、收集、优化需要的信息。基于HotSpot虚拟机提出一种动静结合的自适应优化方法,将运行过程中优化对象迭代搜索到的最佳参数或者信息保存到资源库中;能够从资源库中学习获得适合当前程序的最佳参数或选项,可有效地利用运行过程中积累的数据;资源分析是静态且离线的,不占用应用程序运行的开销;迭代学习的过程中,通过避免冗余实例入库以及从库中剔除噪声实例,保证资源库学习过程的精度与效率。实验表明,该框架对指导Java虚拟机在不同的平台上自适应优化具有一定的实用性。     

Automatic verification of Java programs with dynamic frames

Framing in the presence of data abstraction is a challenging and important problem in the verification of object-oriented programs Leavens et al. (Formal Aspects Comput (FACS) 19:159–189, 2007). The dynamic frames approach is a promising solution to this problem. However, the approach is formalized in the context of an idealized logical framework. In particular, it is not clear the solution is suitable for use within a program verifier for a Java-like language based on verification condition generation and automated, first-order theorem proving. In this paper, we demonstrate that the dynamic frames approach can be integrated into an automatic verifier based on verification condition generation and automated theorem proving. The approach has been proven sound and has been implemented in a verifier prototype. The prototype has been used to prove correctness of several programming patterns considered challenging in related work.     

Design optimization with static and dynamic displacement constraints

A design optimization procedure using a sequential linear programming technique is proposed in this paper to design minimum weight structures subjected to frequency response and static displacement constraints. The merit of the proposed approach is that the reanalyses of the static and dynamic responses, as well as the computations of the static and dynamic sensitivity data, are performed in a reduced approximate model. A significant saving of computer time for large scale structures is expected. Two numerical examples show good results of this method.     

Synthesis of opaque systems with static and dynamic masks

Opacity is a security property formalizing the absence of secret information leakage and we address in this paper the problem of synthesizing opaque systems. A secret predicate S over the runs of a system G is opaque to an external user having partial observability over G, if s/he can never infer from the observation of a run of G that the run belongs to S. We choose to control the observability of events by adding a device, called a mask, between the system G and the users. We first investigate the case of static partial observability where the set of events the user can observe is fixed a priori by a static mask. In this context, we show that checking whether a system is opaque is PSPACE-complete, which implies that computing an optimal static mask ensuring opacity is also a PSPACE-complete problem. Next, we introduce dynamic partial observability where the set of events the user can observe changes over time and is chosen by a dynamic mask. We show how to check that a system is opaque w.r.t. to a dynamic mask and also address the corresponding synthesis problem: given a system G and secret states S, compute the set of dynamic masks under which S is opaque. Our main result is that the set of such masks can be finitely represented and can be computed in EXPTIME and this is a lower bound. Finally we also address the problem of computing an optimal mask.     

2D shape optimization with static and dynamic constraints

The paper presents an approach that allows us to consider in the shape optimization several static loading conditions together with constraints imposed on eigenfrequencies. The idea of the method is based upon simultaneous solutions of equations and inequalities arising from the Kuhn-Tucker necessary conditions for an optimum problem. The paper is illustrated with four examples in which stress and eigenfrequency are active constraints.     

A generic static analyzer for multithreaded Java programs

In this paper, we present heckmate , the first generic static analyzer of multithreaded Java programs based on abstract interpretation. heckmate can be tuned at different levels of precision and efficiency in order to prove various properties (e.g., absence of divisions by zero and data races), and it is sound for multithreaded programs. It supports all the most relevant features of Java multithreading, such as dynamic thread creation, runtime creation of monitors, and dynamic allocation of memory. The experimental results demonstrate that heckmate is accurate and efficient enough to analyze programs with some thousands of statements and a potentially infinite number of threads. Copyright © 2012 John Wiley & Sons, Ltd.     

Robust reinforcement learning control with static and dynamic stability

Robust control theory is used to design stable controllers in the presence of uncertainties. This provides powerful closed‐loop robustness guarantees, but can result in controllers that are conservative with regard to performance. Here we present an approach to learning a better controller through observing actual controlled behaviour. A neural network is placed in parallel with the robust controller and is trained through reinforcement learning to optimize performance over time. By analysing nonlinear and time‐varying aspects of a neural network via uncertainty models, a robust reinforcement learning procedure results that is guaranteed to remain stable even as the neural network is being trained. The behaviour of this procedure is demonstrated and analysed on two control tasks. Results show that at intermediate stages the system without robust constraints goes through a period of unstable behaviour that is avoided when the robust constraints are included. Copyright © 2001 John Wiley & Sons, Ltd.     

Migration-aware adaptive MPSoC static schedules with dynamic reconfigurability

Technology scalings in semiconductors have enabled the integration of dozens of processing elements (PEs) onto a single chip (MPSoC). Scheduling application tasks onto the target MPSoC has been widely reported in the literature. Both technology scalings and resource competitions among applications have led to the variations of availability resources at runtime. While adaptive static schedules with predictable responses to runtime resource variations have consequently been proposed, a large number of task migrations upon PE failures in this reconfigurable schedule scheme will lead to excessive migration cost among processors and performance degradation. In this paper, we present an algorithm to reduce the number of task migrations while retaining the benefits of the fore techniques. Through embedding several soft constraints into the baseline heuristic scheduling algorithm, the proposed algorithm can decrease the number of task migrations significantly on the basis of holding the advantages of the initial dynamic reconfigurable schedule scheme. The performance evaluation of the proposed technique is carried out by incorporation into a well known heuristic scheduling algorithm. The simulation results confirm its effectiveness in minimizing the number of task migrations during dynamic reconfiguration.     

Extending Java to dynamic object behaviors

Class inheritance and dynamic binding are the key features of object-oriented programming and they permit designing and developing complex systems. However, standard class inheritance is essentially static and cannot be directly employed for modeling dynamic object behaviors. In this paper we propose a linguistic extension of Java, called Dec-Java, that is partially inspired by the decorator design pattern. This extension permits easily separating the basic features of objects (that are likely not to change during the application) from their behaviors (that, instead, can be composed dynamically at run-time). Thus, Dec-Java enables a dynamic extension and specialization of object responsibilities.     

Algorithms for Web service selection with static and dynamic requirements

A main feature of Service Oriented Architectures is the capability to support the development of new applications through the composition of existing Web services that are offered by different service providers. The runtime selection of which providers may better satisfy the end-user requirements in terms of quality of service remains an open issue in the context of Web services. The selection of the service providers has to satisfy requirements of different nature: requirements may refer to static qualities of the service providers, which do not change over time or change slowly compared to the service invocation time (for example related to provider reputation), and to dynamic qualities, which may change on a per-invocation basis (typically related to performance, such as the response time). The main contribution of this paper is to propose a family of novel runtime algorithms that select service providers on the basis of requirements involving both static and dynamic qualities, as in a typical Web scenario. We implement the proposed algorithms in a prototype and compare them with the solutions commonly used in service selection, which consider all the service provider qualities as static for the scope of the selection process. Our experiments show that a static management of quality requirements is viable only in the unrealistic case where workload remains stable over time, but it leads to very poor performance in variable environments. On the other hand, the combined management of static and dynamic quality requirements allows us to achieve better user-perceived performance over a wide range of scenarios, with the response time of the proposed algorithms that is reduced up to a 50 % with respect to that of static algorithms.     

结合VRML和Java建立动态场景

随着虚拟现实技术的发展,对虚拟现实场景不仅要求有逼真的效果,同时还要求有生动的交互功能,而VRML(Visual Reality Modeling Language)与Java的结合是目前常用的交互式虚拟现实技术。文章介绍了虚拟现实建模语言VRML,以及怎样利用VRML与Java语言建立动态交互场景,列举了Java与VRML的几种常用的结合方式,并给出了一个实例。     

Specification and static enforcement of scheduler-independent noninterference in a middleweight Java

We introduce a new timing covert channel that arises from the interplay between multithreading and object orientation. This example motivates us to explore the root of the problem and to devise a mechanism for preventing such errors. In doing so, we first add multithreading constructs to Middleweight Java, a subset of the Java programming language with a fairly rich set of features. A noninterference property is then presented which basically demands program executions be equivalent in the view of whom observing final public values in environments using the so-called high-independent schedulers. It is scheduler-independent in the sense that no matter which scheduler is employed, the executions of the program satisfying the property do not lead to illegal information flows in the form of explicit, implicit, or timing channels. We also give a provably sound type-based static mechanism to enforce the proposed property.     

Integrated implementation of dynamic untyped object‐based operator overloading

Operator overloading, a popular mechanism in the C++ language, is a form of ad hoc polymorphism on operator functions, allowing alternative implementations for different argument types. Classless languages with untyped objects are languages that lack classes and treat all objects as compliant to a common Object type. Languages in this category are flexible, dynamic, and easy‐to‐use, with popular examples being JavaScript, Lua, and ActionScript (the latter being hybrid by also offering classes). This paper presents an integrated implementation of untyped operator overloading which enable users to handle dynamically the full range of operators on objects. The focus is on features not supported by other languages, such as (i) arithmetic and relational operators allowing to separately handle caller lhs and rhs positions; (ii) an assignment operator with an untyped analogy of type casting; (iii) a slot access operator allowing user‐defined policies for editing object slots; and (iv) a function‐call operator to support functors. Operators are treated as first‐class object slots, distinguished by reserved indices that match the respective operator lexemes. All reported techniques have been applied in implementing the operator overloading features of the Delta language. Copyright © 2010 John Wiley & Sons, Ltd.     

Hashing for dynamic and static internal tables

The authors survey the classical hashing-function approach to information retrieval and show how general hashing techniques exchange speed for memory space and flexibility in data manipulation operations such as insert, delete, and overflow. They also discuss recent developments in perfect hashing and minimal perfect hashing, which provide speed and memory compactness when the keys are known in advance     

Squaring down by static and dynamic compensators

Given a system, which is not necessarily invertible and which has an unequal number of inputs, a method of `squaring down', that is a method of designing pre-compensators and postcompensators such that the resulting system has an equal number of inputs and outputs and is invertible, is presented. The compensators are, in general, dynamic and have the property that the additional finite zeros induced by them are assignable to the open left-half complex plan. Furthermore, the compensators are asymptotically stable, and hence do not deteriorate the robustness and performance of an eventual feedback design. Also, the compensator design preserves the stabilizability, detectability, and minimum-phase properties and the infinite zero structure of the original system. Thus, a method of designing nonsquare systems by converting them to square invertible systems is introduced. Two applications of such a design philosophy, (1) diagonal decoupling with state feedback; and (2) almost disturbance decoupling with output feedback, are pointed out