Kernel Primitives Research Articles

Spatial frequency performance limitations of radiation dose optimization and beam positioning

The flexibility and sophistication of modern radiotherapy treatment planning and delivery methods have advanced techniques to improve the therapeutic ratio. Contemporary dose optimization and calculation algorithms facilitate radiotherapy plans which closely conform the three-dimensional dose distribution to the target, with beam shaping devices and image guided field targeting ensuring the fidelity and accuracy of treatment delivery. Ultimately, dose distribution conformity is limited by the maximum deliverable dose gradient; shallow dose gradients challenge techniques to deliver a tumoricidal radiation dose while minimizing dose to surrounding tissue. In this work, this ‘dose delivery resolution’ observation is rigorously formalized for a general dose delivery model based on the superposition of dose kernel primitives. It is proven that the spatial resolution of a delivered dose is bounded by the spatial frequency content of the underlying dose kernel, which in turn defines a lower bound in the minimization of a dose optimization objective function. In addition, it is shown that this optimization is penalized by a dose deposition strategy which enforces a constant relative phase (or constant spacing) between individual radiation beams. These results are further refined to provide a direct, analytic method to estimate the dose distribution arising from the minimization of such an optimization function. The efficacy of the overall framework is demonstrated on an image guided small animal microirradiator for a set of two-dimensional hypoxia guided dose prescriptions.

A taste of Capsicum

Capsicum is a lightweight operating system (OS) capability and sandbox framework planned for inclusion in FreeBSD 9. Capsicum extends, rather than replaces, UNIX APIs, providing new kernel primitives (sandboxed capability mode and capabilities ) and a userspace sandbox API. These tools support decomposition of monolithic UNIX applications into compartmentalized logical applications, an increasingly common goal that is supported poorly by existing OS access control primitives. We demonstrate our approach by adapting core FreeBSD utilities and Google's Chromium Web browser to use Capsicum primitives, and compare the complexity and robustness of Capsicum with other sandboxing techniques.

Synchronization for fast and reentrant operating system kernel tracing

AbstractTo effectively trace an operating system, a performance monitoring and debugging infrastructure needs the ability to trace various execution contexts. These contexts range from kernel running as a thread to Non‐Maskable Interrupt (NMI) contexts. Given that any part of the kernel infrastructure used by a kernel tracer could lead to infinite recursion if traced, and because most kernel primitives require synchronization unsuitable for some execution contexts, all interactions of the tracing code with the existing kernel infrastructure must be considered in order to correctly inter‐operate with the existing operating system kernel. This paper presents a new low overhead tracing mechanism and motivates the choice of synchronization sequences suitable for operating system kernel tracing, namely local atomic instructions as main buffer synchronization primitive and the Read–Copy Update (RCU) mechanism to control tracing. It also proposes a wait‐free algorithm extending the time‐base needed by the tracer to 64‐bit on architectures that lack hardware 64‐bit time‐base support. Copyright © 2010 John Wiley & Sons, Ltd.

Genres in Action: The Pragmatics of Literary Interpretation

In my essay I argue for a rethinking of the concept of literary genre. I criticize the static, logico‐empirical approach still favoured by structuralist scholars of various stripes. I make the case for, and describe a dynamic and pragmatic model of literary genre as part of an interactive process of literary interpretation. I also outline one promising way to formulate such a model, based on interdisciplinary work in philosophical pragmatics and game theory.Specifically, I begin with a look of the concept of genre theory within Uri Margolin's tripartite system of deductive models in genre theory. I follow with a critique of the classical logic‐based, nonpragmatic view of literary forms as well as their reliance on structuralist kernel primitives, both of which characterize most deductive models. Using Kendal Walton's classical thought‐experiment from aesthetics, I argue against the persistent belief that literary forms are somehow empirically definable and immutable. On my view, aesthetic qualities of artworks are determined not just by purely structural (pictorial, textual, etc.) features, but by these features as seen through the work's category. In the remainder of my essay I develop an analytic model of genre‐guided strategies of reception, employed cooperatively and reflexively (in the Gricean sense) by the author and the reader.

Real-time behavior monitoring for multi-processor systems

Monitoring tools to observe the behavior of multi-task programs running on multi-processor architectures are important to help debugging complex real-time applications. To design such a tool, two issues are to be solved, relevant information gathering without disturbing the application behavior, display of this information in a way easily interpreted by designers. This paper presents a new solution for these two above issues. First, it describes a method and a tool to collect an event trace which can be implemented by software only or in an hybrid (software and hardware) way. Information to be collected are automatically selected from the tool and the overhead monitoring time is kept very low. Then, it describes the display tool which clearly shows to the designer the inter-function dependencies, all task states and execution times of real-time kernel primitives. This tool may also be used by designers to observe the value of relevant internal variables of the system. Our solution is target independent: it can be implemented on multi-transputer systems or on any conventional or heterogeneous microprocessor architectures.

On the identification of covert storage channels in secure systems

A practical method for the identification of covert storage channels is presented and its application to the source code of the Secure Xenix kernel is illustrated. The method is based on the identification of all visible/alterable kernel variables by using information-flow analysis of language code. The method also requires that, after the sharing relationships among the kernel primitives and the visible/alterable variables are determined, the nondiscretionary access rules implemented by each primitive be applied to identify the potential storage channels. The method can be generalized to other implementation languages, and has the following advantages: it helps discover all potential storage channels is kernel code, thereby helping determine whether the nondiscretionary access rules are implemented correctly; it helps avoid discovery of false flow violations and their unnecessary analysis; and it helps identify the kernel locations where audit code and time-delay variables need to be placed for covert-channel handling.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

A designer's perspective of the Hawk multiprocessor operating system kernel

The Hawk operating system kernel was specifically designed and implemented to support real-time applications on the SANDAC V embedded multiprocessor. The kernel provides a tasking model for program decomposition and supports message passing, synchronization, as well as other ancillary services. The kernel primitives have a Unix&amp;trade;-like system call interface to the C language and were designed to provide users a choice of level of abstraction, yet perform efficiently and behave predictably. Many design choices were limited by the type of environment the system was intended to support, namely, hard-real-time for missions of short duration. The system has been implemented and has supported applications for nearly two years. Measurements of kernel performance are herein reported. This paper is an overview of the Hawk kernel and a look backward at the decisions that were made in its design.

A predictable real-time kernel for distributed multisensor systems

The authors present a real-time kernel developed to support a distributed multisensor system encountered in robotics applications. To ensure predictability, the kernel provides services with bounded worst-case execution times. In addition, the kernel allows the programmer to specify timing constraints for process execution and interprocess communication. The kernel uses these timing constraints both for scheduling processes and for scheduling communications. To illustrate the kernel, the authors describe a multisensor system being developed on their distributed real-time system. They present the measured performance of kernel primitives along with conclusions and remarks regarding distributed real-time systems. >

Simulation and performance evaluation of parallel software on multiprocessor systems

The paper describes a technique to simulate the execution of parallel software on a generic multiple-processor architecture and to evaluate its actual performance. Parallel programs can be written easily in C, compiled with a standard compiler and linked with a simulator library to be run on a simulated parallel system. The parallel system and its kernel primitives are simulated by the library functions, and the executable code is run in a monoprogrammed environment. (Currently both PCs and Unix machines have been used.) Communication between processes uses a message exchange synchronization mechanism similar to that of the Inmos Transputer; the use of shared memory is also allowed. Architectural parameters of the simulated system, such as the number of processors, the allocation of processes to processors, the connection scheme and the speed of operation, are software configurable. A trace utility is also programmable to show the execution of some of the kernel primitives; this feature is very important for debugging and teaching purposes. A variety of statistical parameters are collected during the execution of a program to demonstrate its behaviour on the simulated system.

A real-time monitor for a distributed real-time operating system

Monitoring and debugging for a distributed real-time system is a complicated problem due to the lack of a set of advanced tools and adequate operating system capability. Software tools can cover the wide range of the software development life cycle from the requirement analysis phase to debugging and maintenance phases. However, many of these modern tools are not effective for building or analyzing complex real-time systems. Real-time software tools and effective kernel support are essential to reduce the complexity of real-time software. In this paper, we first address the issues in real-time monitoring and debugging, such as capturing the timing error, the monitor's invasive nature and visualization of system behavior. We then describe the architecture of the ART Real-Time Monitor which is being built for a distributed real-time OS, called ARTS. The built-in monitoring/debugging kernel primitives are also mentioned.

Multiprocessor Implementations of Tasking Facilities in ADA

This paper analyzes the efficiency problems related to the implementation of the ADA tasking facilities on monoprocessor and multiprocessor systems. Three different implementations of the basic communication mechanism in ADA - the rendezvous concept - are discussed and compared. The implementation approach is the same in the three cases and it consists of translating the ADA parallel constructs into procedural calls to kernel primitives. The kernel primitives corresponding to the most complex implementation are described.

Mutual exclusion within both software- and hardware-driven kernel primitives

Mutual exclusion between process and interrupt-driven execution is normally confined by the designer to passages within the kernel of an operating system and has been implemented traditionally by the judicious use of the interrupt inhibit instruction. This paper illustrates an alternative approach to the problem through the implementation of the conflicting software and hardware-driven kernel primitives as a limited set of concurrent subprocesses sharing a singular kernel domain. Manipulations of kernel data are rendered mutually exclusive through the use of P and V operations on simple semaphores associated with the data objects themselves. The kernel programmer is thereby relieved of real-time considerations in guarding his critical sections and the implementation of the kernel acquires a formalism which can greatly aid its verification, testability and maintainability.