{'fraction_non_alphanumeric': 0.025378632828489563, 'fraction_numerical': 0.00020466639377814163, 'mean_word_length': 5.568548387096774, 'pattern_counts': {'":': 0, '<': 0, '<?xml version=': 0, '>': 0, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Unified Execution Environment

The design and development of new system software for HPC (both operating systems and run-times) face multiple challenges, including scalability (high level of parallelism), efficiency, resiliency, and dynamicity. Guided by these fundamental design principles, we advocate for a unified execution environment, which aims at being scalable, asynchronous, dynamic, resource efficient, and reusable. The proposed solution is based on the following core building blocks, (i) events, (ii) agents, and (iii) enclaves. We use these building blocks to support composable environments that may be tailored to combine appropriate system services as well as user jobs. Additionally, for resilience and scalability the proposed design encourages localized or regional operations to foster autonomy of execution contexts. We advocate this approach for exascale systems, which include a massive number of heterogeneous computing resources, since it enables architecturally informed structures (topologies) as well as encouraging efficient grouping of functionality/services. Events trigger notifications and interactions inside the system. This enables the implementation of asynchronous capabilities and therefore improves scalability of the system. In order to support a wide range of interactions between system entities, multiple event types are included: real time (time bounded delivery), standard (delivery guaranteed without any time constraint), and optional (event can be dropped). These different types of events also limit the risk of overflowing the event system when many events are triggered simultaneously. The event system also implements a progress model to ensure that events are dispatched and delivered correctly, and be used to throttle events to avoid overload. Agents instantiate system services as well as user applications. This composition promotes a more efficient allocation of resources due to the fact that applications and system services are combined into a single entity that may work more tightly on resource utilization, etc. Agents also include the concept of contract. A contract involves the definition of common interfaces and contextual properties or dependencies [4]. These additional dependencies allow common interfaces to be supplemented for specialization to take advantage of unique capabilities in an underlying implementation. For instance, it is possible to define a specific agent for the management of memory that guarantees reliability. In fact, based on the underlying hardware, this agent could implement replication techniques or simply rely only on the hardware. This also enables the definition of system services that support varied levels of service guarantees (reliability), which ultimately facilitate scalability and resiliency. Finally, a system library can be used either to implement new tools, run-times, system services or even applications (unified system), or encapsulate existing software. Because agent setup is based on input from the user, resource manager, job scheduler, and even compilers, it enables the optimization of resource allocation for the system services required for the execution of a given job, as well as the deployment of new system services that assist running applications (for instance, a system service could be deployed to enable background compression of application data). Enclaves are the last key concept. An enclave is a logical group of agents that have tight interactions. An enclave is designed to be light-weight (low system footprint), sparse, and dynamic (a enclave can dynamically grow and shrink). Each enclave instantiate its own event engine, which is used for interactions between agents in the same enclave. They also support a simple event API for inter-enclave interactions, such as dynamic agent management between enclaves (i.e., agent migration). Enclaves can also be organized hierarchically to manage multiple enclaves without limiting the scalability of the overall system. Finally, default enclaves are setup based on the hardware characteristics and the overall system configuration. For instance, service nodes could host a I/O enclave. As a result, enclaves are the basic objects used for the deployment of the composition representing a user job; agents being the low-level instantiation of the execution contexts representing the job, as well as the required system services. Ultimately the proposed solution provides a unified execution environment which aims at: (i) ease scalability at extreme scale by incorporating the locality constraints directly into the key system services, as well as using only sparse representations of system objects and using asynchronous operations; (ii) ease fault tolerance by avoiding any central point of failure and abstracting all execution contexts and any global synchronization or notification in the