Version Of Compiler Research Articles

Particle Swarm Algorithm for Smart Contract Vulnerability Detection Based on Semantic Web

In recent years, smart contracts have risen rapidly in the blockchain field, but security issues have also become increasingly prominent. Due to the lack of unified evaluation standards, the security analysis of smart contracts mainly relies on complex and not easily scalable expert rules. To address these issues, we employ slicing techniques to reduce the interference of extraneous code on the detection process, apply normalisation techniques to eliminate the differences between different compiler versions and use particle swarm optimisation algorithms to determine the similarity between contracts, thus improving the accuracy and efficiency of detection. In addition, we combine a variety of features such as static analysis, dynamic analysis and symbolic execution to gain a more comprehensive understanding of contract characteristics and behaviours for more accurate vulnerability identification. Experimental results show that the scheme significantly improves the detection capability and provides a new solution for the security detection of smart contracts.

Function-Level Compilation Provenance Identification with Multi-Faceted Neural Feature Distillation and Fusion

In the landscape of software development, the selection of compilation tools and settings plays a pivotal role in the creation of executable binaries. This diversity, while beneficial, introduces significant challenges for reverse engineers and security analysts in deciphering the compilation provenance of binary code. To this end, we present MulCPI, short for Multi-representation Fusion-based Compilation Provenance Identification, which integrates the features collected from multiple distinct intermediate representations of the binary code for better discernment of the fine-grained function-level compilation details. In particular, we devise a novel graph-oriented neural encoder improved upon the gated graph neural network by subtly introducing an attention mechanism into the neighborhood nodes’ information aggregation computation, in order to better distill the more informative features from the attributed control flow graph. By further integrating the features collected from the normalized assembly sequence with an advanced Transformer encoder, MulCPI is capable of capturing a more comprehensive set of features manifesting the multi-faceted lexical, syntactic, and structural insights of the binary code. Extensive evaluation on a public dataset comprising 854,858 unique functions demonstrates that MulCPI exceeds the performance of current leading methods in identifying the compiler family, optimization level, compiler version, and the combination of compilation settings. It achieves average accuracy rates of 99.3%, 96.4%, 90.7%, and 85.3% on these tasks, respectively. Additionally, an ablation study highlights the significance of MulCPI’s core designs, validating the efficiency of the proposed attention-enhanced gated graph neural network encoder and the advantages of incorporating multiple code representations.

Access to struct members and undefined behavior of C code

During software development, novice developers usually receive a lot of error messages and just warnings of various kinds. And if the code simply won't run when there are errors, then the program usually starts when there are various warnings. And here it is important to understand what consequences the presence of warnings of various kinds can lead to. This work aims to study the code's undefined behavior when working with struc-tures in the C programming language when issuing a corresponding compiler warn-ing about returning the address of a local or temporary variable. In the procedural programming language C, there is an ancestor of the OOP class — the structure struct, which encapsulates only the state of the entity. And the question arises — is it possible to work with separate components-fields of such a structure analogously to OOP languages? For research, a simple structure was taken, which contains information about the person's name, surname, and phone number. To access parts of the structure, pseudogetters were used — functions that returned a pointer to the corresponding part of the structure. The research was conducted in the Visual Studio 2019 environment under the control of the Windows 10 operating system when the default C language standard - MSVC and the more modern ISO standard C17 (2018) was selected in the project settings. As a result, a truly undefined behavior of the code was obtained, when the re-sult of the work of the code fragment (function call) depends on many factors: the length of the array, the standard of the C language, the position of a certain part in the structure. An attempt to conduct similar research under the control of the Linux Mint oper-ating system using the gcc compiler version 5.4 was unsuccessful. When compiling the code, a similar warning about returning the address of a local variable was also issued, as in the case of Visual Studio. But when the program was launched, it sim-ply crashed with a message about a segmentation error. Thus, both the Visual Studio 2019 compiler and the gcc compiler warned us about undefined code behavior. But this uncertain behavior was radically different for operating systems and compilers. If after gcc under the Linux OS, the code simply does not work at all and the program stops its work with a segmentation error mes-sage, then after Visual Studio under Windows, inexperienced developers with im-proper testing and verification of the code can miss the code that "does not always work", which can lead to unexpected results, not always pleasant, to say the least. And that's why software developers, especially beginners, should pay attention not only to compilation errors but also to warnings, even if the code works.

Assessing the Impact of Compiler Optimizations on GPUs Reliability

Graphics Processing Units (GPUs) compilers have evolved in order to support general-purpose programming languages for multiple architectures. NVIDIA CUDA Compiler (NVCC) has many compilation levels before generating the machine code and applies complex optimizations to improve performance. These optimizations modify how the software is mapped in the underlying hardware; thus, as we show in this article, they can also affect GPU reliability. We evaluate the effects on the GPU error rate of the optimization flags applied at the NVCC Parallel Thread Execution (PTX) compiling phase by analyzing two NVIDIA GPU architectures (Kepler and Volta) and two compiler versions (NVCC 10.2 and 11.3). We compare and combine fault propagation analysis based on software fault injection, hardware utilization distribution obtained with application-level profiling, and machine instructions radiation-induced error rate measured with beam experiments. We consider eight different workloads and 144 combinations of compilation flags, and we show that optimizations can impact the GPUs’ error rate of up to an order of magnitude. Additionally, through accelerated neutron beam experiments on a NVIDIA Kepler GPU, we show that the error rate of the unoptimized GEMM (-O0 flag) is lower than the optimized GEMM’s (-O3 flag) error rate. When the performance is evaluated together with the error rate, we show that the most optimized versions (-O1 and -O3) always produce a higher amount of correct data than the unoptimized code (-O0).

DRcipher: A pseudo-random dynamic round lightweight block cipher

The Internet of Things (IoT) has gained popularity in various fields, including components such as embedded devices and wireless sensors. However, ensuring the security of data transmission from these devices is of critical importance. In light of these challenges, a novel lightweight encryption method called DRcipher is proposed in this paper for resource-constrained IoT devices. DRcipher has a 64-bit block size and supports either 96-bit or 128-bit key sizes. In order to improve the security, DRcipher employs a pseudo-random number of encryption rounds determined by the primary key. DRcipher adopts the structure of Generalized Feistel Network (GFN) with 4 branches, and its round functions consist of F-function, FF-function and RP permutation components. In particular, there is a negative feedback mechanism between the FF-function and the overall round of encryption functions. In addition, DRcipher is synthesised using Synopsys Design Compiler version A-2007.12-SP1 and the UMCL18G212T3 standard cell library. DRcipher-96 has an area footprint of 1546 Gate Equivalents (GE), while DRcipher-128 has a slightly larger area footprint of 1646 GE. Moreover, a comprehensive security analysis shows that the proposed DRcipher ensures high-level security redundancy against differential cryptanalysis, linear cryptanalysis, and so on.

HPC-driven computational reproducibility in numerical relativity codes: a use case study with IllinoisGRMHD

Reproducibility of results is a cornerstone of the scientific method. Scientific computing encounters two challenges when aiming for this goal. Firstly, reproducibility should not depend on details of the runtime environment, such as the compiler version or computing environment, so results are verifiable by third-parties. Secondly, different versions of software code executed in the same runtime environment should produce consistent numerical results for physical quantities. In this manuscript, we test the feasibility of reproducing scientific results obtained using the IllinoisGRMHD code that is part of an open-source community software for simulation in relativistic astrophysics, the Einstein Toolkit. We verify that numerical results of simulating a single isolated neutron star with IllinoisGRMHD can be reproduced, and compare them to results reported by the code authors in 2015. We use two different supercomputers: Expanse at SDSC, and Stampede2 at TACC. By compiling the source code archived along with the paper on both Expanse and Stampede2, we find that IllinoisGRMHD reproduces results published in its announcement paper up to errors comparable to round-off level changes in initial data parameters. We also verify that a current version of IllinoisGRMHD reproduces these results once we account for bug fixes which have occurred since the original publication.

MSTor 2023: A new version of the computer code for multistructural torsional anharmonicity, now with automatic torsional identification using redundant internal coordinates

The MSTor program is a computer program for calculating partition functions and thermodynamic functions of complex gas-phase molecules with multiple torsions; the multi-structural approximation with torsional anharmonicity (MS-T) can be used based on either a coupled torsional potential or an uncoupled torsional potential. The program can also carry out calculations in the multiple-structure local harmonic (MS-LH) approximation or multi-structural local quasiharmonic (MS-LQ) approximation or by the dual-level MS-T method. Furthermore, the program package includes eight utility codes that can be used as stand-alone programs to help the user to generate the input files for the code or to generate comparison results. The 2023 version of MSTor includes a new capability, namely automatic identification of torsional modes with redundant internal coordinates. New version program summaryProgram title: MSTor 2023CPC Library link to program files:https://doi.org/10.17632/t4y5wds856.1Licensing provisions: Apache 2.0Programming language: Fortran 90, C, and PerlJournal references of previous versions: Comput. Phys. Comm. 183 (2012) 1803; Comput. Phys. Comm. 184 (2013) 2032Does the new version supersede the previous version?: Yes.Nature of problem: Calculation of the partition functions and thermodynamic functions (standard-state energy, enthalpy, entropy, and free energy as functions of temperature) of molecules or transition states involving multiple torsional motions.Solution method: The program uses the multi-structural approximation with torsional anharmonicity, a coupled torsional potential, and delocalized torsions MS-T(CD) [1]. The program also provides results for the multi-structural local harmonic approximation or local quasiharmonic approximation, and it can also be used for the original multi-structural approximation with torsional anharmonicity and a coupled torsional potential MS-T(C) [2] or an uncoupled torsional potential MS-T(U) [3]. The program can also carry out dual-level [4] MS-T(CD), MS-T(C), and MS-T(U) calculations.Reasons for new version: The new version increases functionality and is more user friendly. The main enhancement is the capability for automatic identification of torsional modes with redundant internal coordinates.Summary of revisions: A newly developed torsional identification approach for complex molecules has been implemented in the MSTor program. The method, called multi-structural torsion method with a coupled torsional potential and delocalized torsions MS-T(CD), is based on Baker et al.'s delocalized internal-coordinates method and on Zheng and Truhlar's torsional projection method. By using a redundant-internal-coordinate auto-generation procedure, the MS-T(CD) method circumvents the need in the original MS-T method for the user to define nonredundant internal coordinates, and it can straightforwardly identify and separate the coupled torsions from the Cartesian Hessian. This greatly simplifies the user input, and it helps users to obtain robust and consistent results. MSTor now sets the redundant internal coordinate scheme as the default method.A new utility code, DLMSTor.exe, is provided to allow dual-level calculations. The $framechain and $framedef sections were reintroduced to the code as optional sections. If these sections are used, the D matrix is calculated using the scheme of Kilpatrick and Pitzer and one should always get correct values for the moments of inertia.Various utility codes were modified to help ensure that structures that are equivalent under rotation to other structures (and thus indistinguishable when considering overall rotation and torsions) are still properly included in the Voronoi tessellation step (which does not fully exploit overall rotational symmetry).The mcvorm.exe utility code was modified to correctly calculate uncertainties and to take advantage of rotational symmetries (at least for linear-chain molecules) and mirror-image symmetries, if present, in the calculation of the uncertainty estimates.We added a new keyword, MTUMME, that provides an option to write a density-of-states file for version 2023 (in preparation) of the TUMME [5] master equation program.Some minor bugs are fixed so the code now compiles properly with the GNU gfortran compiler (version 12.2.1), the NVidia HPC Fortran compiler pgfortran (version 21.3), and the Intel compiler ifort. The output format is cleaned, and unused variables and arrays are removed. The new version has an increased number of test runs, and the manual is improved and updated.The program authors are J. Zheng, W. Chen, S. L. Mielke, J. L. Bao, R. Meana-Pañeda, K. L. Clarkson, X. Xu, and D. G. Truhlar; the new version announcement authors are W. Chen, J. Zheng, J. L. Bao, D. G. Truhlar, and X. Xu; the primary corresponding author is X. Xu.

Training PPA Models for Embedded Memories on a Low-data Diet

Supervised machine learning requires large amounts of labeled data for training. In power, performance, and area (PPA) estimation of embedded memories, every new memory compiler version is considered independently of previous compiler versions. Since the data of different memory compilers originate from similar domains, transfer learning may reduce the amount of supervised data required by pre-training PPA estimation neural networks on related domains. We show that provisioning times of PPA models for new compiler versions can be reduced significantly by exploiting similarities among different compilers, versions, and technology nodes. Through transfer learning, we shorten the time to provision PPA models for new compiler versions, which speeds up time-critical periods of the design cycle. Using only 901 training samples (10%) is sufficient to achieve an almost worst-case (98th percentile) estimation error of 2.67% and allows us to shorten model provisioning times from 40 days to less than one week without sacrificing accuracy. To enable a diverse set of source domains for transfer learning, we devise a new, application-independent method for overcoming structural domain differences through domain equalization that attains competitive results when compared to domain-free transfer. A high degree of automation necessitates the efficient assessment of the best source domains. We propose using various metrics to accurately identify four of the five best among 45 datasets with low computational effort.

Performance Assessment of Using Docker for Selected MPI Applications in a Parallel Environment Based on Commodity Hardware

In the paper, we perform detailed performance analysis of three parallel MPI applications run in a parallel environment based on commodity hardware, using Docker and bare-metal configurations. The testbed applications are representative of the most typical parallel processing paradigms: master–slave, geometric Single Program Multiple Data (SPMD) as well as divide-and-conquer and feature characteristic computational and communication schemes. We perform analysis selecting best configurations considering various optimization flags for the applications and best execution times and speed-ups in terms of the number of nodes and overhead of the virtualized environment. We have concluded that for the configurations giving the shortest execution times the overheads of Docker versus bare-metal for the applications are as follows: 7.59% for master–slave run using 64 processes (number of physical cores), 15.30% for geometric SPMD run using 128 processes (number of logical cores) and 13.29% for divide-and-conquer run using 256 processes. Finally, we compare results obtained using gcc V9 and V7 compiler versions.

Accidental Choices—How JVM Choice and Associated Build Tools Affect Interpreter Performance

Considering the large number of optimisation techniques that have been integrated into the design of the Java Virtual Machine (JVM) over the last three decades, the Java interpreter continues to persist as a significant bottleneck in the performance of bytecode execution. This paper examines the relationship between Java Runtime Environment (JRE) performance concerning the interpreted execution of Java bytecode and the effect modern compiler selection and integration within the JRE build toolchain has on that performance. We undertook this evaluation relative to a contemporary benchmark suite of application workloads, the Renaissance Benchmark Suite. Our results show that the choice of GNU GCC compiler version used within the JRE build toolchain statistically significantly affects runtime performance. More importantly, not all OpenJDK releases and JRE JVM interpreters are equal. Our results show that OpenJDK JVM interpreter performance is associated with benchmark workload. In addition, in some cases, rolling back to an earlier OpenJDK version and using a more recent GNU GCC compiler within the build toolchain of the JRE can significantly positively impact JRE performance.

Bytecode Similarity Detection of Smart Contract across Optimization Options and Compiler Versions Based on Triplet Network

In recent years, the number of smart contracts running in the blockchain has increased rapidly, accompanied by many security problems, such as vulnerability propagation caused by code reuse or vicious transaction caused by malicious contract deployment, for example. Most smart contracts do not publish the source code, but only the bytecode. Based on the research of bytecode similarity of smart contract, smart contract upgrade, vulnerability search and malicious contract analysis can be carried out. The difficulty of bytecode similarity research is that different compilation versions and optimization options lead to the diversification of bytecode of the same source code. This paper presents a solution, including a series of methods to measure the similarity of smart contract bytecode. Starting from the opcode of smart contract, a method of pre-training the basic block sequence of smart contract is proposed, which can embed the basic block vector. Positive samples were obtained by basic block marking, and the negative sampling method is improved. After these works, we put the obtained positive samples, negative samples and basic blocks themselves into the triplet network composed of transformers. Our solution can obtain evaluation results with an accuracy of 97.8%, so that the basic block sequence of optimized and unoptimized options can be transformed into each other. At the same time, the instructions are normalized, and the order of compiled version instructions is normalized. Experiments show that our solution can effectively reduce the bytecode difference caused by optimization options and compiler version, and improve the accuracy by 1.4% compared with the existing work. We provide a data set covering 64 currently used Solidity compilers, including one million basic block pairs extracted from them.

PenRed: An extensible and parallel Monte-Carlo framework for radiation transport based on PENELOPE

Monte Carlo methods provide detailed and accurate results for radiation transport simulations. Unfortunately, the high computational cost of these methods limits its usage in real-time applications. Moreover, existing computer codes do not provide a methodology for adapting these kinds of simulations to specific problems without advanced knowledge of the corresponding code system, and this restricts their applicability. To help solve these current limitations, we present PenRed, a general-purpose, stand-alone, extensible and modular framework code based on PENELOPE for parallel Monte Carlo simulations of electron-photon transport through matter. It has been implemented in C++ programming language and takes advantage of modern object-oriented technologies. In addition, PenRed offers the capability to read and process DICOM images as well as to construct and simulate image-based voxelized geometries, so as to facilitate its usage in medical applications. Our framework has been successfully verified against the original PENELOPE Fortran code. Furthermore, the implemented parallelism has been tested showing a significant improvement in the simulation time without any loss in precision of results. Program summaryProgram title: PenRed: Parallel Engine for Radiation Energy Deposition.CPC Library link to program files:https://doi.org/10.17632/rkw6tvtngy.1Licensing provision: GNU Affero General Public License (AGPL).Programming language: C++ standard 2011.Nature of problem: Monte Carlo simulations usually require a huge amount of computation time to achieve low statistical uncertainties. In addition, many applications necessitate particular characteristics or the extraction of specific quantities from the simulation. However, most available Monte Carlo codes do not provide an efficient parallel and truly modular structure which allows users to easily customise their code to suit their needs without an in-depth knowledge of the code system.Solution method: PenRed is a fully parallel, modular and customizable framework for Monte Carlo simulations of the passage of radiation through matter. It is based on the PENELOPE [1] code system, from which inherits its unique physics models and tracking algorithms for charged particles. PenRed has been coded in C++ following an object-oriented programming paradigm restricted to the C++11 standard. Our engine implements parallelism via a double approach: on the one hand, by using standard C++ threads for shared memory, improving the access and usage of the memory, and, on the other hand, via the MPI standard for distributed memory infrastructures. Notice that both kinds of parallelism can be combined together in the same simulation. Moreover, both threads and MPI processes, can be balanced using the builtin load balance system (RUPER-LB [30]) to maximise the performance on heterogeneous infrastructures. In addition, PenRed provides a modular structure with methods designed to easily extend its functionality. Thus, users can create their own independent modules to adapt our engine to their needs without changing the original modules. Furthermore, user extensions will take advantage of the builtin parallelism without any extra effort or knowledge of parallel programming.Additional comments including restrictions and unusual features: PenRed has been compiled in linux systems with g++ of GCC versions 4.8.5, 7.3.1, 8.3.1 and 9; clang version 3.4.2 and intel C++ compiler (icc) version 19.0.5.281. Since it is a C++11-standard compliant code, PenRed should be able to compile with any compiler with C++11 support. In addition, if the code is compiled without MPI support, it does not require any non standard library. To enable MPI capabilities, the user needs to install whatever available MPI implementation, such as openMPI [24] or mpich [25], which can be found in the repositories of any linux distribution. Finally, to provide DICOM processing support, PenRed can be optionally compiled using the dicom toolkit (dcmtk) [32] library. Thus, PenRed has only two optional dependencies, an MPI implementation and the dcmtk library.

Fine-Grained Compiler Identification With Sequence-Oriented Neural Modeling

Different compilers and optimization levels can be used to compile the source code. Revealed in reverse from the produced binaries, these compiler details facilitate essential binary analysis tasks, such as malware analysis and software forensics. Most existing approaches adopt a signature matching based or machine learning based strategy to identify the compiler details, showing limits in either the detection accuracy or granularity. In this work, we propose NeuralCI (Neural modeling-based Compiler Identification) to infer these compiler details including compiler family, optimization level and compiler version on individual functions. The basic idea is to formulate sequence-oriented neural networks to process normalized instruction sequences generated using a lightweight function abstraction strategy. To evaluate the performance of NeuralCI, a large dataset consisting of 854,858 unique functions collected from 19 widely used real-world projects is constructed. The experiments show that NeuralCI achieves averagely 98.6% accuracy in identifying the compiler family, 95.3% accuracy in identifying the optimization level, 88.7% accuracy in identifying the compiler version, 94.8% accuracy in identifying the compiler family and optimization level, and 83.0% accuracy in identifying all compiler components simultaneously, outperforming existing function level compiler identification methods in terms of both detection accuracy and comprehensiveness.

Разработка компилятора для стековой процессорной архитектуры TF16 на основе LLVM

Development for stack-based architectures is usually done using legacy low level languages or assembly code, so there exists a problem of a high level programming language support for such architectures. In this paper we describe the development process of an LLVM/Clang-based C compiler for stack-based TF16 processor architecture. LLVM was used due to adaptation possibilities of its components for new architectures, such as disassembler, linker and debugger. Two compiler versions were developed. The first version generated code without using stack capabilities of TF16, treating it instead as a register-based architecture. This version was relatively easy to develop and it provided us a comparison point for the second one. In the second version we have implemented a platform independent stack scheduling algorithm that allowed us to generate code that makes use of the stack capabilities of the CPU. When comparing the two versions, a version that utilized stack capabilities generated code that was on average 35.7% faster and 50.8% smaller than the original version. The developed stack scheduling algorithm also allows to support other stack based architectures in LLVM toolchain.

Using OpenMP for HEP framework algorithm scheduling

The OpenMP standard is the primary mechanism used at high performance computing facilities to allow intra-process parallelization. In contrast, many HEP specific software packages (such as CMSSW, GaudiHive, and ROOT) make use of Intel’s Threading Building Blocks (TBB) library to accomplish the same goal. In these proceedings we will discuss our work to compare TBB and OpenMP when used for scheduling algorithms to be run by a HEP style data processing framework. This includes both scheduling of different interdependent algorithms to be run concurrently as well as scheduling concurrent work within one algorithm. As part of the discussion we present an overview of the OpenMP threading model. We also explain how we used OpenMP when creating a simplified HEP-like processing framework. Using that simplified framework, and a similar one written using TBB, we will present performance comparisons between TBB and different compiler versions of OpenMP.

A Novel Design of Mealy Machine Equivalence in Vlsi Technology

In this paper begin of a Novel Design of Mealy Machine Equivalence in VLSI Technology. The pattern in structure and assembling of extremely huge scale incorporated circuit shows a progressing move towards littler gadgets on expanding wafer measurements. CMOS has become a common innovation because of its rapid and pressing thickness combined with low power utilization. New advances have risen to additionally expand circuit speed and to lessen structure and innovation limitations. Models are joined bipolar-CMOS (BICMOS) and CMOS in silicon on the cover (SOI). Other than the mass delivered standard chips exclusively custom-fitted application explicit IC (ASICs) and framework approaches with on-chip coordinated sensors or high power actuators gain significance. These improvements present difficulties in the progression of pillar testing techniques, for example, rapid or high spatial goals on 200 mm width wafers. We have mapped this paper to the Mealy machine equivalence Verilog HDL Code in the Xilinx Vivado Compiler Version v2014.2 (64-bit) and find the Power, utilization report, and Area, Power in Table One, utilization report in Table Two and Area in Table Three.

Coloured Algebras and Biological Response in Quantum Biological Computing Architectures

This paper reports about progress in two areas towards quantum computing architectures with elements inspired from biological controls, as proposed in an earlier paper. The first area is about exploiting mathematical results in coloured algebras, which, combined with the colouring of particle flows, would reduce the decoherence and enhance the decidability in the quantum processing elements; definitions are being recalled, with the required assumptions and results. The second area is to provide experimental results, and a patented biological feedback process in synapse , about light and acoustic excitations in a live animal species to enhance reactivity; the experimental set-up is characterized , the measurement results provided, and the implications are explicated for quantum processing elements approximating a synapse. A paragraph on open issues explains how the results in the two areas will be combined and will help in the design a very early compiler version.

Ongoing solution reproducibility of earth system models as they progress toward exascale computing

We present a methodology for solution reproducibility for the Energy Exascale Earth System Model during its ongoing software infrastructure development to prepare for exascale computers. The nonlinear chaotic nature of climate system simulations precludes traditional model verification approaches since machine precision differences—resulting from code refactoring, changes in software environment, and so on—grow exponentially to a different weather state. Here, we leverage the nature of climate as a statistical description of the atmosphere in order to establish model reproducibility. We evaluate the degree to which two-sample equality of distribution tests can confidently detect the change in climate from minor tuning parameter changes on model output variables in order to establish the level of difference that indicates a new climate. To apply this (baselined test), we target a section of the model’s development cycle wherein no intentional science changes have been applied to its source code. We compare an ensemble of short simulations that were conducted using a verified model configuration against a new ensemble with the same configuration but with the latest software infrastructure (Common Infrastructure for Modeling the Earth, CIME5.0), compiler versions, and software libraries. We also compare these against ensemble simulations conducted using the original version of the software infrastructure (CIME4.0) of the earlier model configuration, but with the latest compilers and software libraries, to test the impact of new compilers and libraries in isolation from additional software infrastructure. The two-sample equality of distribution tests indicates that these ensembles indeed represent the same climate.

Coloured Algebras and Biological Response in Quantum Biological Computing Architectures

This paper reports about progress in two areas towards quantum computing architectures with elements inspired from biological controls, as proposed in an earlier paper. The first area is about exploiting mathematical results in coloured algebras, which, combined with the colouring of particle flows, would reduce the decoherence and enhance the decidability in the quantum processing elements; definitions are being recalled, with the required assumptions and results. The second area is to provide experimental results, and a patented biological feedback process in synapse , about light and acoustic excitations in a live animal species to enhance reactivity; the experimental set-up is characterized , the measurement results provided, and the implications are explicated for quantum processing elements approximating a synapse. A paragraph on open issues explains how the results in the two areas will be combined and will help in the design a very early compiler version.

Automation and Testing for Simplified Software Deployment

Creating software releases is one of the more tedious occupations in the life of a software developer. For this purpose we have tried to automate as many of the repetitive tasks involved as possible from getting the commits to running the software. For this simplification we rely in large parts on free collaborative services available around GitHub: issue tracking, code review (GitHub), continuous integration (Travis-CI), static code analysis (coverity). The dependencies and compilers used in the continuous integration are obtained by mounting CVMFS into a docker container. This enables running any desired compiler version (e.g., gcc 6.2, llvm 3.9) or tool (e.g, clang-format, pylint). To create tags for the software package the powerful GitHub API is used. A script was developed that first collates the release notes from the description of each pull request, commits the release notes file, and finally makes a tag. This moves the burden of writing release notesfrom the package maintainer to the individual developer. The deployment of software releases to CVMFS is handled via GitLab-CI. When a tag is made the software is built and automatically deployed. In this paper we will describe the software infrastructure used for the iLCSoft and iLCDirac projects, which are used by CLICdp and the ILC detector collaborations, and give examples of automation which might be useful for others.