Search

In this paper, we present a transformation method of source code from a POSIX (Portable Operating System Interface) based source code into an OSEK/VDX (Offene Systeme und deren Schnittstellen fur die Elektronik in Kraftfahrzeugen/Vehicle Distributed eXecutive) source code. As the electronic parts of automobile systems increase, the use of embedded software in automobile systems is also growing. Accordingly, many electronic systems are designed in automobile system with OSEK/VDX. Otherwise, one of the major problems of embedded software would be portability to other OS`s. To enhance the portability and interoperability of embedded software, we propose a source code transformation method from POSIX to OSEK/VDX based on API (Application Programming Interface) translation method. Considering the characteristics of the OSEK/VDX which uses OIL (OSEK/VDX Implementation Language) standard, transformation process is performed with source code transformation and OIL code generation. For the validity of the proposed method, the transformation experiment is given using Micro-C OS II and OSEK/VDX with XC167CI micro-controller.

Choosing an appropriate cluster file system for a specific high performance computing application is challenging and depends mainly on the specific application I/O needs. There is a wide variety of I/O requirements: Some implementations require reading and writing large datasets, others out-of-core data access, or they have database access requirements. Application access patterns reflect different I/O behavior and can be used for performance testing. This paper presents the programmable I/O benchmarking tool Parabench. It has access patterns as input, which can be adapted to mimic behavior for a rich set of applications. Using this benchmarking tool, composed patterns can be automatically tested and easily compared on different local and cluster file systems. Here we introduce the design of the proposed benchmark, focusing on the Parabench programming language, which was developed for flexible pattern creation. We also demonstrate here an exemplary usage of Parabench and its capabilities to handle the POSIX and MPI-IO interfaces.

In 2008, the Catamount lightweight kernel was extended to support direct access shared memory between processes running on the same compute node. This extension, called SMARTMAP, allows each process read/write access to another process’ memory by extending the virtual address of each process. Simple virtual address bit manipulation can be used to access the same virtual address in a different process’ address space. In this paper we describe an implementation of the Message Passing Interface (MPI) that uses SMARTMAP for intra-node message passing. SMARTMAP has several advantages over POSIX shared memory techniques for implementing MPI. We present performance results comparing MPI using SMARTMAP to the existing MPI transport layer on a quad-core Cray XT platform.

We conducted a case study of parallelizing a real program for multicore computers using currently available libraries and tools. We selected the sequential Bzip2 compression program for the study because it's a computing-intensive, widely used, and relevant application in everyday life. Its source code is available, and its algorithm is well documented. In addition, the algorithm is non-trivial, but, with 8,000 LOC, the application is small enough to manage in a course.

DARTS (Design Approach for Real Time Systems) (4) is a software design method for real time systems. LabVIEW (Laboratory Virtual Instrument Engineering Workbench) is a graphical application development environment developed by National Instruments Corporation based on the dataflow representation of the "G" language (6)(2). LabVIEW is implicitly multithreaded and has high level functions for communication/synchronization, allowing it to be used as a programming language for control/command and soft real-time applications. In order to help a designer to develop a real-time application, we propose the library DARTSVIEW, which simplifies the passage from the conception of a "multitasking" application to the implementation (8). One can use DARTSVIEW in different phases of the life cycle of real-time system software. The last version of DARTSVIEW, allows to define in XML several real-time programming normalized languages, and to generate a part of the code for different specific programming languages (Ada, POSIX 1003.1, VxWorks, OSEK/VDX, etc.). The flexibility introduced by the use of XML allows a designer also to generate some code targeting real-time scheduling analysis tools in order to achieve the temporal validation. The objective of this article is to present an overview of DARTSVIEW, a Toolkit for DARTS in LabVIEW, the role of DARTSVIEW in the software life-cycle, and some perspectives for the extensibility of this Toolkit in the future.

With the exponential growth of high-fidelity sensor and simulated data, the scientific community is increasingly reliant on ultrascale HPC resources to handle its data analysis requirements. However, to use such extreme computing power effectively, the I/O components must be designed in a balanced fashion, as any architectural bottleneck will quickly render the platform intolerably inefficient. To understand I/O performance of data-intensive applications in realistic computational settings, we develop a lightweight, portable benchmark called MADbench2, which is derived directly from a large-scale cosmic microwave background (CMB) data analysis package. Our study represents one of the most comprehensive I/O analyses of modern parallel file systems, examining a broad range of system architectures and configurations, including Lustre on the Cray XT3, XT4, and Intel Itanium2 clusters; GPFS on IBM Power5 and AMD Opteron platforms; a BlueGene/P installation using GPFS and PVFS2 file systems; and CXFS on the SGI Altix3700. We present extensive synchronous I/O performance data comparing a number of key parameters including concurrency, POSIX- versus MPI-IO, and unique- versus shared-file accesses, using both the default environment as well as highly tuned I/O parameters. Finally, we explore the potential of asynchronous I/O and show that only the two of the nine evaluated systems benefited from MPI-2's asynchronous MPI-IO. On those systems, experimental results indicate that the computational intensity required to hide I/O effectively is already close to the practical limit of BLAS3 calculations. Overall, our study quantifies vast differences in performance and functionality of parallel file systems across state-of-the-art platforms - showing I/O rates that vary up to 75x on the examined architectures - while providing system designers and computational scientists a lightweight tool for conducting further analysis.

A new text-based interface for WIEN2k, the full-potential linearized augmented plane-waves (FPLAPW) program, is presented. This code provides an easy to use, yet powerful way of generating arbitrarily large sets of calculations. Thus, properties over a potential energy surface and WIEN2k parameter exploration can be calculated using a simple input text file. This interface also provides new capabilities to the WIEN2k package, such as the calculation of elastic constants on hexagonal systems or the automatic gathering of relevant information. Additionally, runwien is modular, flexible and intuitive. Program summary Program title: runwien Catalogue identifier: AECM_v1_0 Program summary URL: http://cpc.cs.qub.ac.uk/summaries/AECM_v1_0.html Program obtainable from: CPC Program Library, Queen's University, Belfast, N. Ireland Licensing provisions: GPL version 3 No. of lines in distributed program, including test data, etc.: 62 567 No. of bytes in distributed program, including test data, etc.: 610 973 Distribution format: tar.gz Programming language: gawk (with locale POSIX or similar) Computer: All running Unix, Linux Operating system: Unix, GNU/Linux Classification: 7.3 External routines: WIEN2k ( http://www.wien2k.at/ ), GAWK ( http://www.gnu.org/software/gawk/ ), rename by L. Wall, a Perl script which renames files, modified by R. Barker to check for the existence of target files, gnuplot ( http://www.gnuplot.info/ ) Subprograms used: Cat Id : ADSY_v1_0/AECB_v1_0, Title : GIBBS/CRITIC, Reference : CPC 158 (2004) 57/CPC 999 (2009) 999 Nature of problem: Creation of a text-based, batch-oriented interface for the WIEN2k package. Solution method: WIEN2k solves the Kohn–Sham equations of a solid using the FPLAPW formalism. Runwien interprets an input file containing the description of the geometry and structure of the solid and drives the execution of the WIEN2k programs. The input is simplified thanks to the default values of the WIEN2k parameters known to runwien. Additional comments: Designed for WIEN2k versions 06.4, 07.2, 08.2, and 08.3. Running time: For the test case (TiC), a single geometry takes 5 to 10 minutes on a typical desktop PC (Intel Pentium 4, 3.4 GHz, 1 GB RAM). The full example including the calculation of the elastic constants and the equation of state, takes 9 hours and 32 minutes.

We describe the Modern Multithreading (MM) class library. MM is a class library consisting of thread and synchronization classes that provide significant support for testing and debugging multithreaded programs. The synchronization classes implement commonly used synchronization objects such as semaphores, monitors, and asynchronous and synchronous message passing channels, for programs that run on a single computer or on a distributed system. MM uses controlled executions to provide program tracing and replay and to support a number of implementation-based and specification-based testing techniques, including non-deterministic and deterministic testing and several forms of reachability testing. MM is portable and easy to use, and has been implemented in Java and C++, with C++ versions for the POSIX Pthreads library and for the Windows Win32 API.

We present results from the second pilot project in the international Verification Grand Challenge: a formally verified specification of a POSIX-compliant file store using the Z/Eves theorem prover. The project’s overall objective is to build a verified file store for space-flight missions. Our specification of the file store is based on Morgan and Sufrin’s specification of the UNIX filing system; the proof and its mechanisation in Z/Eves are novel. We show how our work contributes towards building a verified software repository: a set of general theories, proof techniques, and experiments reusable across different domains.

Wireless sensor networks are characterized by very tight code size and power constraints and by a lack of well-established standard software development platforms such as Posix. In this article, we present a comparative study between a few fairly different such platforms, namely MANTIS, TinyOS, and ZigBee, when considering them from the application developer's perspective, that is, by focusing mostly on functional aspects, rather than on performance or code size. In other words, we compare both the tasking model used by these platforms and the API libraries they offer. Sensor network applications are basically event based, so most of the software platforms are also built on considering event handling mechanism, however some use a more traditional thread based model. In this article, we consider implementations of a simple generic application in MANTIS, TinyOS, and the Ember ZigBee development framework, with the goal of depicting major differences between these platforms, and suggesting a programming style aimed at maximizing portability between them.

For pt. 1 see ibid., vol.11, no.2, p.50-56, (2008). This paper provides an explanation of a distributed measurement system based on proprietary software. It describes applications based mainly on free and open source software (FOSS). It is an interesting alternative to proprietary solutions as it offers greater flexibility in software development, better protection of customers' rights, and guaranteed open access to data. FOSS is based on the IEEE standards 1003, also known as POSIX or ISO/IEC 9945. In this paper, it is shown that the same objectives met with proprietary solutions can be achieved with FOSS, if not even better than with proprietary software.

An IPTV set-top box provides a variety of interesting services such as VOD (Video On Demand), PVR (Personal Video Recorder), game, TV shopping as well as live TV broadcast. In order to support various interactive services of IPTV, more elaborate software should be equipped within the set-top box. In this paper, we present the implementation of a storage manager used in the IPTV set-top box. Like general purpose computer systems, softwares within the set-top box form a layered architecture which consists of a set of applications, an operating system, and device drivers. Each software component has its own functions, and communicates with other components through welldefined interfaces. However, the fixed interfaces often become a barrier in delivering some important information to other layers. For example, because of the POSIX interface defined a long time ago, media players with soft real-time requirements cannot deliver the QoS information to the operating system efficiently. To address this problem, we propose a new approach that provides the QoS services by using only the file attributes without modifying the existing interfaces. We implemented our prototype system Daphne on the Linux operating system. Through the experiments by measurements, we show that the proposed approach is effective in guaranteeing the QoS.

The CRN Toolbox enables fast implementation of activity and context recognition systems, featuring mechanisms for distributed processing and support for mobile and wearable devices. CRN Toolbox is a tool set specifically optimized for implementing multimodal, distributed activity and context recognition systems running on Posix operating systems. Like conventional rapid- prototyping tools, the CRN Toolbox contains a collection of ready-to-use algorithms (signal processing, pattern classification, and so on). Unlike classic event detection in homogeneous sensor networks-for example, DSWare (Data Service Middleware)-it supports complex activity detection from heterogeneous sensors. Its implementation is particularly optimized for mobile devices. This includes the ability to execute algorithms, whether in floating-point or fixed-point arithmetic, without recoding. Moreover, with its mature functionality, the CRN Toolbox isn't likely to suffer from limited user acceptance as the Context toolkit framework did.

Panache is a scalable, high-performance, remote file data caching solution integrated with the GPFS cluster file system. It leverages the inherent scalability of GPFS to provide a multi-node, consistent cache of data exported by a remote file system cluster. Panache exploits the soon-to-be standard pNFS protocol to move data in parallel from the remote file cluster. Furthermore, it provides a POSIX compliant file system interface making the cache completely transparent to applications. Panache can mask the fluctuating wide-area-network latencies and outages by supporting asynchronous and disconnected-mode operations. It allows concurrent updates to be made at the cache and at the remote cluster and synchronizes them by using conflict detection techniques to flag and handle conflicts. To maintain commercial viability, Panache relies on open standards for high-performance file serving and does not require any proprietary hardware or software to be deployed at the remote cluster. In this paper we present the overall architecture of Panache and its key features.

Existing anomaly intrusion detection that monitors system calls has two problems: vast false positives and lack of risk information on detection. In order to solve the two problems, we propose an intrusion detection method called "Callchains." Callchains reduces the false positives of existing anomaly intrusion detection by restricting monitoring to the activities with process capabilities prescribed by POSIX 1003.le. Additionally, Callchains provides an administrator information of used POSIX capabilities in sytem call execution as an indicator of risk. This paper shows Callchains' design, its implementation, and experimental results comparing Callchains with existing approaches.

Recently, Embedded systems are different with the past as loading of a simple application program that executed specific functions according to the use and are evolved in the digital convergence integrated multimedia functions and then the complication of the application program is remarkably increased. This application program is combined and evolved with many application program in accordance with the demand of the age. For develope and manage this developing application is necessary standardized interface between developer and manager. POSIX was developed as the standard of the operating system in the standard interface which has the open system structure in computing system, and there is a posix.4 to standard for the system demands the loading of real-time operating system like a digital convergence devices. In this paper, we present the contents of designing and implementing the real-time operating system UbiFOSTM to wrapper for supporting the POSIX.4. Also, Experimental results show that implemented wrapper to application program standardizing POSIX.4 in linux and UbiFOSTM is slight only .

The recent Ada 2005 standard introduced a number of new real-time services, with the capability of creating and managing execution time budgets for groups of tasks. This capability has many practical applications in real-time systems in general, and therefore it is also interesting for real-time operating systems. In this paper we present an implementation of thread group budgets inside a POSIX real-operating system, which can be used to implement the new Ada 2005 services. The architecture and details of the implementation are shown, as they may be useful to other implementers of this functionality defined in the new standard.

Much of the research on scheduling schemes is prevented from being used in practice by the lack of implementations that provide the necessary abstractions. An example of this is the support of execution-time servers. Apart for a single mechanism (the Sporadic Server), which is defined in the POSIX standard, these important building blocks are not available to the system developer. Over the last few years, we have been developing the mechanisms necessary to construct execution-time servers from within an Ada context. Versions of these have now been incorporated in the Ada 2005 standard. In this paper, we show how the mechanisms can be used to construct the Deferrable and Sporadic servers.

We describe the implementation of facilities for the communication with external resources in the Symbolic Manipulation System FORM. This is done according to the POSIX standards defined for the UNIX operating system. We present a number of examples that illustrate the increased power due to these new capabilities., 36 pages, 2 Encapsulated postscript figures, LaTeX2e, uses elsart.cls (included)

In modern receiver control applications achieving real time response is of main importance. The paper is a part of software development for CSM controller system. In this paper a real time application, for controlling SCAN DF receiver simulator will be implemented using POSIX socket APIs on VxWorks RTOS and process the data from the scanDF receiver subsystem. The processed data can be used to develop a database for electronic order of battle. This application will be able to interact with receiver using socket APIs, to exchange command and data packets. TCP/IP based socket APIs will be used to realize the application.

Most resource control protocols such as IPCP (Immediate Priority Ceiling Protocol) require a kernel system call to implement the necessary control over any shared data. This call can be expensive, involving a potentially slow switch from CPU user-mode to kernel-mode (and back). In this paper we look at two anticipatory schemes (IPCP and DFP - Deadline Floor Protocol) and show how they can be implemented with the minimum number of calls on the kernel. Specifically, no kernel calls are needed when there is no contention, and only one when there is. A standard implementation would need two such calls. The protocols developed are verified by the use of model checking. A prototype implementation is described for POSIX pThreads (thus opening up improvements to a range of programming approaches). Experimental results demonstrate the effectiveness of the scheme, showing average case savings of 86%.

In the current scientific computing scenario storage systems are one of the main bottlenecks in computing platforms. This issue affects both traditional high performance computing systems and modern systems based on cloud platforms. Accelerating the I/O subsystems can improve the overall performance of the applications. In this paper, we present Hercules as an I/O accelerator specially designed for improving I/O access in workflow engines deployed over cloud-based infraestructures. Hercules provides a dynamic and flexible in-memory storage platform based on NoSQL-based distributed memory systems. In addition, Hercules offers a user-level interface based on POSIX for facilitating its usage on existing solutions and legacy applications. We have evaluated the proposed solution in a public cloud environment, in this case Amazon EC2. The results show that Hercules provides a scalable I/O solution with remarkable performance, especially for write operations, compared with classic I/O approaches for high performance computing in cloud environments.

Many APIs enable cross-platform system development by abstracting over the details of a platform, allowing application developers to write one implementation that will run on a wide variety of platforms. Unfortunately, subtle differences in the behavior of the underlying platforms make cross-platform behavior difficult to achieve. As a result, applications using these APIs can be plagued by bugs difficult to observe before deployment. These portability bugs can be particularly difficult to diagnose and fix because they arise from the API implementation, the operating system, or hardware, rather than application code. This paper describes CheckAPI, a technique for detecting violations of cross-platform portability. CheckAPI compares an application's interactions with the API implementation to its interactions with a partial specification-based API implementation, and does so efficiently enough to be used in real production systems and at runtime. CheckAPI finds latent errors that escape pre-release testing. This paper discusses the subtleties of different kinds of API calls and strategies for effectively producing the partial implementations. Validating CheckAPI on JavaScript, the Seattle project's Repy VM, and POSIX detects dozens of violations that are confirmed bugs in widely-used software.

We introduce a program logic for specifying a core sequential subset of the POSIX file system and for reasoning abstractly about client programs working with the file system. The challenge is to reason about the combination of local directory update and global pathname traversal (including '..' and symbolic links) which may overlap the directories being updated. Existing reasoning techniques are either based on first-order logic and do not scale, or on separation logic and can only handle linear pathnames (no '..' or symbolic links). We introduce fusion logic for reasoning about local update and global pathname traversal, introducing a novel effect frame rule to propagate the effect of a local update on overlapping pathnames. We apply our reasoning to the standard recursive remove utility (rm -r), discovering bugs in well-known implementations.

Thread-level speculation (TLS) is a technique used to aggressively exploit the parallelism of a program at runtime. In this paper, we develop a programming model for software-based, thread-level value speculation that can be used for image processing. The proposed technique allows users to leverage thread-level value speculation to parallelize programs step-by-step. The whole implementation is built upon the POSIX (Portable Operating System Interface of UNIX) thread library. The experimental results show that the proposed programming model can generate performance benefits for the tested benchmark programs.

MariaDB is a community-developed fork of the MySQL relational database management system and originally designed and implemented to use traditional spinning disk architecture. Now that devices with Non-Volatile memory (NVM) technologies are available, MariaDB addresses this challenge by adding support for NVM devices and introduces NVM Compression method. NVM Compression is a novel hybrid technique that combines application level compression with flash awareness for optimal performance and storage efficiency. Utilizing new interface primitives exported by Flash Translation Layers (FTLs), we leverage the garbage collection available in flash devices to optimize the capacity management required by compression systems. We implement NVM Compression in the popular MariaDB database and use variants of commonly available POSIX file system interfaces to provide the extended FTL capabilities to the user space application. The experimental results show that the hybrid approach of NVM Compression can improve compression performance by 2-7x, deliver compression performance for flash devices that is within 5% of uncompressed performance, improves storage efficiency by 19% over legacy Row-Compression, reduce data writes by up to 4x when combined with other flash aware techniques such as Atomic Writes, and deliver further advantages in power efficiency and CPU utilization.

This document will be organized into sections that are defined by the requirements for a file system that presents a near-POSIX (Portable Operating System Interface) interface to the user, but whose data is stored in whatever form is most efficient for the type of data being stored. After defining the requirement the design for meeting the requirement will be explained. Finally there will be sections on configuring and administering this file system. More and more, data dominates the computing world. There is a “sea” of data out there in many different formats that needs to be managed and used. “Mar” means “sea” in Spanish. Thus, this product is dubbed MarFS, a file system for a sea of data.

As systems sizes increase to exascale and beyond, there is a need to enhance the system software to meet the needs and challenges of applications. The evolutionary versus revolutionary debate can be set aside by providing system software that simultaneously supports existing and new programming models. The seemingly contradictory requirements of scalable performance and traditional rich programming APIs (POSIX, and Linux in particular) suggest that approach, and has lead to a new class of research. Traditionally, operating systems for extreme-scale computing have followed two approaches: they have either started with a full-weight kernel (FWK), typically Linux, and removed features which were impeding performance and scalability, or they started with a light-weight kernel (LWK), and added capability to provide Linux compatibility. Neither of these approaches, succeed in retaining full Linux compatibility and achieving high scalability.To overcome this problem, we have been exploring the design space of providing LWK performance while retaining the Linux APIs and Linux environment. Our hybrid solution is to run Linux and an LWK side-by-side on the same node. HPC applications execute on top of the LWK, but the system selectively provides OS features by leveraging the Linux kernel. In this paper, we discuss two possible methods of achieving the symbiosis between the two kernels and the trade-offs between them. Specifically, we detail and contrast two particular approaches, Intel's mOS project and IHK/McKernel, an effort lead by RIKEN Advanced Institute for Computational Science.

The distance between compute and data continues to grow and despite being declared "dead" a decade ago, the interfaces of the serial world (Posix) are still with us. Is it time to move on and to what? How can we give applications the desired flexibility, consistency and volume of data in large systems composed of thousands or millions of failing parts? The group Brent runs at Intel, the High Performance Data Division, has been shepherding the Lustre file system while working on the riddle of "what now" for big systems when it comes to feeding them data.

Researchers in the real-time community have accumulated an enormous theoretical background on scheduling policies and respective assessment criteria. Lots of surveys and textbooks are available which classify the varying approaches. In contrast to this abundance of policies and strategies the availability of real-time scheduling for given platforms is rather low. Still more frustrating is the lack of easily manageable tools for prototypical test and use of a given platform. This paper presents an easy-to-use platform-independent implementation of rate monotonic scheduling policies — in this paper exemplary for (RMS) — based on the POSIX standard. Hence the only platform requirement is to provide the used POSIX functions. Although many POSIX API-providers claim to be POSIX compliant or POSIX conform but not POSIX certified there is still no guarantee that the required POSIX subset works as expected. A test on conformity of a platform by a stepwise organized and self-documenting test suite is proposed in this paper.

Today's big-data analysis systems achieve performance and scalability by requiring end users to embrace a novel programming model. This approach is highly effective whose the objective is to compute relatively simple functions on colossal amounts of data, but it is not a good match for a scientific computing environment which depends on complex applications written for the conventional POSIX environment. To address this gap, we introduce Conjugal, a scalable data-intensive computing system that is largely compatible with the POSIX environment. Conjugal brings together the workflow model of scientific computing with the storage architecture of other big data systems. Conjugal accepts large workflows of standard POSIX applications arranged into graphs, and then executes them in a cluster, exploiting both parallelism and data-locality. By making use of the workload structure, Conjugal is able to avoid the long-standing problems of metadata scalability and load instability found in many large scale computing and storage systems. We show that CompUSA's approach to load control offers improvements of up to 228% in cluster network utilization and 23% reductions in workflow execution time.

We present a novel, deeply embedded robotics middleware and programming environment. It uses a multithreaded, publish-subscribe design pattern and provides a Unix-like software interface for micro controller applications. We improve over the state of the art in deeply embedded open source systems by providing a modular and standards-oriented platform. Our system architecture is centered around a publish-subscribe object request broker on top of a POSIX application programming interface. This allows to reuse common Unix knowledge and experience, including a bash-like shell. We demonstrate with a vertical takeoff and landing (VTOL) use case that the system modularity is well suited for novel and experimental vehicle platforms. We also show how the system architecture allows a direct interface to ROS and to run individual processes either as native ROS nodes on Linux or nodes on the micro controller, maximizing interoperability. Our microcontroller-based execution environment has substantially lower latency and better hardware connectivity than a typical Robotics Linux system and is therefore well suited for fast, high rate control tasks.

We present a system for performing arbitrary sequences of filesystem operations and provably detecting any violation of serializable isolation semantics, i.e. any interleaving of attacker and defender actions is equivalent to a non-interleaved sequence of attacker and defender actions. Thus, our system provides a provably secure defense against all UNIX file-name race conditions, including the infamous access/open race. Our solution operates entirely in user-space and is portable to any POSIX.1-2008 system, making it usable today. Developers can adopt our solution selectively, using it for security-critical code and using the standard POSIX interface for non-security-critical parts of their programs. Furthermore, the proofs of correctness suggest several simple improvements to the POSIX standard.

The explosion of data volumes in enterprise environments and limited budgets have triggered the need for multi-tiered storage systems. With the bulk of the data being extremely infrequently accessed, tape is a natural fit for storing such data. In this paper we present our approach to a file storage system that seamlessly integrates disk and tape, enabling a bottomless and cost-effective storage architecture that can scale to accommodate Big Data requirements. The proposed system offers access to data through a POSIX filesystem interface under a single global namespace, optimizing the placement of data across disk and tape tiers. Using a self-contained, standardized and open filesystem format on the removable tape media, the proposed system avoids dependence on proprietary software and external metadata servers to access the data stored on tape. By internally managing the tape tier resources, such as tape drives and cartridges, the system relieves the user from the burden of dealing with the complexities of tape storage. Our implementation, which is based on the GPFS and LTFS filesystems, demonstrates the applicability of the proposed architecture in real-world environments. Our experimental evaluation has shown that this is a very promising approach in terms scalability, performance and manageability. The proposed system has been productized by IBM as LTFS Enterprise Edition.

While an input/output (I/O) interface’s syntax describes the available operations, its semantics determines how these operations behave and which assumptions developers can make about them. There are several different interface standards in existence, some of them dating back decades and having been designed for local file systems; one such representative is POSIX. Many parallel distributed file systems implement a POSIX-compliant interface to improve portability. All currently available interfaces follow a fixed approach regarding semantics, making them only suitable for a subset of use cases and workloads. While the interfaces do not allow application developers to influence the I/O semantics, applications could benefit greatly from the possibility of being able to adapt them to their requirements.

Over the past few years, it has become obvious that Internet of Things, in which all embedded devices are interconnected, will soon turn into reality. These smart devices have limited processing and energy resources and there is a need to provide security guarantees for applications running on them. In order to meet these demands, in this paper we present a POSIX-compliant native runtime environment which runs over a L4-based microkernel, a thin operating system, on top of which applications for embedded devices can run and thus be a part of the Internet of Things.

All over the process of treating data on HPC Systems, parallel file systems play a significant role. With more and more applications, the need for high performance Input-Output is rising. Different possibilities exist: General Parallel File System, cluster file systems and virtual parallel file system (PVFS) are the most important ones. However, these parallel file systems use pattern and model access less effective such as POSIX semantics (A family of technical standards emerged from a project to standardize programming interfaces software designed to operate on variant UNIX operating system.), which forces the MPI-IO implementations to use inefficient techniques based on locks. To avoid this synchronization in these techniques, we ensure that the use of a versioning-based file system is much more effective.

The main purpose of this work is to explain the management and distribution of tasks in a grid middleware. The aim is to propose an environment that enables designing the batch jobs that use the standard software and system resources for communication and data exchange. The article explains JSDL specification for defining and management of one batch jobs. The motivation is to design a tool for an easy job definition. The result is a tool that does not require special programming objects for solving a specific task. This work deals with the mechanisms for monitoring and gathering information about the result of each processing task. The JSDL definitions provide the mechanism for the solution of these problems. Grid Scheduler more easily recognizes the status of a specific task.

This chapter focuses on LIKE and SIMILAR TO predicates. The “_” character represents a single arbitrary character; the “%” character represents an arbitrary substring, possibly of length zero. Any other character in the represents that character itself. The is used in the to specify that the character that follows it is to be interpreted as a literal rather than a wildcard. The “_” character tests much faster than the “%” character as the parser that compares a string to the pattern needs only one operation to match an underscore before it can move to the next character, but has to do some look-ahead parsing to resolve a percentage sign. The NULL can be the escape character, pattern, or match value and a NULL in the predicate returns an UNKNOWN result. The CASE expression in Standard SQL lets the programmer use the LIKE predicate in some interesting ways. A CASE expression executes the WHEN clauses in order of their appearance and adjusts the pattern within the LIKE predicate. If the SQL has the ability to define a function in an index, one can reverse or rearrange the string to give faster access, where the query must explicitly use the same function as the index. An alternative to this is to store the rearranged value in the base table and show the actual value in a view. When the view is invoked, the rearranged value is used for the query without the users knowing it.

The POSIX shell is a descendant of the KornShell, which is a descendant of the Bourne shell. The basic syntax has remained the same, and Bourne shell scripts will usually run successfully in a POSIX shell. Not all of the KornShell features are included in POSIX (there are no arrays, for example), but the most important ones are. Those, which would be important to many developers, are string manipulation and arithmetic.

When I was introduced to Bourne shell scripting, I took to it immediately, despite some obvious deficiencies in the language. One of the features missing was string manipulation. It existed, but almost everything had to be done with external commands that were loaded from the disk each time. The KornShell introduced a number of parameter expansion modifiers that drastically reduced the number of calls to external commands. These were copied by other shells and incorporated into the POSIX standard.

The EOS[1] storage software was designed to cover CERN disk-only storage use cases in the medium-term trading scalability against latency. To cover and prepare for long-term requirements the CERN IT data and storage services group (DSS) is actively conducting R&D; and open source contributions to experiment with a next generation storage software based on CEPH[3] and ethernet enabled disk drives. CEPH provides a scale-out object storage system RADOS and additionally various optional high-level services like S3 gateway, RADOS block devices and a POSIX compliant file system CephFS. The acquisition of CEPH by Redhat underlines the promising role of CEPH as the open source storage platform of the future. CERN IT is running a CEPH service in the context of OpenStack on a moderate scale of 1 PB replicated storage. Building a 100+PB storage system based on CEPH will require software and hardware tuning. It is of capital importance to demonstrate the feasibility and possibly iron out bottlenecks and blocking issues beforehand. The main idea behind this R&D; is to leverage and contribute to existing building blocks in the CEPH storage stack and implement a few CERN specific requirements in a thin, customisable storage layer. A second research topic is the integration of ethernet enabled disks. This paper introduces various ongoing open source developments, their status and applicability.

Tasks can share resources in various ways. Multiple threads within the same process can share global variables, through which data can flow back and forth among them. File or memory region objects can be shared via memory mapping by multiple processes. The integrity of an exclusive resource can be endangered when multiple tasks gain access to it at the same time. Semaphore, mutex, and condition variable are POSIX objects that are normally used to protect the integrity of shared resources. For each type of these POSIX objects, we explain the corresponding POSIX functions, examine their usage patterns, and give a few running examples.

Similarly to message queues, pipes offer another mechanism for intertask communication. An unnamed pipe is typically used between processes that are related by either a parent-child relationship or a sibling relationship. A named pipe is a persistent file object, which is typically used between processes that are not necessarily related. Each pipe has two ends, one for writing and one for reading. The read operation on a pipe can be blocked if the pipe is empty, and the write operation on a pipe can be blocked if the available space is not sufficient to hold the data to be written. In a POSIX-compliant operating system implementation, the write operation on a pipe is atomic when the data to be written are no more than the maximum capacity defined by PIPE_BUF. The POSIX select operation allows a task to simultaneously block on several pipes until any one of them becomes ready for reading or writing.

The QNX operating system uses resource managers for managing filesystems and a wide variety of devices. By pathname space mapping, devices and resources are rendered as filesystem entries. This allows a client application to interact with multiple servers through POSIX function calls. The control structure and data structures related to resource managers are introduced, and the mappings between POSIX calls and the internal message handlers of a resource manager are explained. Two examples are given to show how to implement resource managers.

As an open operating system (OS) interface standard, POSIX promotes interoperability and portability of applications across Unix-like operating systems. The POSIX standard consists mainly of definitions for core OS services and real-time extensions. A key POSIX concept is process, which allows multiple threads to run in a protected environment. In an OS, a task can be implemented as a process or simply a thread. The POSIX real-time extensions define real-time services such as real-time signals, real-time scheduling policies, task synchronization mechanisms, clocks, and timers. A real-time OS that is POSIX compliant typically implements both the core OS services and the real-time extensions, with the capability to respond with bounded response time to external events.

SeL4 is the newest member of the L4 microkernel family. It is also the world’s first (currently the only one) general-purpose operating system which has passed the formal verification. However, as the micro-kernel system, seL4 currently provided little library function interface. RefOS is a typical multi-tasking operating system which built on seL4. This paper achieves the mmap function, providing memory mapping and sharing, as well as process copy which is similar with the fork function on RefOS. The child process can share the memory region which is marked as SHARED by mmap with its parent process. Our job provides support for implementing the POSIX standard interfaces on RefOS, as well as a lower-level interface for the development of parallel programs.

JCilk extends the serial subset of the Java language by importing the fork-join primitives spawn and sync from the Cilk multithreaded language, thereby providing call-return semantics for multithreaded subcomputations. In addition, JCilk transparently integrates Java’s exception handling with multithreading by extending the semantics of Java’s try and catch constructs, but without adding new keywords. This extension is “faithful” in that it obeys Java’s ordinary serial semantics when executed on a single processor. When executed in parallel, however, an exception thrown by a JCilk computation causes its sibling computations to abort, which yields a clean semantics in which the enclosing cilk try block need only handle a single exception.The exception semantics of JCilk allows programs with speculative computations to be programmed easily. Speculation is essential in order to parallelize programs such as branch-and-bound or heuristic search. We show how JCilk’s linguistic mechanisms can be used to program the “queens” puzzle and a parallel alpha–beta search. We have implemented JCilk’s semantic model in a prototype compiler and runtime system, called JCilk-1. The compiler implements continuations in a novel fashion by introducing goto statements into Java. The JCilk-1 runtime system shadows the dynamic hierarchy of cilk try blocks using a “try tree”, allowing the system to chase down side computations that must be aborted. Performance studies indicate that JCilk’s exception mechanism incurs minimal overhead, contributing at most a few percent on top of the cost for a spawn/return.