First multi-bend achromat lattice consideration.

By the beginning of 1990, three third-generation synchrotron light sources had been successfully commissioned in Grenoble, Berkeley and Trieste (ESRF, ALS and ELETTRA). Each of these new machines reached their target specifications without any significant problems. In parallel, already at that time discussions were underway regarding the next generation, the `diffraction-limited light source (DLSR)', which featured sub-nm rad electron beam emittance, photon beam brilliance exceeding 10(22) and the potential to emit coherent radiation. Also, at about that time, a first design for a 3 GeV DLSR was developed, based on a modified multiple-bend achromat (MBA) design leading to a lattice with normalized emittance of ℇx = 0.5 nm rad. The novel feature of the MBA lattice was the use of seven vertically focusing bend magnets with different bending angles throughout the achromat cell to keep the radiation integrals and resulting beam emittance low. The baseline design called for a 400 m ring circumference with 12 straight sections of 6 m length. The dynamic aperture behaviour of the DLSR lattice was estimated to produce > 5 h beam lifetime at 100 mA stored beam current

South East European International Institute for Sustainable Technologies (SEEIIST)

The South East European International Institute for Sustainable Technologies (SEEIIST) was proposed in 2016 at the World Academy of Art and Science, with the objective of building a facility for charged particle cancer therapy for the South Eastern European countries. SEEIIST will offer the world-class research needed to reduce or even revert the brain drain that is causing a shortage of talent and economic losses in South East Europe. There is no particle therapy in South-East Europe in spite of a growing number of cancers being diagnosed. The facility beam time will be shared 50:50 between treating patients and performing research with a wide spectrum of different light ions beyond the presently used protons and carbon ions, which will make the facility unique in the world. SEEIIST Project is presently in a Conceptual to a Design Phase, implemented with the support of the EU and the involvement of CERN and GSI. The next phase of the project realization will include a final technical design for the facility, a structure and a business plan for the organization and the definition of conditions for the site selection

A Formalization of the Proof-Carrying Code Architecture in a Linear Logical Framework

this paper we formalize the PCC safety architecture in a logical framework, which constitutes an important first step towards an environment for experimentation and formal verification of properties of safety policies and their implementations in the PCC architecture. Our main tool is LLF [CP96], a logical framework based on linear logic [Gir87]. Linear logic provides natural means of describing programming languages and their semantics, especially those of an imperative nature. LLF permits us to give a high-level description of assembly code, safety policies, and safety proofs within the same language. In future work we plan to formally verify safety policies based on their encoding in LLF. We also hope to introduce linearity to the PCC architecture itself in order to reduce the size of safety proofs. We will first further describe the PCC infrastructure in Section 2 followed by a brief sketch of our meta-language, the linear logical framework in Section 3. In order to implement portions of the PCC system, we must choose a language for our simulated agent. We follow [Nec98] and use Safe Assembly Language (SAL), a generic RISC architecture. SAL is described in Section 4. Two execution models, one without and one with run-time safety checks, are described in Section 5. A formal connection between these two models is provided in Section 6, where we specify safety as a property of traces of unsafe execution. An implementation of the Verification Condition Generato

Integrating support for undo with exception handling

One of the important tasks of exception handling is to restore program state and invariants. Studies suggest that this is often done incorrectly. We introduce a new language construct that integrates automated memory recovery with exception handling. When an exception occurs, memory can be automatically restored to its previous state. We also provide a mechanism for applications to extend the automatic recovery mechanism with callbacks for restoring the state of external resources. We describe a logging-based implementation and evaluate its effect on performance. The implementation imposes no overhead on parts of the code that do not make use of this feature

Abstract Optimizing Memory Transactions

Atomic blocks allow programmers to delimit sections of code as ‘atomic’, leaving the language’s implementation to enforce atomicity. Existing work has shown how to implement atomic blocks over word-based transactional memory that provides scalable multiprocessor performance without requiring changes to the basic structure of objects in the heap. However, these implementations perform poorly because they interpose on all accesses to shared memory in the atomic block, redirecting updates to a thread-private log which must be searched by reads in the block and later reconciled with the heap when leaving the block. This paper takes a four-pronged approach to improving performance: (1) we introduce a new ‘direct access ’ implementation that avoids searching thread-private logs, (2) we develop compiler optimizations to reduce the amount of logging (e.g. when a thread accesses the same data repeatedly in an atomic block), (3) we use runtime filtering to detect duplicate log entries that are missed statically, and (4) we present a series of GC-time techniques to compact the logs generated by long-running atomic blocks. Our implementation supports short-running scalable concurrent benchmarks with less than 50 % overhead over a non-thread-safe baseline. We support long atomic blocks containing millions of shared memory accesses with a 2.5-4.5x slowdown. Categories and Subject Descriptors D.3.3 [Programming Languages]: Language Constructs and Features—Concurrent programmin

A Certifying Compiler for Java

This paper presents the initial results of a project to determine if the techniques of proof-carrying code and certifying compilers can be applied to programming languages of realistic size and complexity. The experiment shows that: (1) it is possible to implement a certifying native-code compiler for a large subset of the Java programming language; (2) the compiler is freely able to apply many standard local and global optimizations; and (3) the PCC binaries it produces are of reasonable size and can be rapidly checked for type safety by a small proof-checker. This paper also presents further evidence that PCC provides several advantages for compiler development. In particular, generating proofs of the target code helps to identify compiler bugs, many of which would have been dicult to discover by testing

ACS – THE ADVANCED CONTROL SYSTEM

The ACS is a CORBA-based control system framework with all features expected from a modern control system. It has been recently installed at the ANKA light source in Karlsruhe, Germany and is being used to develop the ALMA control system. ALMA is a joint project between astronomical organisations in Europe, USA and Japan and will consist of 64 12-meter sub-millimetre radio telescopes. ACS provides a powerful XML-based configuration database, synchronous and asynchronous communication, configurable monitors and alarms that automatically reconnect after a server crash, run-time name/location resolution, archiving, error system and logging system. Furthermore, ACS has built-in management, which allows centralized control over processes with commands such as start/stop/reload, send message, disconnect client, etc. and is fine-grained to the level of single devices. ACS comes with all necessary generic GUI applications and tools for management, display of logs and alarms and a generic object explorer, which discovers all CORBA objects, their attributes and commands at run-time and allows the user to invoke any command. A Visual configuration database editor is under development. An XML/XSLT generator creates an Abeans plug for each controlled object, giving access to all Abeans applications such as snapshot, table, GUI panels, and allowing one to use the CosyBeans GUI components for creating Java applications. For those that write their own control system, ACS allows to define own types of controlled data and own models of communication, yet use powerful support libraries as long as one adheres to some rules in the form of programming patterns. ACS users several standard CORBA services such as notification service, naming service, interface repository and implementation repository. ACS hides all details of the underlying mechanisms, which use many complex features of CORBA, queuing, asynchronous communication, thread pooling, life-cycle management, etc. Written in C++ and using the free ORB TAO, which is based on the operating system abstraction platfor