Tomáš Poch

Simulation Level of Detail for Virtual Humans

Graphical level of detail (LOD) is a set of techniques for coping with the issue of limited computational resources by reducing the graphical detail of the scene far from the observer. Simulation LOD reduces quality of the simulation at the places unseen. Contrary to graphical LOD, simulation LOD has been almost unstudied. As a part of our on-going effort on a large virtual-storytelling game populated by tens of complex virtual humans, we have developed and implemented a set of simulation LOD algorithms for simplifying virtual space and behaviour of virtual humans. The main feature of our technique is that it allows for several degrees of detail, i.e. for gradualvarying of simulation quality. In this paper, we summarise the main lessons learned, introduce the prototype implementation called IVE and discuss the possibility of scaling our technique to other applications featuring virtual humans.

CoCoME in Fractal

This chapter presents our solution to the CoCoME assignment that is based on the Fractal component model. The solution involves (i) modeling architecture in Fractal ADL, (ii) specification of component behavior via behavior protocols, (iii) checking compatibility of components, (iv) verification of correspondence between component code and behavior specification, and (v) run-time monitoring of non-functional properties. Among the issues we have faced was the need to modify the architecture - the component hierarchy was reorganized in order to improve clarity of the design and the hierarchical bus was split into two independent buses. These were modeled by primitive components, since Fractal does not support message bus as a first-class entity. Since the CoCoME assignment does not include a complete UML behavior specification (e.g. via activity diagrams and state charts), behavior protocols for all the components are based on the provided plain-English use cases, the UML sequence diagrams, and the reference Java implementation.

CoCoME in SOFA

This chapter presents our solution to the CoCoME assignment that is based on the SOFA 2.0 (SOFtware Appliances) hierarchical component model. The solution involves (i) modeling architecture in SOFA meta-model, (ii) speci fication of component behavior via extended behavior protocols, (iii) checking behavior compliance of components, (iv) verification of correspondence be tween selected component Java code and behavior specification, (v) deploy ment to SOFA run-time envi ronment (using connectors that support RMI and JMS), and (vi) modeling of performance and resource usage via layered queue ing networks. We faced sev eral issues during implementation of the CoCoME assignment in SOFA 2.0. Most notably, the architecture was modified in order to improve clarity of the design --- in particular, the hierarchical bus was re placed by two separate buses and the Inventory component was restructured. Extended behavior protocols for all the components are based on the provided plain-English use cases, the UML sequence diagrams, and the reference Java implementation (the assignment does not include a complete UML behavior specification e.g. via activity dia grams and state charts).

TBP: Code-Oriented Component Behavior Specification

Assuring components compatibility plays a crucial part in developing a reliable component system. Especially, when the components come from different vendors worldwide. In order to do so, an appropriate formalism for behavior specification of components is necessary. We propose a formalism of threaded behavior protocols, which-unlike most other formalisms-allows for both analysis on the formal level (correctness and substitutability checking) and reasoning about conformance of a specification and the actual implementation. Moreover, the formalism is designed to be simple enough and to directly support constructs known from implementation languages (e.g., method calls, threads, synchronized blocks), so that it is easy to use by a nonprofessional.

Pattern-Based Verification for Multithreaded Programs

Pattern-based verification checks the correctness of program executions that follow a given <i>pattern</i>, a regular expression over the alphabet of program transitions of the form <i>w</i>₁^* … <i>w</i>_<i>n</i>^*. For multithreaded programs, the alphabet of the pattern is given by the reads and writes to the shared storage. We study the complexity of pattern-based verification for multithreaded programs with shared counters and finite variables. While unrestricted verification is undecidable for abstracted multithreaded programs with recursive procedures and PSPACE-complete for abstracted multithreaded while-programs (even without counters), we show that pattern-based verification is NP-complete for both classes, even in the presence of counters. We then conduct a multiparameter analysis to study the complexity of the problem on its three natural parameters (number of threads+counters+variables, maximal size of a thread, size of the pattern) and on two parameters related to thread structure (maximal number of procedures per thread and longest simple path of procedure calls). We present an algorithm that for a fixed number of threads, counters, variables, and pattern size solves the verification problem in <i>st</i>^{<i>O</i>(<i>lsp</i>+ ⌈ log (<i>pr</i>+1) ⌉)} time, where <i>st</i> is the maximal size of a thread, <i>pr</i> is the maximal number of procedures per thread, and <i>lsp</i> is the longest simple path of procedure calls.

JavaCompExt: Extracting Architectural Elements from Java Source Code

Abstract—Software architecture erosion is a general problem in legacy software. To fight this trend, component models and languages are designed to try to make explicit, and automatically enforceable, the architectural decisions in terms of components, interfaces, and allowed communication channels between component interfaces. To help maintainers work on existing object-oriented systems, we explore the possibility of extracting architectural elements (components, communications, services, ...) from the source code. We designed a tool based on some heuristics for extracting component information from Java source code.

Extracting Behavior Specification of Components in Legacy Applications

A challenge of componentizing legacy applications is to extract behavior specification of suggested components. It is desirable to preserve a relation between the original structure of the source code of a component and the extracted specification; in particular, this is important for both user comprehension and for interpretation of results of any further formal verification. Even though the reverse engineering techniques providing behavior specification have already been applied on object oriented software and components, none of them targets the interplay of both the externally and internally triggered activities on the components provided and required interfaces from a single perspective. This paper targets the problem in the scope of Behavior Protocols and components given as a set of Java classes accompanied with information on component boundaries. To demonstrate viability of the proposed approach, this technique has been partially applied in the JAbstractor tool for the SOFA component model.

Threaded behavior protocols

Component-based development is a well-established methodology of software development. Nevertheless, some of the benefits that the component based development offers are often neglected. One of them is modeling and subsequent analysis of component behavior, which can help establish correctness guarantees, such as absence of composition errors and safety of component updates. We believe that application of component behavior modeling in practice is limited due to huge differences between the behavior modeling languages (e.g., process algebras) and the common implementation languages (e.g., Java). As a result, many concepts of the implementation languages are either very different or completely missing in the behavior modeling languages. As an example, even though behavior modeling languages are practical for modeling and analysis of various message-based protocols, they are not well suited for modeling current component applications, where thread-based parallelism, lock-based synchronization, and nested method calls are the essential building blocks. With this in mind, we propose a new behavior modeling language for software components, Threaded Behavior Protocols (TBP). At the model level, TBP provides developers with the concepts known from the implementation languages and essential to most component applications. In addition, the theoretical framework of TBP provides a notion of correctness based on absence of communication errors and a refinement relation to verify correctness of hierarchical components. The main asset of TBP formalism is that it links together the notion of threads as used in imperative object oriented languages and the notion of refinement. For instance, this allows reasoning about hierarchical components composed of primitive components implemented in Java without the need of bridging abstractions and simplifications enforced by the modeling languages.

Level-of-Detail in behaviour of virtual humans

An application featuring virtual humans is a program that simulates an artificial world inhabited by virtual people. Recently, only either small artificial worlds inhabited by a few complex virtual humans, or larger worlds with tens of humans, but performing only walking and crowding, are simulated. This is not surprising: a large world inhabited by complex virtual humans requires unreasonable amount of computational and memory resources. In this paper, we report on the project IVE, a common simulation framework for huge artificial worlds, pointing out the level-of-detail technique used at the behavioural level. The technique addresses the issue on reducing simulation demands by gradually decreasing simulation quality on unimportant places, while keeping the simulation plausible, with minimum scenic inconsistencies.

Strengthening Component Architectures by Modeling Fine-Grained Entities

Component-based software engineering (CBSE) defines components as basic software building blocks with strongly formalized behavior and interactions. The key benefits of structuring code into components include good analyzability of performance and behavioral correctness, simpler code generation, and high documentation value. However, a sufficiently detailed formalization including all relevant parts of application behavior often requires finer granularity than of a software component - a typical example is components data exposed to other components that can circulate through the application, e.g., opened files, client sessions. In order to propagate all the mentioned benefits of CBSE to this level of granularity, we propose a conservative component model extension which allows to capture those concepts on the architecture level. Our main goal is to define a model allowing seamless integration in existing behavior specification formalisms and implementation in current component systems.