Petri nets are a powerful formalism for modeling and analyzing concurrent, distributed, and complex systems. However, extensions that enable greater representative capabilities (e.g., coloured Petri nets) include significant complexities beyond elementary Petri nets or even Turing complete Petri nets with inhibitor arcs. Currently, there is a lack of free and open-source Petri net tools that are both maintained and free of the complications of coloured Petri nets. In this paper we present a free and open-source Petri net editor and simulator, MyPetri.net, that provides a modern web-based editor for Petri nets and several modes of execution or simulation. While more complex editors offer formal verification methods, our approach introduces a unit testing-like framework that allows users to set and verify place values after execution, similar to traditional software testing. Finally, we present an informal discussion on the impact of the MyPetrinet tool in the classroom.

A self-adaptive system (SAS) is capable of modifying its behavior at run-time to address uncertainty. For games, these self-adaptations can present a more dynamic experience (e.g., changing difficulty, optimizing performance), thereby enabling run-time updates to mitigate potential issues experienced during gameplay. For example, a self-adaptation may result in emergent behaviors that keep the player engaged or optimize performance to support a multitude of device configurations. Notably, games that leverage a run-time feedback loop have previously demonstrated success in optimizing a game's frame rate. However, multi-agent systems that incorporate self-adaptation remain largely unexplored in the video games domain. This paper demonstrates a novel approach for using multiple goal models with competing metrics for expressing optimal behavior in balancing and mitigating video game uncertainties. To support this goal, we adapt an existing browser-based game to a new framework that incorporates two distinct self-adaptive agents with potentially competing objectives.

In this paper we present a framework for branch-and-bound algorithms to separate problem specific logic and branch-and-bound implementation from the core branch-and-bound algorithm. By isolating the problem-specific logic and paradigm-specific branch-and-bound implementation via two instances of the Template Method design pattern, we simplify parallelizing branch-and-bound algorithms and allow multiple execution paradigms. Specifically, our framework includes multiple branch-and-bound algorithm implementations that can execute problem specific logic sequentially, in parallel via distribution of each node in the search tree (e.g., a single ’task’), or in parallel via execution of multiple ’tasks’ before distribution. Each implementation paradigm can employ the same problem-specific operations. Problematically, branch-and-bound algorithms are difficult to parallelize due to both the fine-grained nature of each ’task,’ and the uneven distribution in the search tree requiring re-balancing of workloads. Our approach allows low-effort changes between parallelization strategies that can operate on the same problem-specific implementations enabling significant speedups on a variety of problems. Our proof-of-concept framework is assessed across a variety of branch-and-bound algorithms for different problems to demonstrate its effectiveness.

Two new algorithms are presented to find all the maximal cliques in an undirected graph. The algorithms are not recursive and they have been designed to take advantage of the large number of cores available in Graphical Processing Units (GPUs). The proposed algorithm evaluates all elements of the Power Set of the set of vertices, in other words, all the possible subsets of the set of vertices and finds for each of them, in parallel, if that particular subset is a clique. Once all cliques have been found, the cliques that are not maximal are eliminated. The algorithms differ in the way the non-maximal cliques are discarded. In one version, as soon as one subset of vertices has been identified as being a clique, the code checks if this is a maximal clique. In the other version, all the cliques are brought to the host computer and the cliques that are subsets of other cliques are discarded. Prototype implementations have been written using Thrust. Results of experiments are included. The code can be easily adapted to solve the dual problem of the maximal cliques problem: The maximal independent sets problem.

Internet of Things (IoT) applications can comprise heterogeneous components that are responsible for delivering a quality of service that ideally supports the objectives of the system as a whole. However, individual components may have competing objectives with other components, be improperly implemented, and/or experience uncertainty that impacts the overall quality of service. Run-time modeling of such systems provides an approach for quantifying objective success, however distributing the outputs of such models in a peer-to-peer environment is nontrivial given the constraints of IoT environments. This paper presents a proof-of-concept framework for managing adaptive P2P networks using goal-based modeling techniques and fuzzy logic operators to enable run-time flexibility in goal satisfaction and describes challenges to overcome.

Voronoi diagrams are used in numerous fields from Biology and Medicine to Geography and Cartography. The wide variety of uses of Voronoi diagrams across this disparate fields requires computationally efficient algorithms. While existing Divide-and-Conquer methods prevent unnecessary computations for sub-problems that are all within the same region, the computational cost of continuing to sub-divide problems in degenerate cases is higher. In this paper, we propose a hybrid of the Divide-and-Conquer method and the naive approach for discretized Voronoi diagrams. We present the original and updated algorithms and a variety of comparisons on computational costs.

Voronoi diagrams are used in a wide range of applications, and many of those applications are in three dimensional space. Two important benchmarks you can measure for Voronoi solver algorithms are run time and memory usage. Run time is important due to the potential costs of computation, and memory usage allows for larger areas to be analyzed. Run time can be addressed via parallelization, but memory usage is dependent on data structure. In this paper we compare the run time and memory usage of a previously published 3D Voronoi solver implementation that utilized an array data structure with a new novel implementation that utilizes an oct-tree data structure.

Verifying system behavior before deployment is a necessity, especially with self-adaptive software. However, exhaustive verification is impractical due to both the scale of the input/output space and uncertainties that may not be captured in pre-deployment testing. Run-time monitors have been used to measure operational health after deployment but are unlikely to have a one-to-one correspondence with pre-deployment testing. Problematically, adaptation strategies can be defined for managing adverse run-time measurements due to runtime monitors, however, it is infeasible to provide adaptation triggers for untested behaviors with only static pre-deployment tests. This paper introduces contextual metamorphic relations that are applicable to specific contexts of a system’s behavior and implementation artifacts. These contextual metamorphic relations are a subset of general metamorphic relations and can be used for both pre-deployment testing and post-deployment run-time monitoring to trigger context specific adaptations in order to improve tolerance to specific faults. We illustrate our approach by triggering adaptation at run-time using contextual metamorphic relations for two real-world inspired responsive cyber-physical systems: a robotic drone system and a set of proximity-enabled responsive systems.

While computing Voronoi diagrams are used in a wide variety of domains and applications, comparisons are often based on different algorithms implemented in the same programming language. However, while various algorithms have different tradeoffs, the language used to implement a single algorithm can have an effect on the overall computational time required to compute a Voronoi diagram. In this paper, we compare several different languages (Julia, Java, Python with Numba, and C++) to determine the impact of language choice. We present comparisons of timing data across these languages for a variety of inputs.

Safety-critical systems, such as drones, are vulnerable to effects of uncertainty, where uncertainty can manifest as adverse weather conditions, unexpected human interactions, and misconfigured system settings. Moreover, it is humanly infeasible to test for all possible combinations of conditions that a system may experience through its lifetime during design. Additionally, drones are difficult to exhaustively test prior to deployment as real-world validation is costly in terms of time and equipment. Search-based testing is an approach for discovering new situations that a system may experience, however such tests can suffer from automatically inferring incorrect expected values/outcomes without domain knowledge (i.e., the oracle problem). As such, we propose a metamorphic testing framework for software-defined drone systems that uses exploratory search and aims to minimize the oracle problem at both design time and run time. We demonstrate our framework through a motivating example that illustrates each step of the process.

Calculating Voronoi diagrams quickly is useful across a range of fields and application areas. However, existing divide-and-conquer methods decompose into squares while boundaries between Voronoi diagram regions are often not perfectly horizontal or vertical. In this paper we introduce a novel method of dividing Approximate Voronoi Diagram spaces into triangles stored by quadtree data structures. While our implementation stores the resulting Voronoi diagram in a data structure, rather than setting each approximated point to its closest region, we provide a comparison of the decomposition time alone.

Self-adaptive systems (SAS) can reconfigure at run time in response to changing situations to express acceptable behaviors in the face of uncertainty. With respect to game design, such situations may include user input, emergent behaviors, performance concerns, and combinations thereof. Typically an SAS is modeled as a feedback loop that functions within an existing system, with operations including monitoring, analyzing, planning, and executing (i.e., MAPE-K) to enable online reconfiguration. This paper presents a conceptual approach for extending software engineering artifacts to be self-adaptive within the context of game design. We have modified a game developed for creative coding education to include a MAPE-K self-adaptive feedback loop, comprising run-time adaptation capabilities and the software artifacts required to support adaptation.

Identifying appropriate tests for software systems is necessary to ensure adherence to behavioral specifications. However, existing approaches to measure test quality (e.g., code or path coverage metrics) are predicated on a fixed set of tests that may not exercise faults in the software. Worse, flawless measures of test quality (e.g., 100% code coverage) do not ensure faults in the software are exercised. Metamorphic relationships enable search-based methods to automatically identify software faults. In this paper we employ metamorphic relationships to automatically identify a diverse set of tests using evolutionary computation. We apply our automatic test generation method on a portion of an open-source game engine (Godot), rather than a contrived example and discover unexpected behavior.

When utilizing multi-robot systems or sensors in a sensor network it is necessary to ensure communication between the individual robots or sensors. Problematically, communication methods are often limited in transmission distance and sensors can only measure the environment with some finite range. However, existing methods of dividing space (e.g., Voronoi diagrams) do not take into account the transmission or sensing distance limitations. In this paper we utilize genetic algorithms to divide space in a sensor network or robotic system environment, similar to the facility location problem. We discuss implications for planning travel to optimal locations for a set of communicating robotic systems.

A common task in search-based testing is automatically identifying valuable test cases for software systems. However, existing approaches tend to either search for unique tests with regard to inputs or outputs (i.e., novelty search) or search for inputs that invalidate some expected proposition regarding the software (i.e., metamorphic testing). Problematically, verifying unique tests induces the oracle problem while an invalidated proposition results in a single test case. In this paper we utilize novelty search and metamorphic testing to discover a broad range of unique test cases that are directly verifiable via a metamorphic relation and invalidate such an expected proposition in fewer generations of an evolutionary algorithm than direct search. We apply this novelty search and metamorphic testing combination to discover errors in identifying the midpoint of a geodesic as a proof-of-concept.