Awkward Arrays in Python, C++, and Numba

The Awkward Array library has been an important tool for physics analysis in Python since September 2018. However, some interface and implementation issues have been raised in Awkward Array's first year that argue for a reimplementation in C++ and Numba. We describe those issues, the new architecture, and present some examples of how the new interface will look to users. Of particular importance is the separation of kernel functions from data structure management, which allows a C++ implementation and a Numba implementation to share kernel functions, and the algorithm that transforms record-oriented data into columnar Awkward Arrays.Comment: To be published in CHEP 2019 proceedings, EPJ Web of Conferences; post-review updat

FlexibleSUSY – a meta spectrum generator for supersymmetric models

AbstractFlexibleSUSY is a software package that takes as input descriptions of (non-)minimal supersymmetric models written in Wolfram/Mathematica and generates a set of spectrum generator libraries and executables, with the aid of SARAH. The design goals are precision, reliability, modularity, speed, and readability of the code. The boundary conditions are independent C++ objects that are plugged into the boundary value problem solver together with the model objects. This clean separation makes it easy to adapt the generated code for individual projects. The current status of the interface and implementation is sketched

JAVA Server Reliability in the Presence of Failures

A design for the separation of a server interface and work processing. Numerous sources, Tanenbaum (Tanenbaum Modern Operating Systems, 493), Goscinski (Goscinski Distributed operating systems, 203), and Birman (Birman Reliable distributed systems, 265), all discuss the concept of Two-Phase Commit, where a coordinator directs one or more processes to perform a transaction. If the transaction or any of the processes fail, the coordinator can decide how to proceed by either retrying or aborting the request. The popular web browser Chrome utilizes a separate process for each tab displayed. Should the rendering and display of a web page cause a crash, the Chrome application itself does not. The implementation leads to a search of available Java IPC (Inter-process communication) methods, presenting a review of Java IPC implementations found. The implementation of IPC using JGroups is shown, including a code example. With results showing a 36 percent reduction in memory usage and a four times improvement in receipt and storage of DICOM C-Store images

Preprocessor for C++ class implementation

A single file approach for class implementation in C++ programming language is addressed in this thesis. The objective of this thesis is to find a simple and efficient class implementation approach for C++ programming language. The current C++ class implementation named as "two files approach" has many drawbacks and also has some advantages. This thesis develops a new approach, the single file approach, which keeps the two files approach's advantages and eliminates its disadvantages. In the single file approach the developer puts all class information into one file and thus it is easier for the developer to develop only one file (canonical file) for class information. In this thesis a preprocessor program is developed to generate four different files from the canonical file, i.e. the header file and the implementation file for the compiler, and two documentation (interfaces) files for clients. These output files do not have the interface and implementation files' drawbacks of the two files approach. Also, in the single file approach the separation of class information is done automatically which saves the developer's time

UML-F: A Modeling Language for Object-Oriented Frameworks

The paper presents the essential features of a new member of the UML language family that supports working with object-oriented frameworks. This UML extension, called UML-F, allows the explicit representation of framework variation points. The paper discusses some of the relevant aspects of UML-F, which is based on standard UML extension mechanisms. A case study shows how it can be used to assist framework development. A discussion of additional tools for automating framework implementation and instantiation rounds out the paper.Comment: 22 pages, 10 figure

Towards an aspect weaving BPEL engine

This position paper proposes the use of dynamic aspects and the visitor design pattern to obtain a highly configurable and extensible BPEL engine. Using these two techniques, the core of this infrastructural software can be customised to meet new requirements and add features such as debugging, execution monitoring, or changing to another Web Service selection policy. Additionally, it can easily be extended to cope with customer-specific BPEL extensions. We propose the use of dynamic aspects not only on the engine itself but also on the workflow in order to tackle the problems of Web Service hot deployment and hot fixes to long running processes. In this way, composing aWeb Service "on-the-fly" means weaving its choreography interface into the workflow

Permission-Based Separation Logic for Multithreaded Java Programs

This paper presents a program logic for reasoning about multithreaded Java-like programs with dynamic thread creation, thread joining and reentrant object monitors. The logic is based on concurrent separation logic. It is the first detailed adaptation of concurrent separation logic to a multithreaded Java-like language. The program logic associates a unique static access permission with each heap location, ensuring exclusive write accesses and ruling out data races. Concurrent reads are supported through fractional permissions. Permissions can be transferred between threads upon thread starting, thread joining, initial monitor entrancies and final monitor exits. In order to distinguish between initial monitor entrancies and monitor reentrancies, auxiliary variables keep track of multisets of currently held monitors. Data abstraction and behavioral subtyping are facilitated through abstract predicates, which are also used to represent monitor invariants, preconditions for thread starting and postconditions for thread joining. Value-parametrized types allow to conveniently capture common strong global invariants, like static object ownership relations. The program logic is presented for a model language with Java-like classes and interfaces, the soundness of the program logic is proven, and a number of illustrative examples are presented