61,475 research outputs found
Cuckoo: a Language for Implementing Memory- and Thread-safe System Services
This paper is centered around the design of a thread- and memory-safe language, primarily for the compilation of application-specific services for extensible operating systems. We describe various issues that have influenced the design of our language, called Cuckoo, that guarantees safety of programs with potentially asynchronous flows of control. Comparisons are drawn between Cuckoo and related software safety techniques, including Cyclone and software-based fault isolation (SFI), and performance results suggest our prototype compiler is capable of generating safe code that executes with low runtime overheads, even without potential code optimizations. Compared to Cyclone, Cuckoo is able to safely guard accesses to memory when programs are multithreaded. Similarly, Cuckoo is capable of enforcing memory safety in situations that are potentially troublesome for techniques such as SFI
EffectiveSan: Type and Memory Error Detection using Dynamically Typed C/C++
Low-level programming languages with weak/static type systems, such as C and
C++, are vulnerable to errors relating to the misuse of memory at runtime, such
as (sub-)object bounds overflows, (re)use-after-free, and type confusion. Such
errors account for many security and other undefined behavior bugs for programs
written in these languages. In this paper, we introduce the notion of
dynamically typed C/C++, which aims to detect such errors by dynamically
checking the "effective type" of each object before use at runtime. We also
present an implementation of dynamically typed C/C++ in the form of the
Effective Type Sanitizer (EffectiveSan). EffectiveSan enforces type and memory
safety using a combination of low-fat pointers, type meta data and type/bounds
check instrumentation. We evaluate EffectiveSan against the SPEC2006 benchmark
suite and the Firefox web browser, and detect several new type and memory
errors. We also show that EffectiveSan achieves high compatibility and
reasonable overheads for the given error coverage. Finally, we highlight that
EffectiveSan is one of only a few tools that can detect sub-object bounds
errors, and uses a novel approach (dynamic type checking) to do so.Comment: To appear in the Proceedings of 39th ACM SIGPLAN Conference on
Programming Language Design and Implementation (PLDI2018
Replicode: A Constructivist Programming Paradigm and Language
Replicode is a language designed to encode short parallel programs and executable models, and is centered on the notions of extensive pattern-matching and dynamic code production.
The language is domain independent and has been designed to build systems that are modelbased and model-driven, as production systems that can modify their own code. More over, Replicode supports the distribution of knowledge and computation across clusters of computing nodes.
This document describes Replicode and its executive, i.e. the system that executes Replicode constructions. The Replicode executive is meant to run on Linux 64 bits and Windows 7 32/64 bits platforms and interoperate with custom C++ code.
The motivations for the Replicode language, the constructivist paradigm it rests on, and the higher-level AI goals targeted by its construction, are described by Thórisson (2012), Nivel and Thórisson (2009), and Thórisson and Nivel (2009a, 2009b).
An overview presents the main concepts of the language. Section 3 describes the general structure of Replicode objects and describes pattern matching. Section 4 describes the execution model of Replicode and section 5 describes how computation and knowledge are structured and controlled. Section 6 describes the high-level reasoning facilities offered by the system. Finally, section 7 describes how the computation is distributed over a cluster of computing nodes.
Consult Annex 1 for a formal definition of Replicode, Annex 2 for a specification of the executive, Annex 3 for the specification of the executable code format (r-code) and its C++ API, and Annex 4 for the definition of the Replicode Extension C++ API
The PAX Toolkit and its Applications at Tevatron and LHC
At the CHEP03 conference we launched the Physics Analysis eXpert (PAX), a C++
toolkit released for the use in advanced high energy physics (HEP) analyses.
This toolkit allows to define a level of abstraction beyond detector
reconstruction by providing a general, persistent container model for HEP
events. Physics objects such as particles, vertices and collisions can easily
be stored, accessed and manipulated. Bookkeeping of relations between these
objects (like decay trees, vertex and collision separation, etc.) including
deep copies is fully provided by the relation management. Event container and
associated objects represent a uniform interface for algorithms and facilitate
the parallel development and evaluation of different physics interpretations of
individual events. So-called analysis factories, which actively identify and
distinguish different physics processes and study systematic uncertainties, can
easily be realized with the PAX toolkit.
PAX is officially released to experiments at Tevatron and LHC. Being explored
by a growing user community, it is applied in a number of complex physics
analyses, two of which are presented here. We report the successful application
in studies of t-tbar production at the Tevatron and Higgs searches in the
channel t-tbar-Higgs at the LHC and give a short outlook on further
developments
Concepts, Developments and Advanced Applications of the PAX Toolkit
The Physics Analysis eXpert (PAX) is an open source toolkit for high energy
physics analysis. The C++ class collection provided by PAX is deployed in a
number of analyses with complex event topologies at Tevatron and LHC. In this
article, we summarize basic concepts and class structure of the PAX kernel. We
report about the most recent developments of the kernel and introduce two new
PAX accessories. The PaxFactory, that provides a class collection to facilitate
event hypothesis evolution, and VisualPax, a Graphical User Interface for PAX
objects
Pythia version 7-0.0 - a proof-of-concept version
This document describes the first proof-of-concept version of the Pythia7
program.
Pythia7 is a complete re-write of the Pythia program in C++. It is mainly
intended to be a replacement for the `Lund' family of event generators, but is
also a toolkit with a structure suitable for implementing any event generator
model.
In this document, the structure of the program is presented both from the
user and the developer point of view. It is not intended to be a complete
manual, but together with the documentation provided in the distribution, it
should be sufficient to start working with the program.Comment: 39 pages, 3 figure
- …