3 research outputs found
Hare: a file system for non-cache-coherent multicores
Hare is a new file system that provides a POSIX-like interface on multicore processors without cache coherence. Hare allows applications on different cores to share files, directories, and file descriptors. The challenge in designing Hare is to support the shared abstractions faithfully enough to run applications that run on traditional shared-memory operating systems, with few modifications, and to do so while scaling with an increasing number of cores.
To achieve this goal, Hare must support features (such as shared file descriptors) that traditional network file systems don't support, as well as implement them in a way that scales (e.g., shard a directory across servers to allow concurrent operations in that directory). Hare achieves this goal through a combination of new protocols (including a 3-phase commit protocol to implement directory operations correctly and scalably) and leveraging properties of non-cache-coherent multiprocessors (e.g., atomic low-latency message delivery and shared DRAM).
An evaluation on a 40-core machine demonstrates that Hare can run many challenging Linux applications (including a mail server and a Linux kernel build) with minimal or no modifications. The results also show these applications achieve good scalability on Hare, and that Hare's techniques are important to achieving scalability.Quanta Computer (Firm
Providing a Shared File System in the Hare POSIX Multikernel
Thesis: Ph. D. in Computer Science, Massachusetts Institute of Technology, Department of Electrical Engineering and Computer Science, 2014.31Cataloged from PDF version of thesis.Includes bibliographical references (pages 71-73).Hare is a new multikernel operating system that provides a single system image for multicore processors without cache coherence. Hare allows applications on different cores to share files, directories, file descriptors, sockets, and processes. The main challenge in designing Hare is to support shared abstractions faithfully enough to run applications that run on traditional shared-memory operating systems with few modifications, and to do so while scaling with an increasing number of cores. To achieve this goal, Hare must support shared abstractions (e.g., file descriptors shared between processes) that appear consistent to processes running on any core, but without relying on hardware cache coherence between cores. Moreover, Hare must implement these abstractions in a way that scales (e.g., sharded directories across servers to allow concurrent operations in that directory). Hare achieves this goal through a combination of new protocols (e.g., a 3-phase commit protocol to implement directory operations correctly and scalably) and leveraging properties of non-cache coherent multiprocessors (e.g., atomic low-latency message delivery and shared DRAM). An evaluation on a 40-core machine demonstrates that Hare can run many challenging Linux applications (including a mail server and a Linux kernel build) with minimal or no modifications. The results also show these applications achieve good scalability on Hare, and that Hare's techniques are important to achieving scalability.by Charles Gruenwald, III.Ph. D. in Computer Scienc
Aspects of Code Generation and Data Transfer Techniques for Modern Parallel Architectures
Im Bereich der Prozessorarchitekturen hat sich der Fokus neuer Entwicklungen von immer höheren Taktfrequenzen hin zu immer mehr Kernen auf einem Chip verschoben.
Eine hohe Kernanzahl ermöglicht es unterschiedlich leistungsfÀhige Kerne anzubieten, und sogar dedizierte Kerne mit speziellen BefehlssÀtzen.
Die Entwicklung fĂŒr solch heterogene Plattformen ist herausfordernd und benötigt entsprechende UnterstĂŒtzung von Entwicklungswerkzeugen, wie beispielsweise Ăbersetzern.
Neben ihrer heterogenen Kernstruktur gibt es eine zweite Dimension, die die Entwicklung fĂŒr solche Architekturen anspruchsvoll macht: ihre Speicherstruktur.
Die Aufrechterhaltung von globaler Cache-KohÀrenz erschwert das Erreichen hoher Kernzahlen.
Hardwarebasierte Cache-KohĂ€renz-Protokolle skalieren entweder schlecht, oder sind kompliziert und fĂŒhren zu Problemen bei AusfĂŒhrungszeit und Energieeffizienz.
Eine radikale Lösung dieses Problems stellt die Abschaffung der globalen Cache-KohÀrenz dar.
Jedoch ist es schwierig, bestehende Programmiermodelle effizient auf solch eine Hardware-Architektur mit schwachen Garantien abzubilden.
Der erste Teil dieser Dissertation beschĂ€ftigt sich Datentransfertechniken fĂŒr nicht-cache-kohĂ€rente Architekturen mit gemeinsamem Speicher.
Diese Architekturen bieten einen gemeinsamen physikalischen Adressraum, implementieren aber keine hardwarebasierte KohÀrenz zwischen allen Caches des Systems.
Die logische Partitionierung des gemeinsamen Speichers ermöglicht die sichere Programmierung einer solchen Plattform.
Im Allgemeinen erzeugt dies die Notwendigkeit Daten zwischen Speicherpartitionen zu kopieren.
Wir untersuchen die Ăbersetzung fĂŒr invasive Architekturen, einer Familie von nicht-cache-kohĂ€renten Vielkernarchitekturen.
Wir betrachten die effiziente Implementierung von Datentransfers sowohl einfacher als auch komplexer Datenstrukturen auf invasiven Architekturen.
Insbesondere schlagen wir eine neuartige Technik zum Kopieren komplexer verzeigerter Datenstrukturen vor, die ohne Serialisierung auskommt.
Hierzu verallgemeinern wir den Objekt-Klon-Ansatz mit ĂŒbersetzergesteuerter automatischer software-basierter KohĂ€renz, sodass er auch im Kontext nicht-kohĂ€renter Caches funktioniert.
Wir prĂ€sentieren Implementierungen mehrerer Datentransfertechniken im Rahmen eines existierenden Ăbersetzers und seines Laufzeitsystems.
Wir fĂŒhren eine ausfĂŒhrliche Auswertung dieser Implementierungen auf einem FPGA-basierten Prototypen einer invasiven Architektur durch.
SchlieĂlich schlagen wir vor, HardwareunterstĂŒtzung fĂŒr bereichsbasierte Cache-Operationen hinzuzufĂŒgen und beschreiben und bewerten mögliche Implementierungen und deren Kosten.
Der zweite Teil dieser Dissertation befasst sich mit der Beschleunigung von Shuffle-Code, der bei der Registerzuteilung auftritt, durch die Verwendung von Permutationsbefehlen.
Die Aufgabe der Registerzuteilung wĂ€hrend der ProgrammĂŒbersetzung ist die Abbildung von Programmvariablen auf Maschinenregister.
WĂ€hrend der Registerzuteilung erzeugt der Ăbersetzer Shuffle-Code, der aus Kopier- und Tauschbefehlen besteht, um Werte zwischen Registern zu transferieren.
AbhĂ€ngig von der QualitĂ€t der Registerzuteilung und der Zahl der verfĂŒgbaren Register kann eine groĂe Menge an Shuffle-Code erzeugt werden.
Wir schlagen vor, die AusfĂŒhrung von Shuffle-Code mit Hilfe von neuartigen Permutationsbefehlen zu beschleunigen, die die Inhalte von einigen Registern in einem Taktzyklus beliebig permutieren.
Um die Machbarkeit dieser Idee zu demonstrieren, erweitern wir zunÀchst ein bestehendes RISC-Befehlsformat um Permutationsbefehle.
AnschlieĂend beschreiben wir, wie die vorgeschlagenen Permutationsbefehle in einer bestehenden RISC-Architektur implementiert werden können.
Dann entwickeln wir zwei Verfahren zur Codeerzeugung, die die Permutationsbefehle ausnutzen, um Shuffle-Code zu beschleunigen: eine schnelle Heuristik und einen auf dynamischer Programmierung basierenden optimalen Ansatz.
Wir beweisen QualitÀts- und Korrektheitseingeschaften beider AnsÀtze und zeigen die OptimalitÀt des zweiten Ansatzes.
Im Folgenden implementieren wir beide Codeerzeugungsverfahren in einem Ăbersetzer und untersuchen sowie vergleichen deren CodequalitĂ€t ausfĂŒhrlich mit Hilfe standardisierter Benchmarks.
ZunĂ€chst messen wir die genaue Zahl der dynamisch ausgefĂŒhrten Befehle, welche wir folgend validieren, indem wir Programmlaufzeiten auf einer FPGA-basierten Prototypimplementierung der um Permutationsbefehle erweiterten RISC-Architektur messen.
SchlieĂlich argumentieren wir, dass Permutationsbefehle auf modernen Out-Of-Order-Prozessorarchitekturen, die bereits Registerumbenennung unterstĂŒtzen, mit wenig Aufwand implementierbar sind