As IoT devices advance, their microcontroller systems-on-a-chip (SoCs) demand higher speeds, more memory, and advanced peripherals, leading to increased power consumption. Integrating low-power (LP) coprocessors in SoCs can reduce power usage while maintaining responsiveness. However, switching application execution to and from the coprocessors generally involves complex and platform-specific procedures. We propose a JIT compilation method for managed programming languages to streamline LP coprocessor use. Our prototype for the programming language mruby includes a JIT compiler and a seamless processor-switching mechanism, enabling rapid development of IoT applications leveraging LP coprocessors. This work-in-progress paper describes the design and implementation of the extended mruby interpreter and presents preliminary evaluations of its power consumption and latency on ESP32-S3 and ESP32-C6.

In this paper, we introduce a runtime monitoring method for Actor-based programs and present a Scala module that realizes the proposed method. The primary characteristic of our method is that it supports asynchronous message-passing based on the Actor model. Besides, the module does not require specialized languages for describing application properties to be monitored. Once a developer incorporates the module in his/her application, it continuously checks whether the application satisfies certain properties described as Scala code and invokes mitigation code when it finds the violation of the properties. This paper also provides two non-trivial use cases to illustrate how the module can be seamlessly integrated into actual modern Scala applications. We also demonstrate the efficiency of the module using a set of benchmarks that resulted in only 8% of the experiments causing more than 5% runtime overhead.

The primary goal of this work is to provide an easy and systematic way of developing safe soft real-time systems. To achieve this goal, we propose a method of generating real-time programs from formally verified models written as systems of timed automata. The models are verified using UPPAAL model checker prior to be processed by our code generators. A characteristic of our code generator is that the generated code runs in a non-real-time environment, i.e., a runtime environment without inherent real-time schedulers. To realize this, the code generator weaves timing checking code fragments within the generated programs. The generated code explicitly checks the real-time clock of its runtime to obey the timing constraints specified in the model. In this paper, we describe how to generate Java/C programs from UPPAAL timed automata and show the benefits of our method using a robot controller case study.

The authors are interested in the characterization of policies which are enforced by execution monitoring mechanisms with an extra structure that is an extension of Schneider's enforcement mechanism. This paper is a starting point for continuing in this area. We use an emulator as the extra structure, which emulates the behavior of a system by running a subsequence from an interleaved state sequence of processes, in order to detect several covert channels at run time. We then define a security automaton for this extended mechanism and show a class of properties which is enforced by the security automaton. Further, our mechanism can enforce information flow policies, which are specified by system developers, under an information flow property to be defined for the aim of this study. We show that the information flow property include O'Halloran's noninference. In the last of this paper, we give a simple example for the policy and an outline of our mechanism.

Computational reflection is beneficial in concurrent computing in offering a linguistic mechanism for incorporating user-specific policies. New challenges are (1) how to implement them, and (2) how to do so efficiently. We present efficient implementation schemes for object-oriented concurrent reflective languages using our language ABCL/R2 as an example. The schemes include: efficient lazy creation of metaobjects/meta-groups, partial compilation of scripts (methods), dynamic progression, self-reification, and light-weight objects, all appropriately integrated so that the user-level semantics remain consistent with the meta-circular definition so that the full power of reflection is retained, while achieving practical efficiency. ABCL/R2 exhibits two orders of magnitude speed improvement over its predecessor, ABCL/R, and in fact compares favorably to the ABCL/1 compiler and also C + Sun LWP, neither supporting reflection. 3 To be presented at ACM OOPSLA'92, Vancouver, Canada, Oct. 199...

Our work is along the line of the work of B. Smith and P. Maes. We first discuss our notion of reflection in object-oriented concurrent computation and then present a reflective object-oriented concurrent language ABCL/R. We give several illustrative examples of reflective programming such as (1) dynamic concurrent acquisition of “methods” from other objects, (2) monitoring the behavior of concurrently running objects, and (3) augmentation of the time warp mechanism to a concurrent system. Also the definition of a meta-circular interpreter of this language is given as the definition of a meta-object. The language ABCL/R has been implemented. All the examples given in this paper are running on our ABCL/R system.