25,597 research outputs found
SOA-based security governance middleware
Business requirements for rapid operational efficiency, customer
responsiveness as well as rapid adaptability are actively driving the need for
ever increasing communication and integration apabilities of software assets.
In this context, security, although acknowledged as being a necessity, is often
perceived as a hindrance. Indeed, dynamic environments require flexible and
understandable security that can be customized, adapted and reconfigured
dynamically to face changing requirements. In this paper, the authors propose
SOA based security governance middleware that handles security requirements on
behalf of a resource exposed through it. The middleware aims at providing
different security settings through the use of managed compositions of security
services called profiles. The main added value of this work compared to
existing handlers or centralized approaches lies in its enhanced flexibility
and transparency
A System's Perspective Towards an Architecture Framework for Safe Automated Vehicles
With an increasing degree of automation, automated vehicle systems become
more complex in terms of functional components as well as interconnected
hardware and software components. Thus, holistic systems engineering becomes a
severe challenge. Emergent properties like system safety are not solely
arguable in singular viewpoints such as structural representations of software
or electrical wiring (e.g. fault tolerant). This states the need to get several
viewpoints on a system and describe correspondences between these views in
order to enable traceability of emergent system properties. Today, the most
abstract view found in architecture frameworks is a logical description of
system functions which structures the system in terms of information flow and
functional components. In this article we extend established system viewpoints
towards a capability-based assessment of an automated vehicle and conduct an
exemplary safety analysis to derive behavioral safety requirements. These
requirements can afterwards be attributed to different viewpoints in an
architecture frameworks and thus be integrated into a development process for
automated vehicles.Comment: 8 pages, 6 figures. Submitted to the 2018 IEEE ITS
MorphoSys: efficient colocation of QoS-constrained workloads in the cloud
In hosting environments such as IaaS clouds, desirable application performance is usually guaranteed through the use of Service Level Agreements (SLAs), which specify minimal fractions of resource capacities that must be allocated for unencumbered use for proper operation. Arbitrary colocation of applications with different SLAs on a single host may result in inefficient utilization of the host’s resources. In this paper, we propose that periodic resource allocation and consumption models -- often used to characterize real-time workloads -- be used for a more granular expression of SLAs. Our proposed SLA model has the salient feature that it exposes flexibilities that enable the infrastructure provider to safely transform SLAs from one form to another for the purpose of achieving more efficient colocation. Towards that goal, we present MORPHOSYS: a framework for a service that allows the manipulation of SLAs to enable efficient colocation of arbitrary workloads in a dynamic setting. We present results from extensive trace-driven simulations of colocated Video-on-Demand servers in a cloud setting. These results show that potentially-significant reduction in wasted resources (by as much as 60%) are possible using MORPHOSYS.National Science Foundation (0720604, 0735974, 0820138, 0952145, 1012798
CUDA Support in GNA Data Analysis Framework
Usage of GPUs as co-processors is a well-established approach to accelerate
costly algorithms operating on matrices and vectors.
We aim to further improve the performance of the Global Neutrino Analysis
framework (GNA) by adding GPU support in a way that is transparent to the end
user. To achieve our goal we use CUDA, a state of the art technology providing
GPGPU programming methods.
In this paper we describe new features of GNA related to CUDA support. Some
specific framework features that influence GPGPU integration are also
explained. The paper investigates the feasibility of GPU technology application
and shows an example of the achieved acceleration of an algorithm implemented
within framework. Benchmarks show a significant performance increase when using
GPU transformations.
The project is currently in the developmental phase. Our plans include
implementation of the set of transformations necessary for the data analysis in
the GNA framework and tests of the GPU expediency in the complete analysis
chain.Comment: 12 pages, 7 figures, ICCSA 2018, submitted to Lecture Notes in
Computer Science (Springer Verlag
Massively Parallel Processor Architectures for Resource-aware Computing
We present a class of massively parallel processor architectures called
invasive tightly coupled processor arrays (TCPAs). The presented processor
class is a highly parameterizable template, which can be tailored before
runtime to fulfill costumers' requirements such as performance, area cost, and
energy efficiency. These programmable accelerators are well suited for
domain-specific computing from the areas of signal, image, and video processing
as well as other streaming processing applications. To overcome future scaling
issues (e.g., power consumption, reliability, resource management, as well as
application parallelization and mapping), TCPAs are inherently designed in a
way to support self-adaptivity and resource awareness at hardware level. Here,
we follow a recently introduced resource-aware parallel computing paradigm
called invasive computing where an application can dynamically claim, execute,
and release resources. Furthermore, we show how invasive computing can be used
as an enabler for power management. Finally, we will introduce ideas on how to
realize fault-tolerant loop execution on such massively parallel architectures
through employing on-demand spatial redundancies at the processor array level.Comment: Presented at 1st Workshop on Resource Awareness and Adaptivity in
Multi-Core Computing (Racing 2014) (arXiv:1405.2281
Towards the Model-Driven Engineering of Secure yet Safe Embedded Systems
We introduce SysML-Sec, a SysML-based Model-Driven Engineering environment
aimed at fostering the collaboration between system designers and security
experts at all methodological stages of the development of an embedded system.
A central issue in the design of an embedded system is the definition of the
hardware/software partitioning of the architecture of the system, which should
take place as early as possible. SysML-Sec aims to extend the relevance of this
analysis through the integration of security requirements and threats. In
particular, we propose an agile methodology whose aim is to assess early on the
impact of the security requirements and of the security mechanisms designed to
satisfy them over the safety of the system. Security concerns are captured in a
component-centric manner through existing SysML diagrams with only minimal
extensions. After the requirements captured are derived into security and
cryptographic mechanisms, security properties can be formally verified over
this design. To perform the latter, model transformation techniques are
implemented in the SysML-Sec toolchain in order to derive a ProVerif
specification from the SysML models. An automotive firmware flashing procedure
serves as a guiding example throughout our presentation.Comment: In Proceedings GraMSec 2014, arXiv:1404.163
Goal-oriented Data Visualization with Software Project Control Centers
Many software development organizations still lack support for obtaining
intellectual control over their software development processes and for
determining the performance of their processes and the quality of the produced
products. Systematic support for detecting and reacting to critical project
states in order to achieve planned goals is usually missing. One means to
institutionalize measurement on the basis of explicit models is the development
and establishment of a so-called Software Project Control Center (SPCC) for
systematic quality assurance and management support. An SPCC is comparable to a
control room, which is a well known term in the mechanical production domain.
Its tasks include collecting, in- terpreting, and visualizing measurement data
in order to provide context-, purpose-, and role-oriented information for all
stakeholders (e.g., project managers, quality assurance manager, developers)
during the execution of a software development project. The article will
present an overview of SPCC concepts, a concrete instantiation that supports
goal-oriented data visualization (G-SPCC approach), and experiences from
practical applications.Comment: 11 pages. arXiv admin note: substantial text overlap with
arXiv:1401.190
Views, Program Transformations, and the Evolutivity Problem in a Functional Language
We report on an experience to support multiple views of programs to solve the
tyranny of the dominant decomposition in a functional setting. We consider two
possible architectures in Haskell for the classical example of the expression
problem. We show how the Haskell Refactorer can be used to transform one view
into the other, and the other way back. That transformation is automated and we
discuss how the Haskell Refactorer has been adapted to be able to support this
automated transformation. Finally, we compare our implementation of views with
some of the literature.Comment: 19 page
MORPHOSYS: efficient colocation of QoS-constrained workloads in the cloud
In hosting environments such as IaaS clouds, desirable application performance is usually guaranteed through the use of Service Level Agreements (SLAs), which specify minimal fractions of resource capacities that must be
allocated for use for proper operation. Arbitrary colocation of applications with different SLAs on a single host may result in inefficient utilization of the host’s resources. In this paper, we propose that periodic resource allocation and consumption models be used for a more granular expression of SLAs. Our proposed SLA model has the salient feature that it exposes flexibilities that enable the IaaS provider to safely transform SLAs from one form to another
for the purpose of achieving more efficient colocation. Towards that goal, we present MorphoSys: a framework for a service that allows the manipulation of SLAs to enable efficient colocation of workloads. We present results from extensive trace-driven simulations of colocated Video-on-Demand servers in a cloud setting. The results show that potentially-significant reduction in wasted resources (by as much as 60%) are possible using MorphoSys.First author draf
QEMU/CPC: Static Analysis and CPS Conversion for Safe, Portable, and Efficient Coroutines
Coroutines and events are two common abstractions for writing concurrent
programs. Because coroutines are often more convenient, but events more
portable and efficient, it is natural to want to translate the former into the
latter. CPC is such a source-to-source translator for C programs, based on a
partial conversion into continuation-passing style (CPS conversion) of
functions annotated as cooperative.
In this article, we study the application of the CPC translator to QEMU, an
open-source machine emulator which also uses annotated coroutine functions for
concurrency. We first propose a new type of annotations to identify functions
which never cooperate, and we introduce CoroCheck, a tool for the static
analysis and inference of cooperation annotations. Then, we improve the CPC
translator, defining CPS conversion as a calling convention for the C language,
with support for indirect calls to CPS-converted function through function
pointers. Finally, we apply CoroCheck and CPC to QEMU (750 000 lines of C
code), fixing hundreds of missing annotations and comparing performance of the
translated code with existing implementations of coroutines in QEMU.
Our work shows the importance of static annotation checking to prevent actual
concurrency bugs, and demonstrates that CPS conversion is a flexible, portable,
and efficient compilation technique, even for very large programs written in an
imperative language.Comment: 12 page
- …