• International Journal of Contents
• /
• v.14 no.3
• /
• pp.7-16
• /
• 2018

The extent and depth of the event plan determines the scope of pedagogical experience in situations and consequently the quality of immersive learning based on our simulated world. In contrast to planning in conventional narrative-based systems mainly pursuing dramatic interests, planning in virtual world-based pedagogical systems strive to provide realistic experiences in immersed situations. Instead of story plot comprising predetermined situations, our inter-event planning method aims at simulating diverse situations that each involve multiple events coupled via their associated agents' conditions and meaningful associations between events occurring in a background world. The specific techniques to realize our planning method include, two-phase planning based on inter-event search and intra-event decomposition (down to the animated action level); autonomous and independent agents to behave proactively with their own belief and planning capability; full-blown background world to be used as the comprehensive stage for all events to occur in; coupling events via realistic association types including deontic associations as well as conventional causality; separation of agents from event roles; temporal scheduling; and parallel and concurrent event progression mechanism. Combining all these techniques, diverse exogenous events can be derived and seamlessly (i.e., semantically meaningfully) integrated with the original event to form a wide scope of situations providing chances of abundant pedagogical experiences. For effective implementation of plan execution, we devise an execution scheme based on multiple priority queues, particularly to realize concurrent progression of many simultaneous events to simulate its corresponding reality. Specific execution mechanisms include modeling an action in terms of its component motions, adjustability of priority for agent across different events, and concurrent and parallel execution method for multiple actions and its expansion for multiple events.

• The KIPS Transactions:PartA
• /
• v.16A no.2
• /
• pp.55-60
• /
• 2009

Race conditions in current Java programs must be detected because it may cause unexpected result by non-deterministic executions. For detecting such races during program execution, execution flows of all threads and all access events can be monitored. It is difficult for previous race detection techniques to monitor all threads and access events in actuality because these techniques analyze the files traced during program execution or modify original source programs and then monitor these programs. This paper presents a transparent scalable monitoring tool to detect races using JDI(Java Debug Interface) where JDI is 100% pure java interface to provide in JDPA(Java Platform Debugger Architecture) and is able to provide information corresponding to events occurred in run-time of programs. This tool thus can monitor execution flows of all threads and all access events without program modification. We prove transparency of the presented tool and grasp the efficiency of it using a set of published benchmark programs. As a result of this, the suggested tool can monitor all threads and accesses of these programs without their modification, and their monitoring time is increased to more than 20 times.

• Journal of KIISE:Computer Systems and Theory
• /
• v.31 no.1_2
• /
• pp.41-50
• /
• 2004

Detecting races is important for debugging shared-memory Parallel programs, because races result in unintended nondeterministic executions of the programs. Particularly, the first races to occur in an execution of a program must be detected because they can potentially affect other races that occur later. Previous on-the-fly techniques that detect such first races based on candidate events that are likely to participate in the first races monitor access events in order to collect the candidate events during a program execution, and try to report the races only from determining the concurrency relationships of the candidates. Such races reported in this way. however, are not guaranteed to be first races, because they are not determined by taking into account how they are affected with each other. This paper presents a new post-mortem technique that analyzes, on each nesting level, candidate events collected from an execution of a shared-memory program with nested parallelism in order to report only first races. This technique is efficient, because it guarantees that first races reported by analyzing a nesting level are the races that occur first at the level, and does not require more analyses to the higher nesting levels than the current level. The Proposed technique facilitates more practical and effective debugging than the previous techniques, because it guarantees to detect first races if candidate events are collected from an execution instance of the program with nested parallelism.

• International Journal of Contents
• /
• v.16 no.1
• /
• pp.25-33
• /
• 2020

We develop a simulation method that affords very high variability of virtual pedagogical situations involving many independent plans, still achieves authoring (or implementation) scalability. While each individual plan would be coherently drawn up by an agent for its respective goal, those independently-made plans might be coincidentally intertwined in their execution. The inevitable non-determinism involved in this multi-event plan encompassing pre-planned and unforeseen events is resolved by (multi-phase) dynamic planning and articulated sequencing of events in contrast to static planning and monolithic authoring in conventional narrative systems. Connections between events are dictated by their associated rules and their actual connections are dynamically determined in execution time by current conditions of background-world. This unified connection scheme across pre-planned and unforeseen events allows a multi-plan, multi-agent situation to be coherently planned and executed in a global scale. To further the variability of a situation, the inter-event coupling is made in a fine level of action along with a limited episteme of each agent involved. We confirm analytically the viability of our approach with respect to the situation variability and authoring scalability, and demonstrate its practicality with an implementation of a composite situation.

• Nuclear Engineering and Technology
• /
• v.49 no.6
• /
• pp.1165-1171
• /
• 2017

The traditional form of parallelism in Monte Carlo particle transport simulations, wherein each individual particle history is considered a unit of work, does not lend itself well to data-level parallelism. Event-based algorithms, which were originally used for simulations on vector processors, may offer a path toward better utilizing data-level parallelism in modern computer architectures. In this study, a simple model is developed for estimating the efficiency of the event-based particle transport algorithm under two sets of assumptions. Data collected from simulations of four reactor problems using OpenMC was then used in conjunction with the models to calculate the speedup due to vectorization as a function of the size of the particle bank and the vector width. When each event type is assumed to have constant execution time, the achievable speedup is directly related to the particle bank size. We observed that the bank size generally needs to be at least 20 times greater than vector size to achieve vector efficiency greater than 90%. When the execution times for events are allowed to vary, the vector speedup is also limited by differences in the execution time for events being carried out in a single event-iteration.

• Proceedings of the Korea Society for Simulation Conference
• /
• 1998.10a
• /
• pp.124-127
• /
• 1998

One of the eventual goals of VR research is to provide valuable experiences to the participants. In this work, we view that the content of experience is composed of a sequence of events, and develop algorithms authoring those events. Event authoring can be realized by controlling agents in VE in two different modes: (1) the autonomous mode, in which the agent exhibit autonomous behaviors based on the current world status and its own personality, and (2) the event mode, in which the behaviors generated form the autonomous mode is further controlled to meet the needs of the experiment. We define the event authoring language, so that the authors can design experiments by writing event-programs. Then the architecture of event execution manager is described, which is the heart of event-program execution. prove the effectiveness of our approach by showing results of several experiments.

• Journal of KIISE:Computer Systems and Theory
• /
• v.28 no.9
• /
• pp.424-433
• /
• 2001

The cyclic debugging approach often fails for message passing parallel programs because they non-deterministic characteristics due to message race conditions. This paper identifies the MPI events that affect non-deterministic executions, and then converts the concurrent execution to the sequential one that is controlled in order to make it equivalent to a reference execution by keeping their orders of events in two executions identical. This paper also presents an efficient algorithm for the causal distributed breakpoint which is initiated by any sequential breakpoint in one process, and restores each process to the earliest state that reflects all events that happened causally before the sequential breakpoint. So a cyclic debugging approach can be used in debugging MPI parallel programs as like as in debugging sequential programming environments.

• Journal of Institute of Control, Robotics and Systems
• /
• v.17 no.11
• /
• pp.1074-1081
• /
• 2011

As robotics systems are becoming more complex there is the need to promote component based robot development, where systems can be constructed as the composition and integration of reusable building block. One of the most important challenges facing component based robot development is safeguarding against software component failures and malfunctions. The health monitoring of the robot software is most fundamental factors not only to manage system at runtime but also to analysis information of software component in design phase of the robot application. And also as a lot of monitoring events are occurred during the execution of the robot software components, a simple data treatment and efficient memory management method is required. In this paper, we propose an efficient events monitoring and data management method by modeling robot software component and monitoring factors based on robot software framework. The monitoring factors, such as component execution runtime exception, Input/Output data, execution time, checkpoint-rollback are deduced and the detail monitoring events are defined. Furthermore, we define event record and monitor record pool suitable for robot software components and propose a efficient data management method. To verify the effectiveness and usefulness of the proposed approach, a monitoring module and user interface has been implemented using OPRoS robot software framework. The proposed monitoring module can be used as monitoring tool to analysis the software components in robot design phase and plugged into self-healing system to monitor the system health status at runtime in robot systems.

• Journal of the Korea Society for Simulation
• /
• v.20 no.1
• /
• pp.87-96
• /
• 2011

DEVS(Discrete Event Systems Specification) is a set theoretic formalism developed for specifying discrete event system. For execution of DEVS, we need an execution environment, which consists of simulation engine and models interpreted by the simulation engine. Common existing environments use hierarchical scheduling algorithm for DEVS execution. This hierarchical scheduling is a proper algorithm for DEVS execution because of hierarchical and modular characteristics. But this algorithm has overheads owing to message passing and time management. To overcome these overheads, we apply event-oriented simulation to DEVS execution and we remove hierarchical overheads. In eventoriented simulation, the scheduling of model execution is performed by events and event list. We propose three event-oriented execution environments for DEVS and experiment about the performance of our proposed environments in comparison with the existing execution environment using the hierarchical scheduling. The experimental results show our environments works better than existing environment using the hierarchical scheduling.

• Journal of the Korea Institute of Information Security & Cryptology
• /
• v.28 no.6
• /
• pp.1553-1561
• /
• 2018

The source code for Android is open and easy to modify depending on the purpose. Recently, this charateristic has been exploited to bypass the runtime protection technique and extract the original executable code. Unfortunately, Android devices are so fragmented that it is difficult to verify the integrity of the system. To solve this problem, this paper proposes a technique to verify the integrity of the execution environment indirectly using the features of the application permission. Before executing the original executable code, it loads and executes the dummy DEX file to monitor for abnormal events and determine whether the system is intact. The proposed technique shows a performance overhead of about 2 seconds and shows that it can detect the bypassing technique that is currently disclosed.