Separating presentation from interface in RPC and IDLs

Journal ArticleIn RPC-based communication, we term the interface the set of remote procedures and the types of their arguments; the presentation is the way these procedures and types are mapped to the target language environment in a particular client or server, including semantic requirements. For example, presentation includes the local names assigned to RPC stubs, the physical representation of a logical block of data (e.g., in-line, out-of-line, linked blocks), and trust requirements (e.g., integrity, security). In existing systems, the presentation of a given RPC construct is largely fixed. Separating presentation from interface, both in the interface definition language (IDL) itself and in the RPC implementation, is the key to interoperability, with many benefits in the area of elegance, as well. This separation and resulting cleanliness makes it manageable to generate specialized kernel code paths for each type of client-server pair. This is a key element o/end-to-end optimization. The separation should also allow the integration of disparate RPC optimization techniques, such as those applied in LRPC[2] and fbufs[6], into a single system, in a uniform and fully interoperable way. In initial work we demonstrate a variant of threaded code generation and two presentation-based optimizations, transparently activated by the RPC system. Each of these optimizations speeds up local RPC by approximately 25%.

Using annotated interface definitions to optimize RPC

Journal ArticleIn RPC-based communication, it is useful to distinguish the RPC interface, which is the "network contract" between the client and the server, from the presentation, which is the "programmer's contract" between the RPC stubs and the code that calls or is called by them. Presentation is usually a fixed function of the RPC interface, but some RPC systems, such as DCE and Concert, support the notion of a flexible presentation or endpoint modifier, allowing controlled modification of the behavior of the stubs on each side without affecting the contract between the client and the server. Up until now, the primary motivation for flexible presentation has been for programmer convenience and improved interoperability. However, we have found flexible presentation also to be useful for optimization of RPC, and in many cases necessary to achieving maximal performance without throwing out the RPC system and resorting to hand-coded stubs. In this paper we provide examples demonstrating this point for a number of different operating systems and IPC transport mechanisms, with RPC performance improvements ranging from 5% to an order of magnitude. In general, we observe that the more efficient the underlying IPC transport mechanism is, the more important it is for the RPC system to support flexible presentation, in order to avoid unnecessary user-space overhead?

Direct Inter-Process Communication (dIPC): Repurposing the CODOMs architecture to accelerate IPC

In current architectures, page tables are the fundamental mechanism that allows contemporary OSs to isolate user processes, binding each thread to a specific page table. A thread cannot therefore directly call another process's function or access its data; instead, the OS kernel provides data communication primitives and mediates process synchronization through inter-process communication (IPC) channels, which impede system performance. Alternatively, the recently proposed CODOMs architecture provides memory protection across software modules. Threads can cross module protection boundaries inside the same process using simple procedure calls, while preserving memory isolation. We present dIPC (for "direct IPC"), an OS extension that repurposes and extends the CODOMs architecture to allow threads to cross process boundaries. It maps processes into a shared address space, and eliminates the OS kernel from the critical path of inter-process communication. dIPC is 64.12× faster than local remote procedure calls (RPCs), and 8.87× faster than IPC in the L4 microkernel. We show that applying dIPC to a multi-tier OLTP web server improves performance by up to 5.12× (2.13× on average), and reaches over 94% of the ideal system efficiency.We thank Diego Marr´on for helping with MariaDB, the anonymous reviewers for their feedback and, especially, Andrew Baumann for helping us improve the paper. This research was partially funded by HiPEAC through a collaboration grant for Lluís Vilanova (agreement number 687698 for the EU’s Horizon2020 research and innovation programme), the Israel Science Fundation (ISF grant 769/12) and the Israeli Ministry of Science, Technology and Space.Peer ReviewedPostprint (author's final draft

Dynamic load balancing via thread migration

Light-weight threads are becoming increasingly useful for parallel processing. This is particularly true for threads running in a distributed memory environment. Light-weight threads can be used to support latency hiding techniques, communication and computation overlap, and functional parallelism. Additionally, dynamic migration of light-weight threads supports both data locality and load balancing. Designing a thread migration mechanism presents some very unique and interesting challenges. One such challenge is maintaining communication between mobile threads. A potentially more difficult challenge involves maintaining the correctness of pointers within mobile threads. Since traditional pointers have no concept of address space, moving threads from processor to processor has a strong impact on the use of pointers. Options for dealing with pointers include restricting their use, adding a layer of software to support pointers referencing non-local data, and binding data to threads such that referenced data is always local to the thread. This dissertation presents the design and implementation of Chant, an efficient light-weight threads package which runs in a distributed memory environment. Chant was designed and implemented as a runtime system using MPI like and Pthreads like calls. Chant supports point-to-point message passing between threads executing in distributed address spaces. We focus on the use of Chant as a framework to support dynamic load balancing based on thread migration. We explore many of the issues which arise when designing and implementing a thread migration mechanism, as well as the issues which arise when considering the use of thread migration as a means for performing dynamic load balancing. This load balancing framework uses both system state information, including communication history, and user input. One of the basic functionalities of this load balancing framework is the ability of the user to customize the load balancing to fit particular classes of problems. This dissertation provides implementation details as well as discussion and justification of design choices. We go on to show that the overhead associated with our approach is within an acceptable range, and that significant performance gains can be achieved through the use of thread migration as a means of performing dynamic load balancing

Applied (Meta)-Heuristic in Intelligent Systems

Engineering and business problems are becoming increasingly difficult to solve due to the new economics triggered by big data, artificial intelligence, and the internet of things. Exact algorithms and heuristics are insufficient for solving such large and unstructured problems; instead, metaheuristic algorithms have emerged as the prevailing methods. A generic metaheuristic framework guides the course of search trajectories beyond local optimality, thus overcoming the limitations of traditional computation methods. The application of modern metaheuristics ranges from unmanned aerial and ground surface vehicles, unmanned factories, resource-constrained production, and humanoids to green logistics, renewable energy, circular economy, agricultural technology, environmental protection, finance technology, and the entertainment industry. This Special Issue presents high-quality papers proposing modern metaheuristics in intelligent systems

The design and application of an extensible operating system

Tanenbaum, A.S. [Promotor

I-JVM: a Java Virtual Machine for Component Isolation in OSGi

The OSGi framework is a Java-based, centralized, component oriented platform. It is being widely adopted as an execution environment for the development of extensible applications. However, current Java Virtual Machines are unable to isolate components from each other. For instance, a malicious component can freeze the complete platform by allocating too much memory or alter the behavior of other components by modifying shared variables. This paper presents I-JVM, a Java Virtual Machine that provides a lightweight approach to isolation while preserving compatibility with legacy OSGi applications. Our evaluation of I-JVM shows that it solves the 8 known OSGi vulnerabilities that are due to the Java Virtual Machine. Overall, the overhead of I-JVM compared to the JVM on which it is based is below 20%

The dynamics of circumbinary discs and embedded planets

Since the first detection of a circumbinary planet with the Kepler space telescope in 2011 nine more circumbinary planets have been discovered. All these circumbinary Kepler systems have two things in common: First they are very flat, meaning that the orbit of the binary and the planet are in one plane, suggesting that they formed in an accretion disc surrounding both binary components. Second, the orbits of the planets are very close to the calculated stability limit. To explain the formation of these planets two scenarios are possible: An in situ formation at the observed location or a formation further outside in the disc followed by radial migration to the current observed position. Simulations have shown that an in situ formation is unlikely, due to destructive collisions of planetesimals on orbits close to the binary. The second scenario leads to the question of how the migrating planets can be stopped at the observed location. In this thesis the second scenario is examined through numerical simulations. The gravitational interaction between the binary and the disc leads to the formation of an eccentric inner gap, which precesses slowly in a prograde manner around the binary. This inner gap constitutes a barrier for a migrating planet. Therefore, the first part of this thesis investigates how binary parameters (eccentricity, mass ratio) as well as disc parameters (pressure, viscosity) influence the size, eccentricity, and precession period of the gap. The binary eccentricity (ebin) is identified as an important parameter. In the precession period – gap-size diagram a bifurcation occurs for varying ebin. Increasing the binary eccentricity from zero, precession period and gap-size decrease until a critical eccentricity of ebin = 0.18 is reached. From this point onward, precession period and gap-size increase again for increasing binary eccentricities. The binary mass ratio changes only the precession period, which decreases with increasing mass ratios, while the gap-size remains constant. For increasing viscosity and pressure in the disc the expected behaviour is observed: precession period and gap-size decrease. The second part of this thesis investigates the migration of planets in circumbinary discs. For five Kepler systems (Kepler-16, -34, -35, -38, -413) the dependence of the final orbital parameters on the planet-to-disc mass ratio is examined as well as the change in the disc structure due to the presence of the planet. The planets migrate in all cases to the edge of the gap, as expected. Depending on the planet mass, two migration scenarios are observed. Massive planets dominate the disc by shrinking and circularising the inner gap, whereas light planets are influenced by the disc. They align their orbits to the precessing disc and their eccentricity is excited. In general the final simulated orbital parameters are too large compared to the observations. Circumbinary planets around systems which create large, eccentric gaps (Kepler-34 and -413) also have the highest simulated eccentricities in agreement with the observations.Seit der ersten Entdeckung eines zirkumbinären Planeten mit dem Kepler Weltraumteleskop im Jahr 2011 wurden neun weitere Planeten entdeckt, die um einen Binärstern kreisen. All diese zirkumbinären Kepler Systeme haben folgende Gemeinsamkeiten: Sie sind planar, das heißt die Umlaufbahn des Planeten liegt in derselben Ebene wie die Umlaufbahn des Binärsterns, was auf eine Entstehung der Planeten in einer Akkretionsscheibe, die beide Komponenten des Binärsterns umgab, hindeutet. Des Weiteren liegt die Umlaufbahn all dieser Planeten sehr nahe am berechneten Stabilitätslimit. Für die Entstehung von zirkumbinären Planeten gibt es grundsätzlich zwei Erklärungsmöglichkeiten: Eine Entstehung direkt am Ort der heutigen Beobachtung oder eine Entstehung in den äußeren Bereichen der Scheibe, gefolgt von einer Migration zur beobachteten Position. Wie Simulationen gezeigt haben, ist eine Entstehung am Ort der Beobachtung unwahrscheinlich, da Planetesimale auf Umlaufbahnen in der Nähe des Binärsterns destruktiv kollidieren. Das zweite Szenario führt direkt zur Frage, wie die Migration der Planeten an der beobachteten Stelle gestoppt werden kann. In dieser Arbeit wird das zweite Szenario mit Hilfe von numerischen Simulationen untersucht. Die gravitative Interaktion zwischen Binärstern und Akkretionsscheibe führt zur Bildung einer zentralen, exzentrischen Lücke, die langsam prograd um den Binärstern präzediert. Diese innere Lücke formt eine Barriere für den migrierenden Planeten. Daher untersucht der erste Teil dieser Arbeit wie Parameter des Binärsterns (Exzentrizität, Massenverhältnis) und Parameter der Scheibe (Druck, Viskosität) die Größe, Exzentrizität und Präzessionsperiode der Lücke beeinflussen. Dabei stellt sich die Exzentrizität des Binärsterns (ebin) als ein wichtiger Parameter heraus. So zeigt sich, wenn man die Präzession der Lücke gegen ihre Größe darstellt, eine Bifurkation bei Variation von ebin. Erhöht man, von null ausgehend, die Exzentrizität des Binärsterns, so sinken zunächst die Präzessionsperiode und die Größe der Lücke. Dieses Verhalten ändert sich mit Erreichen einer kritischen Exzentrizität von ebin = 0.18, ab der Präzessionsperiode und Größe der Lücke wieder zunehmen. Das Massenverhältnis des Binärsterns hat lediglich Auswirkung auf die Präzessionsperiode, die mit steigendem Massenverhältnis sinkt, die Größe der Lücke bleibt konstant. Bei der Variation des Druckes und der Viskosität erhält man das erwartete Ergebnis, dass sich mit steigendem Druck und Viskosität die Größe der Lücke verringert. Im zweiten Teil dieser Arbeit wird der Migrationsprozess von Planeten in zirkumbinären Scheiben untersucht. Dazu wurde anhand von fünf Kepler Systemen (Kepler-16, -34, -35, -38 und -413) simuliert wie die finalen Bahnparameter vom Verhältnis der Planeten- und Scheiben- masse abhängen, und wie die Planeten die Struktur der Scheibe verändern. Wie erwartet migrieren die Planeten in allen Fällen bis zur Lücke. In Abhängigkeit der Planetenmasse zeigen sich zwei verschiedene Migrationsszenarien: Schwere Planeten dominieren die Scheibe, verringern die Größe der inneren Lücke und formen sie kreisförmiger. Leichte Planeten werden hingegen von der Scheibe dominiert. Sie richten ihren Orbit an der präzedierenden Lücke in der Scheibe aus und ihre Exzentrizität wird angeregt. Im Allgemeinen sind die simulierten finalen Bahnparameter, im Vergleich zu den Beobachtungen, zu groß. Zirkumbinäre Planeten um Systeme, welche sehr exzentrische Lücke erzeugen (Kepler-34 und -413) haben auch die höchsten simulierten Exzentrizitäten im Einklang mit den Beobachtungen

Energy-aware and adaptive fog storage mechanism with data replication ruled by spatio-temporal content popularity

Data traffic demand increases at a very fast pace in edge networking environments, with strict requisites on latency and throughput. To fulfil these requirements, among others, this paper proposes a fog storage system that incorporates mobile nodes as content providers. This fog storage system has a hybrid design because it does not only bring data closer to edge consumers but, as a novelty, it also incorporates in the system other relevant functional aspects. These novel aspects are the user data demand, the energy consumption, and the node distance. In this way, the decision whether to replicate data is based on an original edge service managed by an adaptive distance metric for node clustering. The adaptive distance is evaluated from several important system parameters like, distance from consumer to the data storage location, spatio-temporal data popularity, and the autonomy of each battery-powered node. Testbed results evidence that this flexible cluster-based proposal offers a more responsive data access to consumers, reduces core traffic, and depletes in a fair way the available battery energy of edge nodes.info:eu-repo/semantics/acceptedVersio