Naoshi Tabuchi

Model-Driven performance analysis of UML design models based on stochastic process algebra

The popular model-driven development (MDD) methodology strongly promotes a model-based approach to modular system development, which often implies as an integral part automatic transformation of UML design components into executable forms. When using MDD for verifying performance-related system specifications, UML designs annotated with these specifications in some profile language need to be transformed to stochastic (Markovian) models or timed simulation models. However, most of the previous efforts have focused on transformations of (variants of) UML state machine models and/or transformations to stochastic Petri net models, which lead to two problems: Relying (solely) on state machine models often restricts design flexibility (designers instead prefer choosing diagrams on a case-by-case basis), and graph-oriented Petri net models complicate the modular transformations of UML models. To resolve these problems, we propose stochastic performance analysis of a UML design defined in different sorts of diagrams, including not only state machines but also activity diagrams with temporal annotation in UML-SPT, which are transformed into stochastic process algebraic forms. To our knowledge, this is the first attempt to define stochastic process algebraic semantics for the UML AD with UML-SPT annotations. Unlike the related efforts, ours will facilitate verification in early development stages, in which consultants and architects can benefit from modeling in a natural manner and modular component-based development, thanks to the inherent compositionality of process algebra. Further, to guarantee the validity of the transformation, we have proved the equivalence of our semantics with the stochastic Petri net semantics of UML AD. We have developed a prototype implementation of this performance analysis mechanism, and shown that realistic design examples, defined in different sorts of UML diagrams, can successfully be transformed into those that provide various performance metrics.

An Efficient and Portable Scheduler for RTOS Simulation and its Certified Integration to SystemC

We propose a new task scheduling algorithm for timed-functional simulation of concurrent software tasks. It attains efficiency by reducing the frequency of context-switching between concurrent tasks. It also provides a high-degree of portability in the sense that it only needs the underlying system to support a very small number of primitives. We provide a concrete implementation built on top of the SystemC scheduler and show some results of preliminary evaluation

Reducing Unnecessary Conservativeness in Access Rights Analysis with String Analysis

The JavaTM2 runtime system has a security mechanism which guarantees the code under execution has appropriate access permissions to a certain system resource. Use of this security mechanism requires access control policies to specify what operations are permitted on each such resource at each program point. Previous work proposed a program analysis algorithm to statically infer a semi-optimal policy set from given program text. However the proposed method cannot calculate the optimal policy when the target resource is determined by string values at run-time, since it does not keep track of all potential string values generated through built-in or user-defined methods. This results in generating excessive access policies where actually unnecessary resource accesses are permitted. To overcome such limitations, we apply static string analysis to program variables relevant to access control policies. This paper shows that unnecessary permissions can be reduced with string analysis by applying it to analyzing open-source libraries.

Secure Behavior of Web Browsers to Prevent Information Leakages

Recently Web browsers are widely used as client-side application platforms beyond the traditional use of Web browsers. One of main reasons for such evolution of the browsers is the client-side JavaScript language that can execute programs embedded in a document. However, Web applications with client-side JavaScript programs have problems of leaking private information (such as cookie information) due to interactions between the browser and scripts embedded in the document. We propose a new calculus representing browser behavior that prevents information from leakage by means of language-based information flow. The proposed calculus can deal with script rewriting and higher-order functions. In addition, our calculus has a noninterference property depending on a security policy statically given by the user.