Java-Portierung eines Kad-basierten P2P-Systems
Werbung
Institut für Angewandte Mikroelektronik und Datentechnik Entwurf und Evaluation eines Kad-basierten P2PSystems für Android-Plattformen Projektbericht Bearbeiter: B.Sc. Arne Wall Betreuer: M.Sc. Michael Rethfeldt Dr.-Ing. Peter Danielis Aufgabenstellung 2 Aufgabenstellung Entwurf und Evaluation eines Kad-basierten P2P-Systems für Android-Plattformen Bestehende Client-Server-Lösungen, die als Basis für eine Vielzahl von Internet-Diensten dienen, enthalten eine zentrale Instanz, die einen Single Point of Failure darstellt. Peer-toPeer (P2P)-Netzwerke wie das Distributed Hash Table-basierte Kad-Netzwerk stellen eine Alternative in diesem Bereich dar und weisen positive Eigenschaften wie hohe Zuverlässigkeit und Skalierbarkeit auf. Sie sind als Netzwerktechnologie für die Vernetzung von einer Vielzahl von Geräten mit unterschiedlichen Betriebssystemen (BS) geeignet, wobei das Android-BS vor allem auf mobilen Geräten an Bedeutung gewinnt. Die Aufgabe dieser Projektarbeit ist es, ein Kad-basiertes Netzwerk für Android-Plattformen zu entwerfen und zu implementieren. Dabei sollen nützliche Anwendungen für das KadNetzwerk untersucht werden und schließlich soll eine anschauliche Demonstration von einem Netzwerk aus angeschlossenen Kad-Knoten auf Android-Plattformen vorgenommen werden. Eine detaillierte Diskussion der erzielten Ergebnisse ist einzubeziehen. Zusammenfassend sind folgende Aufgaben zu lösen: Analyse der Standes der Technik in Bezug auf P2P-Technologie und KadNetzwerk Ableitung von nützlichen Anwendungen für das Kad-Netzwerk auf AndroidPlattformen Entwurf der Architektur eines Kad-Knotens für Android-Plattformen Umsetzung des Kad-Knotens für Android-Plattformen Leistungsbewertung und Demonstration von einem Netzwerk aus verbundenen Kad-Knoten Inhaltsverzeichnis 3 Inhaltsverzeichnis AUFGABENSTELLUNG ............................................................................................................................... 2 INHALTSVERZEICHNIS ............................................................................................................................. 3 ABBILDUNGSVERZEICHNIS ..................................................................................................................... 4 TABELLENVERZEICHNIS ......................................................................................................................... 5 ABKÜRZUNGSVERZEICHNIS ................................................................................................................... 6 1 2 3 EINLEITUNG ........................................................................................................................................ 7 1.1 MOTIVATION ....................................................................................................................................... 7 1.2 AUFBAU DER ARBEIT ........................................................................................................................... 8 GRUNDLAGEN..................................................................................................................................... 9 2.1 P2P-NETZWERKE ................................................................................................................................. 9 2.2 KADEMLIA ......................................................................................................................................... 16 2.3 FREERTOS ........................................................................................................................................ 19 2.4 JAVA .................................................................................................................................................. 19 2.5 PROJEKTKONTEXT ............................................................................................................................. 20 IMPLEMENTIERUNG ...................................................................................................................... 23 3.1 WESENTLICHE UNTERSCHIEDE ZWISCHEN C++ UND JAVA ................................................................ 23 3.2 SYSTEMAUFRUFE VON FREERTOS .................................................................................................... 24 3.3 GRUNDLEGENDE SOFTWAREARCHITEKTUR ....................................................................................... 26 3.4 KAD-CLIENT ...................................................................................................................................... 29 4 ERGEBNISSE UND DISKUSSION ................................................................................................... 30 5 ZUSAMMENFASSUNG UND AUSBLICK ...................................................................................... 31 LITERATURVERZEICHNIS ..................................................................................................................... 32 Abbildungsverzeichnis 4 Abbildungsverzeichnis Abbildung 1: Server-Client-Konzept am Beispiel von FTP [12] ............................................................... 10 Abbildung 2: Dezentrale, vollständig vermaschte P2P-Netzwerkstruktur [12] ....................................... 11 Abbildung 3: Vergleich logisches Overlay / physikalisches Underlay [12] ............................................... 12 Abbildung 4: P2P-Netzwerktypen [14] ........................................................................................................ 14 Abbildung 5: Distributed Hash Table Ring [12] ......................................................................................... 15 Abbildung 6: Suchkomplexität O(log2(N)) durch binären Baum [12] ..................................................... 17 Abbildung 7: Iterativer Suchvorgang [12] .................................................................................................. 18 Abbildung 8: Rekursiver Suchvorgang [12]................................................................................................ 18 Abbildung 9: Java Abstraktion [21] ............................................................................................................ 20 Abbildung 10: Projektverlauf ...................................................................................................................... 22 Abbildung 11: Systemaufrufe ....................................................................................................................... 24 Abbildung 12: Netzwerkaufbau ................................................................................................................... 26 Abbildung 13: Kommunikation zwischen Threads [12] ............................................................................ 27 Abbildung 14: Paketverarbeitung [12] ........................................................................................................ 28 Abbildung 15: Kad-Client auf Windows Rechner ...................................................................................... 29 Tabellenverzeichnis 5 Tabellenverzeichnis Tabelle 1: Klassifizierung von P2P-Netzwerken [13] ................................................................................. 13 Abkürzungsverzeichnis Abkürzungsverzeichnis Abkürzung Bedeutung ARM Advanced Reduced Instruction Set Computer Machines DDoS Distributed Denial of Service DHT Distributed Hash Table DLNA Digital Living Network Alliance DNS Domain Name System IP Internet Protocol JVM Java Virtual Machine MD5 Message-Digest Algorithm 5 OS Operating System P2P Peer-to-Peer PC Personal Computer RT Real Time SPoF Single Point of Failure TCP Transmission Control Protocol UDP User Datagram Protocol VM Virtual Machine 6 Einleitung 7 1 Einleitung Ein Trend in der modernen Informationstechnik ist die zunehmende Gerätevernetzung. Dies zeigt sich in sogenannten Smart-Cities. Drahtlose Sensornetzwerke gewinnen an Bedeutung, da sie Informationen über Feinstaubbelastung, Lärm, Temperatur und Helligkeit liefern. Der Straßenverkehr innerhalb einer Smart-City lässt sich durch intelligente Verkehrsleitsysteme optimieren. Dem Alltagsnutzer allgegenwärtig sind Informationssysteme an Bahnhöfen, Flughäfen und öffentlichen Plätzen. Innerhalb einer Smart-City kommuniziert somit eine große Anzahl von Geräten miteinander. Die Skalierbarkeit solcher Gerätesysteme ist von großer Bedeutung. Eine weitere Entwicklung betrifft die Automatisierungstechnik. Hierbei sollen beispielsweise durch eine zunehmende Gerätevernetzung industrielle Fertigungsprozesse optimiert werden. Es finden sich viele Geräte zum Anlagen Monitoring. Logistikzentren werden für eine effiziente Warenauslieferung stärker vernetzt. Ein deterministisches Zeitverhalten solcher Systeme ist von grundlegender Bedeutung. Außerdem ist eine hohe Ausfallsicherheit von Systemen in der Industrieautomatisierung wichtig. Weiterhin werden Geräte verschiedener Hersteller im Bereich der Heimautomatisierung miteinander vernetzt. Ein Beispiel ist die Vernetzung von Multimediageräten via DNLA [1]. Dadurch ist es möglich, Multimediainhalte zwischen Geräten verschiedener Hersteller von Smartphones, Smart-TVs und Desktop PCs auszutauschen. Windows [2], Linux [3] und OS-X Rechner [4], Windows Phones [5], Android [6] und iOS [7] Geräte, Smart-TVs und andere Haushaltsgeräte kommunizieren miteinander. Die Interoperabilität zwischen verschiedenen Hardware- und SoftwarePlattformen muss gewährleistet sein. 1.1 Motivation Häufig basieren solche Anwendungen auf zentralisierten Architekturen. Dabei tauschen viele Clients Daten mit einem Server aus, der einen Single Point of Failure (SPoF) darstellt. Ein weiterer Nachteil solcher Systeme ist die schlechte Skalierbarkeit. Eine wachsende Anzahl von Clients kann nicht mehr so gut bewältigt werden. Die Netzwerkanbindung des Servers stellt einen Flaschenhals dar und sämtliche Anfragen muss dieser Server bearbeiten. Einleitung 8 Daraus resultiert die Anfälligkeit für Distributed Denial of Service (DDoS) Attacken, bei denen ein Angreifer versucht, das System mit vielen Anfragen von vielen Clients auszulasten. Häufig wird versucht, solchen Szenarien durch eine schnellere Netzwerkanbindung und mehr Rechenkapazität entgegenzuwirken. Um diesen Problemen zu begegnen, empfiehlt sich die Verwendung von dezentralen Architekturen wie sie Peer-to-Peer-Netzwerke (P2P) aufweisen. Die Anwendungen befinden sich oberhalb der P2P-Schicht. Das P2P-Netzwerk dient der Verwaltung der einzelnen Geräte. Das Beitreten neuer Knoten in ein bestehendes Netzwerk, das Suchen anderer Geräte und der Dateiaustausch werden unabhängig von der Anwendung durchgeführt. Das P2P-Protokoll kann somit als eine Art Middleware aufgefasst werden. Eine Anwendung oberhalb der Middleware nutzt deren Vorteile. In dieser Arbeit wurde das P2P-Protokoll „Kademlia“ [8] mit dessen C++-Implementierung „Kad“ verwendet. Da C++ [9] eine plattformabhängige Sprache ist, soll „Kad“ in die plattformunabhängige Sprache Java [10] portiert werden. Für verschiedene Betriebssysteme lassen sich dann P2PAnwendungen, basierend auf Kademlia, entwickeln. Selbst Android-Geräte [6] sollen künftig dem P2P-Netzwerk beitreten können. 1.2 Aufbau der Arbeit Zunächst wird in Abschnitt 2 auf P2P-netzwerktechnische Grundlagen eingegangen und die Wahl auf das P2P-Netzwerkprotokolls „Kademlia“ begründet. Da die Implementierung „Kad“ von Kademlia auf dem Echtzeitbetriebssystem FreeRTOS basiert, soll dieses kurz beschrieben werden. Anschließend wird auf die plattformunabhängige Sprache Java eingegangen. Weiterhin soll diese Projektarbeit in den Projektkontext eingeordnet werden. Abschnitt 3 beschreibt die Portierung von Kad in die Sprache Java. Dabei wird auf die relevanten Unterschiede zwischen C++ und Java eingegangen. Weiterhin findet sich eine Analyse, welche Systemaufrufe die vorliegende Implementierung verwendet. Außerdem beschreibt Abschnitt 3 die Softwarearchitektur von „Java-Kad“ und ein Tool zum Debuggen und Testen der Portierung. Abschnitt 4 beschreibt den aktuellen Stand der Arbeit. Anknüpfende Untersuchungen / Arbeiten skizziert Abschnitt 5. Grundlagen 9 2 Grundlagen Im Rahmen dieser Arbeit wird das P2P-Protokoll „Kademlia“ zur Gerätevernetzung verwendet. Dieses Kapitel erläutert zunächst allgemeine P2P-netzwerktechnische Grundlagen. Anschließend findet sich eine Erläuterung zum gewählten P2P- Netzwerkprotokoll (Kademlia). Weiterhin beschreibt dieses Kapitel das der Kademlia-C++Implementierung „Kad“ zugrundeliegende Echtzeitbetriebssystem FreeRTOS. Anschließend findet sich ein Abschnitt, der die Wahl auf die Sprache „Java“ zur Portierung begründet. Der Projektkontext dieser Arbeit soll ebenfalls betrachtet werden. 2.1 P2P-Netzwerke Häufig ist in Computernetzwerken eine zentralisierte Architektur zu finden. Server und Clients bilden dabei die grundlegenden Gerätetypen. Im Zentrum befindet sich ein Server, der von vielen Clients kontaktiert wird. Ein Anwendungsbeispiel (Abbildung 1) ist das File Transfer Protokoll (FTP) [11]. Ein zentraler FTP-Server stellt Dateien zur Verfügung. Weiterhin können Clients Dateien auf dem Server speichern. Eine solche zentralisierte Netzwerktopologie weist einen serverseitigen Flaschenhals auf. Die Netzwerkanbindung des Servers kann maximal ausgelastet sein, so dass weitere Anfragen von Clients nicht mehr beantwortet werden können. Es kommt zu einem Ausfall der Dienstverfügbarkeit (Denial of Service) [12]. Grundlagen 10 ftp://username:password@host:port/path Server Client Abbildung 1: Server-Client-Konzept am Beispiel von FTP [12] Im Gegensatz zum Server-Client-Prinzip steht das P2P-Paradigma (Abbildung 2). Server und Clients werden nicht mehr getrennt voneinander betrachtet. Ein Peer kann sowohl Server- als auch Client-Funktionalität annehmen. Soll eine große Datenmenge, wie beispielsweise ein Film, vom Netzwerk bezogen werden, so können mehrere Knoten (Peers) die Daten bereitstellen. Die Netzwerklast lässt sich besser verteilen. Eine Architektur dieser Art weist keinen SPoF mehr auf. Fallen ein oder mehrere Knoten aus, so kann das gesamte Netzwerk weiterarbeiten. Dies ist möglich, da sich Daten redundant im Netzwerk speichern lassen. Durch die erhöhte Ausfallsicherheit von P2P-Netzwerken sind solche Netzwerkarchitekturen für industrielle Anwendungen denkbar [12]. Grundlagen 11 Abbildung 2: Dezentrale, vollständig vermaschte P2P-Netzwerkstruktur [12] Abbildung 2 zeigt eine Form der logischen Verknüpfung von Knoten. Diese Schicht wird als „logisches Overlay“ bezeichnet. Demgegenüber steht der physikalische Netzwerkaufbau, auch als physikalisches Underlay benannt. Knoten, die auf der logischen Verknüpfung benachbart sind, können in dem physikalischen Underlay durch eine netzwerktechnische Distanz voneinander getrennt sein [12]. große Grundlagen 12 5 4 1 3 2 logisches Overlay 4 3 1 physikalisches Underlay 2 5 Abbildung 3: Vergleich logisches Overlay / physikalisches Underlay [12] Abbildung 3 zeigt, dass die Knoten 1 und 2 im logischen Overlay direkt verbunden sind und somit eine geringe netzwerkstechnische Distanz aufweisen. Das P2P-Netzwerk ist vollständig vermascht. Das physikalische Underlay hingegen beschreibt die reale Verknüpfung der Rechner. Hierbei weisen die Knoten 1 und 2 eine große Distanz auf, da sich mehrere Netzwerkgeräte (z.B. Switches oder Router) zwischen ihnen befinden. P2PNetzwerke lassen sich anhand ihres logischen Overlays klassifizieren (Tabelle 1) [12]. Grundlagen 13 Unstrukturiert Strukturiert Zentral Dezentral Hybrid DHT basiert - Zentrale Instanz - zentrale Instanz - Gruppenbildung - keine Verwendung managet Netzwerk nicht vorhanden von mehreren einer zentralen - Managementeinheit - Rechner lassen Knoten Instanz verweist auf Knoten sich aus dem - Gruppen werden - Gesamtnetzwerk - Management stellt Netzwerk nehmen, durch Super-Peers bleibt nach Ausfall SPoF dar ohne dass das vertreten beliebiger Rechner Gesamtnetzwerk - Netzwerk bleibt intakt. ausfällt bei Ausfall eines beliebigen Rechners bestehen Bsp.: Napster Bsp.: Gnutella 0.4 Bsp.: JXTA Bsp.: Kademlia Tabelle 1: Klassifizierung von P2P-Netzwerken [13] Die zwei Hauptgruppen sind die unstrukturierten und die strukturierten Netzwerke. Weiterhin lässt sich die unstrukturierte Gruppe in zentralisierte, dezentralisierte und hybride Netzwerke klassifizieren. Bei einem unstrukturierten P2P-Netzwerk erfolgt im Gegensatz zu den strukturierten Netzwerken keine systematische Bindung von Daten an bestimmte Knoten. Abbildung 4 zeigt die schematische Darstellung der einzelnen P2P-Netzwerktypen. Bei einem unstrukturierten zentralisierten Ansatz organisiert ein zentraler Server die Verbindungen zwischen allen Peers. Der Server, welcher einen SPoF darstellt, fehlt bei einem unstrukturierten dezentralen P2P-Netzwerk. Weiterhin existiert eine hybride Form zwischen zentralisierten und dezentralisierten unstrukturierten Netzwerken. Dabei werden die Peers in Gruppen zusammengefasst, die durch jeweils einen Super-Peer verwaltet werden. Der Super-Peer trägt die Kommunikation zwischen den einzelnen Gruppen [12], [14]. Grundlagen 14 a) unstrukturiert, zentralisiert (Verbindungen zum zentralen Server in Rot markiert) c) unstrukturiert, hybrid (Super-Peers in Rot markiert) b) unstrukturiert, dezentralisiert d) strukturiert, DHT-Ring Abbildung 4: P2P-Netzwerktypen [14] In einem strukturierten Distributed Hash Table (DHT) -basierten P2P-Netzwerk erfolgen eine Zuordnung von Daten zu den Knoten und eine feste Adressierung von Daten und Knoten. Bei einem DHT-basierten Verfahren existiert ein Ring, der den Adressraum mit nBit darstellt (Abbildung 5). Jeder Knoten erhält über den Hashwert, beispielsweise gebildet über seine IP-Adresse, seinen Platz auf den DHT-Ring. Um eine Zuordnung der Daten zu erreichen wird ebenfalls der Hashwert über z.B. den Dateinamen gebildet. Befindet sich dieser Hashwert im Bereich um einen Knoten, so ist dieser Knoten für die Verwaltung dieses Datums zuständig. Es lassen sich neben Daten auch Services den Peers zuordnen. Es entsteht eine Service-orientierte Architektur [15] [12]. Grundlagen 15 2n-1 0 Peer Datum/Service Abbildung 5: Distributed Hash Table Ring [12] Da bei einem DHT-basierten P2P-Netzwerk keine zentrale Instanz, die zu einem SPoF führt, vorhanden ist und die Daten strukturiert im Netzwerk abgelegt werden, fiel die Wahl auf den Vertreter „Kademlia“. Grundlagen 16 2.2 Kademlia 2002 entwickelten Petar Maymounkov und David Mazieres von der University of New York Kademlia. Dieses Protokoll basiert auf einer Distributed Hash Table (DHT). Über die DHT können Daten in strukturierter Form abgelegt und abgerufen werden [12]. Das Netzwerk organisiert sich über die DHT selber. Verschiedene Anwendungen können auf Kademlia aufsetzen und dessen Vorteile (einfache Integration neuer Knoten, dezentrale Verwaltung, geringe Suchkomplexität) nutzen [12]. Wenn ein neuer Knoten einem bestehenden Kademlia-Netzwerk beitritt, führt er den Bootstrap-Vorgang aus. Dabei wird ein vorher bekannter, dem Netzwerk angehöriger, Knoten kontaktiert. Dieser antwortet mit zufälligen Einträgen aus seiner Routingtabelle. Die Routingtabelle enthält unter anderem Informationen über Hashwert und zugehörige IPAdresse eines Knotens. Der neu beigetretene Knoten besitzt nach dem Bootstrap-Vorgang Informationen über Kontakte und ist somit in das Kademlia-Netzwerk eingebunden. Knoten haben eine Lebensdauer, bei deren Ablaufen dieser Knoten angesprochen wird. Wenn der Knoten nicht antwortet, wird die Routingtabelle durch Entfernen des entsprechenden Eintrags aktualisiert. Kademlia weist im Gegensatz zu unstrukturierten zentralisierten Systemen keinen SPoF auf. Durch die ebene Hierarchie kann jeder Knoten durch einen anderen Knoten ersetzt werden [12]. Die C++-Implementierung von Kademlia, „Kad“, nutzt den MD4-Algorithmus um Hashwerte zu berechnen. Der Hashwert eines Knotens ergibt sich beispielsweise über dessen IP-Adresse. Dem Hashwert entsprechend erhält der Knoten seinen Platz auf dem DHT-Ring. Soll ein Datum im Kad-Netzwerk gefunden werden, so wird die XOR-Distanz zwischen Hashwert des Datums und des Knotens gebildet. Liegt die XOR-Distanz in der Suchtoleranz eines Knotens (Bereich um einen Knoten herum), so ist dieser Knoten für die Verwaltung dieses Datums zuständig. Dieses Verfahren wird als Prefix-Matching-Verfahren bezeichnet. Eine Übereinstimmung vieler führender Bits ergibt eine kleine Distanz. Ein Vorteil vom strukturierten P2P-Netzwerk Kademlia ist die Suche von Daten, die nie zu einem FalseNegative-Ergebnis führt, wenn die Suchtoleranz genügend groß ist [12]. Netzwerke, die auf DHT basieren, weisen eine geringe Suchkomplexität von 𝑂(log 2 ( 𝑛)) auf. Dies wird durch eine Routingtabelle ermöglicht, die sich in einem binären Baum organisiert (Abbildung 6). Die Kontakte eines Knotens befinden sich in dessen Routingtabelle. Dieses Routing bezieht sich, im Gegensatz zum Routing auf IP-Ebene, auf die Anwendungsebene von Kademlia [12]. Grundlagen 17 XOR-Distanz in einem 4-Bit Adressraum 1111 0000 1 0 1 0 1 Knoten 0 1 0 Kontakte des Knotens k-Bucket Abbildung 6: Suchkomplexität O(log2(N)) durch binären Baum [12] Um Knoten in einem Kademlia-Netzwerk zu finden, kann ein iterativer (Abbildung 7) oder ein rekursiver (Abbildung 8) Suchvorgang durchgeführt werden. Der Zielhashwert ist entweder der Hashwert des gesuchten Knotens oder liegt im Bereich der Suchtoleranz des Zielknotens. Beim iterativen Suchvorgang kontaktiert der suchende Knoten sukzessive andere Knoten. Dabei antwortet jeder Knoten mit einem Kontakt aus seiner Routingtabelle, der im nächsten Iterationsschritt angesprochen wird. Dieser Vorgang wird solange wiederholt, bis der Zielknoten erreicht ist. Alternativ können Knoten über den rekursiven Suchvorgang erreicht werden. Dabei leitet der vom suchenden Knoten angesprochene Knoten die Suchanfrage direkt an den nächsten Knoten weiter. Erst der Zielknoten schickt eine Antwort an den suchenden Knoten. Ein Vorteil ist die geringere Suchlatenz, da im Gegensatz zum iterativen Suchalgorithmus keine Pakete von allen Knoten zum suchenden Knoten gesendet werden. Um eine erfolgreiche Suche zu gewährleisten, sollte kein Knoten innerhalb der Suchkette ausfallen [12]. Grundlagen 18 1 2 3 4 Zielknoten 5 Suchender Knoten 6 Abbildung 7: Iterativer Suchvorgang [12] 2 1 3 Zielknoten Suchender Knoten 4 Abbildung 8: Rekursiver Suchvorgang [12] Kad wurde in der Sprache C++ implementiert. Innerhalb von Kad finden sich Betriebssystemaufrufe des Echtzeitbetriebssystems FreeRTOS. Dadurch ist die Software an eine feste Softwareplattform gebunden. Außerdem existiert eine Hardwareabhängigkeit, da FreeRTOS nur auf bestimmten Architekturen ausgeführt werden kann. Der folgende Abschnitt beschreibt FreeRTOS. Grundlagen 19 2.3 FreeRTOS FreeRTOS [16] ist ein von Real Time Engineers Ltd. stammendes Echtzeitbetriebssystem. Es unterstützt 35 Architekturen. Programme basierend auf FreeRTOS lassen sich in Threads aufteilen. So ist es beispielsweise möglich, einen Thread zum Empfang von Netzwerkpaketen aufzusetzen. Über verschiedene Kommunikationsmechanismen, wie Message Queues, Semaphoren und Mutexe, können andere Threads die empfangenen Pakete weiterverarbeiten. Den einzelnen Threads lassen sich Prioritäten zuweisen, sodass sich über ein prioritäts-basiertes Scheduling ein zeitlich deterministisches Programmverhalten erzielen lässt. Weiterhin beinhaltet FreeRTOS den lwip-Stack. Dies ist ein „leichtgewichtiger“ TCP/IP-Stack zur Netzwerkkommunikation [17]. Da Kad durch die Programmierung in C++ an die Verwendung der entsprechenden Betriebssystemaufrufe (Threadmanagement, Semaphoren, Mutexe, Netzwerkkommunikation) von FreeRTOS gekoppelt ist, soll Kad zur Erhöhung der Plattformunabhängigkeit in die Programmiersprache Java portiert werden. 2.4 Java Java eignet sich als Programmiersprache für die Gerätevernetzung, da sie eine plattformunabhängige Sprache ist (Abbildung 9). Der Java-Quellcode wird zunächst in einen Byte-Code übersetzt und anschließend auf einer Java virtual machine (virtuelle Java Maschine, kurz: JVM) ausgeführt. JVMs sind für verschiedene Systeme verfügbar. Somit ist es beispielsweise möglich, die Java-Anwendung auf einem Windows-Rechner zu entwickeln und zu testen und auf einem Linux-Rechner, wie dem Einplatinen-Computer Raspberry Pi [18], laufen zu lassen. Neben der Unabhängigkeit vom verwendeten Betriebssystem besteht eine Unabhängigkeit von der Hardwareplattform. Weiterhin bietet das mobile Betriebssystem Android die Möglichkeit, die Apps in Java zu entwickeln. Diese Apps laufen in einer virtuellen Maschine (VM) namens Dalvik [19]. Ab Android der Version 4.4 ist eine VM mit verbesserter Performance, genannt ART [20], verfügbar. Grundlagen 20 Java Quelltext Compiler Java Bytecode Java Virtual Machine Betriebssystem Hardware Abbildung 9: Java Abstraktion [21] 2.5 Projektkontext Diese Arbeit steht im Kontext eines größeren Projektes zur P2P-basierten Gerätevernetzung. Abbildung 10 zeigt den Verlauf mit dessen Phasen. 2007 begann die Entwicklung eines verteilten DNS (P-DONAS [22]), eines Systems zur verteilten Berechnung (DuDE [23]) sowie einer Architektur, die eine verteilte Speicherung ermöglicht. Die Softwareentwicklung erfolgte in der Programmiersprache C++ auf einem Windowsrechner, basierend auf einer x86-Architektur. Eine Ausführung der Software auf einem x86-64 Prozessor ist ebenfalls möglich. In der nächsten Projektstufe im Jahr 2009 wurde der Anwendungsfall „P-DONAS“ auf eine andere Hardwareplattform übertragen. Dabei kamen Virtex 4/5 [24] Entwicklungsboards zum Einsatz. Diese basieren auf einem PowerPC [25], auf dem ein Linux-ähnlicher Xilkernel [26] ausgeführt wird. In der dritten Projektstufe (2012) ist es möglich, Anwendungen echtzeitfähig zu machen. Das P2P-Netzwerk basiert auf dem Echtzeitbetriebssystem „FreeRTOS“. Der zeitlich deterministische Datenaustausch zwischen einzelnen Knoten erfolgt über Zeitschlitze. Die Zeitsynchronisierung lässt sich in dezentraler Form durchführen [27]. dafür notwendige Grundlagen 21 Zur Entwicklung von echtzeitfähigen Anwendungen, wie HaRTKad [28] (zur Industrieautomatisierung), und nicht echtzeitfähigen Anwendungen, wie MultiKad [29] (Smart City/Home) und Geräte-Discovery/Eventing, CoHaRT (HartKad mit CoAP Block Transfer zur Dateiübertragung), werden ZedBorads [30] mit einem ARM-Prozessor [31] genutzt. Phase vier verfolgt die Verwendung von Kad auf Raspberry Pi’s mit einem ARMProzessor als Hardwareplattform und einem RT-Linux als Softwareplattform. Dabei handelt es sich um ein echtzeitfähiges Linux mit einem Preemptive-Patch[32], der EchtzeitScheduling und Unterbrechbarkeit von Kernel-Routinen ermöglicht. Die Anwendungssoftware samt P2P-Netzwerk wird nach wie vor in der Sprache C++ entwickelt. Da die Software bislang jeweils an eine spezielle Hardwareplattform und an ein Betriebssystem gebunden war, soll mit dieser Arbeit eine Plattformunabhängigkeit erreicht werden. Dies lässt sich durch die Verwendung der plattformunabhängigen Sprache Java erzielen. Dazu soll die C++-Implementierung des P2P-Protokolls Kademlia namens Kad in Java portiert werden. Allerdings verliert das System durch die Verwendung einer Java virtual machine (virtuelle Java Maschine) die Echtzeitfähigkeit. Herkömmliche Java virtual machines sind nicht Echtzeitfähig, da nicht mehr benötigter Speicher durch einen „Garbage Collector“ freigegeben wird. Der Garbage Collector arbeitet sporadisch, sodass keine zeitlich deterministische Ausführung einer Java-Anwendung möglich ist. Die Zukunftsvision beschreibt neben Unabhängigkeit gegenüber einer Hardware und eines Betriebssystems die Echtzeitfähigkeit. Dieses Ziel lässt sich durch die Verwendung einer echtzeitfähigen virtuellen Maschine für Java erreichen. Abbildung 10: Projektverlauf ZedBoard (ARM) Virtex 4/5 (PowerPC, Microblaze) Desktop-PC (x86/x64) Nein Geräteklasse/ (Architektur) Echtzeitfähigkeit Anwendungen C++ C++ C++ Programmiersprache Ja (soft) Raspb. Pi (ARM) - Smart City/Home: - Geräte Discovery (MultiKad) - Eventing - Industrieautomatisierung (HaRTKad) - CoAP Block Transfer (CoHaRT) - Verteiltes Netzwerkmanagement Nein unabhängig Java unabhängig RT Linux (Preemp.Patch Kernel) C++ 2015 2014 - DNS (P-DONAS), verteilte Berechnung (DuDE), verteilte Speicherung (PSP) Ja (hart) FreeRTOS Xilkernel/ Linuxlike Windows OS Nein 2012 2009 2007 Alle bisherigen Anwendungen Ja (über RT VM) unabhängig Java unabhängig Vision Grundlagen 22 Implementierung 23 3 Implementierung Dieses Kapitel beschreibt die Implementierungsdetails der Portierung von Kad (C++) in die Sprache Java. Dazu werden zunächst die relevanten Unterschiede zwischen C++ und Java erläutert. Die von Kad verwendeten Systemaufrufe von FreeRTOS sollen in Abschnitt 3.2 aufgezeigt und die äquivalenten Verwendungen in der JVM beschrieben werden. Anschließend erläutert Abschnitt 3.3 die grundlegende Softwarearchitektur. Abschnitt 3.4 beschreibt das zum Debuggen und Testen verwendete Komandozeilen-Tool. 3.1 Wesentliche Unterschiede zwischen C++ und Java C++ und Java sind objektorientierte Sprachen, dennoch unterscheiden sie sich in einigen Merkmalen. An dieser Stelle sollen nur die für die Portierung wesentlichen Unterschiede betrachtet werden. In C++ erfolgt die Verwaltung der einzelnen Quellcodedateien über Header-Dateien [33]. In einer Header-Datei können weitere Header eingefügt sein. Java ermöglicht typische Header-Datei-Funktionen über Interfaces [34]. Ein Interface beinhaltet die Methodendeklarationen einer Klasse. Unter Java lässt sich der Quellcode über Packages strukturieren. Ein Package (Paket) enthält Klassen und Typen [35]. Bei der Portierung von C++ zu Java wurde darauf geachtet eine übersichtliche Codestruktur beizubehalten. Wenn ein Programm während der Laufzeit Speicher benötigt, fordert es diesen über eine malloc-Funktion an [36]. Solange genügend freier Speicher vorhanden ist, kann der Speicher über malloc reserviert werden. Wird der Speicher nicht mehr benötigt, muss die Freigabe explizit im Quellcode angegeben werden [37]. In Java lässt sich neuer Speicher über „new“ allokieren. Nicht mehr benötigter Speicher muss nicht explizit freigegeben werden. Die Freigabe managet ein sogenannter „Garbage Collector“ [38], welcher Bestandteil der Java Laufzeitumgebung ist. Durch das nicht-deterministische Zeitverhalten des Garbage Collectors ist keine Echtzeitfähigkeit möglich. Die Sprache C++ sieht zwei Möglichkeiten zur Parameterübergabe an Methoden vor: „Call by Value“ und „Call by Reference“. Bei einer Call by Value - Übergabe erfolgt nur ein Austausch des Wertes einer Variablen. Innerhalb der mit Call by Value aufgerufenen Methode wird mit einer Kopie der Variablen gearbeitet. Wird die Methode über ein Call by Reference - Verfahren aufgerufen, so wird die Variable selber übergeben. Aufrufende und aufgerufene Methode arbeitet jeweils mit derselben Variablen. Implementierung 24 Java sieht nur einen Call by Reference - Aufruf vor. Soll sichergestellt werden, dass aufrufende und aufgerufene Methode mit der gleichen Variablen arbeiten, so muss der aufgerufenen Methode eine Kopie übergeben werden. 3.2 Systemaufrufe von FreeRTOS Da Kad Funktionalitäten von FreeRTOS aufruft, ist Kad an diese Plattform gebunden. Die Systemaufrufe müssen in äquivalente Aufrufe der Java-Laufzeitumgebung (Java Runtime Environment) portiert werden. Java Runtime Environment FreeRTOS Threads Semaphoren / Mutexe Sockets komplexe Datentypen Zeitmessung Abbildung 11: Systemaufrufe Abbildung 11 zeigt, welche Hauptfunktionalitäten in FreeRTOS von Kad verwendet werden. Das Programm unterteilt sich in einzelne Threads. Zur Synchronisierung zwischen den Threads finden Semaphoren bzw. Mutexe Verwendung. Die Netzwerkkommunikation erfolgt über Sockets. Um Daten abzulegen, finden sich komplexe Datentypen, wie Warteschlangen, Maps und Listen. Um Zeiten zu messen, finden sich in Kad entsprechende FreeRTOS-Aufrufe. Alle genannten Funktionen sollen näher erläutert werden: Um das Programm zu strukturieren und eine parallele Ausführung zu ermöglichen, wurde Kad in einzelne Threads unterteilt. Eine genauere Beschreibung der Softwarearchitektur findet sich in 3.3. Eine Java-Klasse, die den auszuführenden Code beinhaltet, muss das Interface „java.lang.Runnable“ [39] implementieren. Implementierung 25 Das Interface schreibt vor, dass die Klasse eine Implementierung für eine run-Methode liefern muss. In der run-Methode befindet sich die Funktionalität des Threads. Beim Erstellen eines Threads wird dem Thread-Konstruktor ein Objekt übergeben, dass die runMethode enthält. Der Thread als instanziiertes Objekt kann über die Methode „start()“ [40] ausgeführt werden [35]. Wenn einzelne Threads auf gemeinsame Daten zurückgreifen, muss der Zugriff synchronisiert werden. Dazu lassen sich Semaphoren verwenden. Die Semaphore zählt, wie viele Teilnehmer maximal auf die Ressource zugreifen dürfen. Ist die maximale Zahl erreicht, müssen alle anderen Teilnehmer, die ebenfalls auf die Ressource zurückgreifen wollen, warten. Ein Mutex ist ein Sonderfall eines Semaphors, da bei einem Mutex nur maximal ein Teilnehmer (Thread) auf die Ressource zugreifen darf. Die in FreeRTOS verwendeten Semaphoren und Mutexe lassen sich ebenfalls in Java verwenden. Für Semaphoren steht die Klasse „java.util.concurrent.Semaphore“ [41] zur Verfügung. Wenn ein Semaphoren-Objekt instanziiert wird, so muss im Konstruktor die Anzahl an maximal auf die Ressource zugreifenden Teilnehmern definiert werden. Ist dieser Wert eins, handelt es sich um einen Mutex. Die Methodenaufrufe zum Belegen und Freigeben eines Semaphors wurden angepasst [42]. Damit die Software über das Netzwerk Pakete austauschen kann, sind Sockets notwendig. Diese sind durch das Transportprotokoll (TCP [43] oder UDP [44]), die eigene IP-Adresse [45] und den Port definiert. Die Original-Implementierung von Kad nutzt zum Arbeiten mit Sockets den lwIP-Stack. Unter Java findet sich die Klasse java.net.DatagramSocket, um UDP-Sockets aufzusetzen und zu verwalten [46]. Eine Datenübertragung über TCP wird in Kad nicht genutzt. Ankommende Pakete werden innerhalb von Kad in eine Warteschlange eingeordnet. Als First-In-First-Out-Speicher (FIFO-Speicher) wird eine „Linked List“ genutzt. Neue Elemente werden an das Ende der Liste angefügt. Das Lesen und das damit verbundene Entfernen eines Elements von der Liste geschehen beim ersten Listenelement. Java liefert dafür die Klasse java.util.LinkedList [47]. Weiterhin finden sich in Kad „Hash-Maps“ als komplexe Datentypen. Dabei wird einem Wert ein Schlüssel (Hashwert) zugeordnet. Es entsteht die Hash-Map, ein Paar aus zwei Elementen (Wert und Hashwert) [48]. Für Echtzeitanwendungen [27] sind Zeitmessungen notwendig. Die ursprüngliche KadImplementierung greift auf einen Mikrosekundentimer von FreeRTOS zu. Um Zeitmessungen in Java durchzuführen, liefert Java den aktuellen Wert der Systemzeit in der Einheit „Nanosekunden“ [49]. Die Zeitwerte lassen sich in Mikrosekunden umrechnen. Implementierung 26 3.3 Grundlegende Softwarearchitektur Kad-Funktionalität Kad-Netzwerk User-Interface KadClient Abbildung 12: Netzwerkaufbau Die zu portierende Kad-Software besteht aus einem Teil zur Kommunikation mit dem KadNetzwerk und einer Schnittstelle zur Kommunikation mit einem Client, der sich außerhalb des Kad-Netzwerkes befindet (Abbildung 12). Anfragen, die vom Client an einen Knoten gesendet werden, müssen ausgewertet werden. Dazu bildet der Knoten die XOR-Distanz zwischen seinem eigenen Hashwert und den Zielhashwert. Wenn das Ergebnis innerhalb der Suchtoleranz liegt, wird die Anfrage direkt vom Knoten an den Client zurückgeschickt. Ein Ergebnis außerhalb der Suchtoleranz bewirkt, dass eine Suche innerhalb des Kad Netzwerkes angestoßen wird. Implementierung 27 Thread-Generierung Start Thread-Generierung Nein Nein Semaphor für Empfang gesetzt? PaketEmpfang Schreiben des Pakets in die Warteschlange Warteschlange Ja 1 Lese Paket aus Warteschlange Semaphor für Senden gesetzt? Warteschlange 1 2 3 Setzen der Semaphoren für den Empfang PaketVerarbeitung (Abbildung 14) Schreiben des zu sendenden Pakets in die Warteschlange Thread für den PaketEmpfang Ja Lese Paket aus Warteschlange 2 3 Sende Paket Thread für das PaketSenden Setzen der Semaphor für das Senden an Nutzer oder Kad Threads für die PaketVerarbeitung Thread-Terminierung Thread-Terminierung Ende Thread-Terminierung Abbildung 13: Kommunikation zwischen Threads [12] Abbildung 13 beschreibt die einzelnen Threads zur Paketverarbeitung genauer. Dabei empfängt ein Thread die Pakete über einen UDP-Socket und schreibt sie in eine Warteschlange. Das Setzen eines Semaphors signalisiert einem anderen Thread, dass ein neues Paket aus der Warteschlange gelesen werden soll. Für jedes empfangene Paket wird ein neuer Thread für dessen Auswertung gestartet. Nachdem das Paket der Warteschlange entnommen wurde, erfolgt die Paketverarbeitung. Daraufhin wird ein Antwortpaket erstellt und über eine weitere Warteschlange einem Sende-Thread übergeben. Ein Semaphor steuert den Lesevorgang aus der Warteschlange. Der Sende-Thread verschickt das gelesene Paket über einen UDP-Socket. Implementierung 28 Start Bestimmung der XORDistanz zu eigenem Knoten Opcode == Request Read? Ja Distanz <= Suchtoleranz Ja Antwortpaket mit Zufallszahl erstellen Ende Nein Opcode == Request Store Distanz <= Suchtoleranz Ja Ja Antwortpaket erstellen Ende Nein Nein Nein Ende Suche des zuständigen Knotens an KadNetzwerk weiterleiten Ende Abbildung 14: Paketverarbeitung [12] Abbildung 14 zeigt die Paketverarbeitung jedes einzelnen Pakets. Jeder Thread für die Paketverarbeitung führt die dargestellte Routine durch. Nachdem ein Paket empfangen wurde, erfolgt eine Auswertung des Opcodes. Dieser beschreibt die Art der Pakete. In dem implementierten Anwendungsfall finden sich zwei verschiedene Opcodes: eine Anfrage zum Lesen (Request Read) eines Wertes und eine Anfrage zum Speichern (Request Store) eines Wertes. Nachdem der Opcode bekannt ist, wird bestimmt, ob der Knoten für die Anfrage zuständig ist, oder die Anfrage an das Kad Netzwerk weitergeleitet werden muss. Ist der angesprochene Knoten zuständig, antwortet er auf einen Request Read mit einer Zufallszahl. Bei einem Request Store sendet der Knoten das abzuspeichernde Datum an den Absender zurück. Dieses Übertragungsprotokoll ist unabhängig vom Kad-Protokoll und dient für Testzwecke, bzw. eine Instrumentierung des Kad-Clients. Implementierung 29 3.4 Kad-Client Wie in Abbildung 12 dargestellt, kommuniziert ein Client mit dem Kad-Netzwerk. Zum Testen wurde ein Kommandozeilentool (Abbildung 15) implementiert, welches UDPDatagramme an einen Kad-Knoten sendet. Die UDP-Datagramme können benutzerdefiniert erstellt werden. Abbildung 15: Kad-Client auf Windows Rechner Über den Client lässt sich die UDP-Payload Byte-weise definieren. Die ersten zwei Byte beschreiben den Opcode. Im dargestellten Beispiel bedeutet eine „80“ den hexadezimalen Wert „0x80“, welcher eine Anfrage zum Lesen eines Wertes aus dem Kad-Netzwerk kodiert. Zwei weitere Bytes geben in dezimaler Form die Anzahl der zu lesenden Werte an. In diesem Fall sind es zwei. Die nächsten vier Bytes beschreiben den Zielhashwert (im Beispiel: 0x6466) in hexadezimaler Form. Durch Variation der Pakete konnten verschiedene Testfälle erprobt werden. Ergebnisse und Diskussion 30 4 Ergebnisse und Diskussion In dieser Arbeit wurde begonnen, die C++ Implementierung von Kademlia namens Kad in die Sprache Java zu portieren. Die Kommunikation zwischen Rechnern außerhalb des KadNetzwerks und einzelner Kad-Knoten konnte erfolgreich umgesetzt werden. Es ist möglich, Anfragen zum Speichern und Lesen von Werten zu dekodieren. Jeder Knoten ist in der Lage anhand der XOR-Distanz zwischen dem Zielhashwert und dem eigenen Hashwert zu bestimmen, ob der Knoten selbst für die Anfrage zuständig ist, oder ob die Anfrage an das Kad-Netzwerk weitergeleitet werden muss. Um die Performance der Implementierung abzuschätzen, wurde die Dauer der MD5Hashwert-Berechung ermittelt. Wird die C++-Implementierung von Kad, basierend auf FreeRTOS, auf einem ZedBorad verwendet, so ergibt sich eine Dauer von ca. 30 Mikrosekunden. Die Java-Kad-Software benötigt eine Ausführungszeit von ca. 30 Millisekunden auf einem Windows-PC. Die deutlich höhere Ausführungszeit der MD5Berechung auf dem PC lässt sich auf die Verwendung der Java virtual machine zurückführen. Während der Arbeit konnten relevante Unterschiede zwischen den Sprachen C++ und Java ermittelt werden. Weiterhin erfolgte eine Analyse der verwendeten Betriebssystemfunktionalitäten von FreeRTOS. Alle Systemaufrufe, wie das Starten und Beenden von Threads, die Interthreadkommunikation mittels Semaphoren und Mutexen, die Netzwerkkommunikation über Sockets und die mikrosekunden-genaue Zeitmessung, lassen sich in äquivalente Aufrufe der Java-Laufzeitumgebung portieren. Zusammen mit diesen Systemaufrufen und der Verwendung von komplexen Datentypen kann der bestehende Quellcode zur Kommunikation innerhalb des Kad-Netzes portiert werden. Zusammenfassung und Ausblick 31 5 Zusammenfassung und Ausblick Durch die Verwendung von Java wird eine Plattformunabhängigkeit erreicht. Alle Geräte, afür die eine Java Laufzeitumgebung verfügbar ist, können einen Kad-Knoten darstellen und einem Kad-Netzerk beitreten. Anwendungen, basierend auf Kademlia, nutzen die Eigenschaften, wie einfache Integration neuer Knoten in ein bestehendes Netzwerk, gute Skalierbarkeit durch geringe Suchkomplexität und hohe Ausfallsicherheit durch eine dezentrale Organisierung. Werden vernetzte Geräte im Industriebereich eingesetzt, ist neben einer hohen Ausfallsicherheit auch eine Echtzeitfähigkeit erforderlich. Diese geht durch die Verwendung einer herkömmlichen Java-Laufzeitumgebung anstelle eines Echtzeitbetriebssystems, wie FreeRTOS, verloren. Zukünftige Arbeiten müssen untersuchen, inwiefern sich eine Echtzeitfähigkeit mit einer geeigneten Laufzeitumgebung, ggf. oberhalb einer echtzeitfähigen Betriebssystemumgebung für Java realisieren lässt. Da Android Apps ebenfalls auf einer Java VM ausgeführt werden (Dalvik bzw. künftig ART), ist eine Android-Portierung der Java-Kad-Software anzustreben. Eine Recherche hat ergeben, dass die Aufrufe innerhalb der Java-Kad-Software zum Starten und Verwalten von Threads, die Verwendung von Semaphoren und Mutexen und die Nutzung und Verwaltung von Sockets ebenfalls unter Android verfügbar sind und der Portierungsauswand daher als gering einzuschätzen ist. Geräte, wie Android-Telefone, lassen sich unter anderem über eine WLAN-Verbindung miteinander vernetzen. Der bislang wenig bekannte WLAN-Standard IEEE 802.11s [50] bietet die Möglichkeit, WLAN-Mesh-Netzwerke ohne zentrale Instanz zu errichten. Dieser Standard definiert die physikalische und die MAC-Schicht der Vernetzung. Basierend auf diesen Netzwerkschichten können die physikalisch vermaschten Geräte über Kademlia ebenfalls dezentral auf Anwendungsschicht organisiert werden. Es entstehen, wie in 2.1 beschrieben, die zwei Schichten: physikalisches Underlay und logisches Overlay. Zukünftige Arbeiten untersuchen die Berücksichtigung netzwerktechnischer Nähe im logischen P2P-Overlay sowie den sinnvollen Einsatz verteilter P2P-Anwendungen oberhalb von physikalischen WLAN-Mesh-Netzwerken. Literaturverzeichnis 32 Literaturverzeichnis [1] Digital Living Network Alliance, “Webpage: DLNA for Industry.” [Online]. Available: http://www.dlna.org/. [Accessed: 26-Aug-2014]. [2] Microsoft, “Webpage: Windows - Microsoft Windows.” [Online]. Available: http://windows.microsoft.com/de-de/windows/home. [Accessed: 26-Aug-2014]. [3] Linux Foundation, “Webpage: The Linux Foundation.” [Online]. Available: http://www.linuxfoundation.org/. [Accessed: 26-Aug-2014]. [4] Apple Inc., “Webpage: Apple – OS X Mavericks – Noch mehr Möglichkeiten mit neuen Apps und Features.” [Online]. Available: https://www.apple.com/de/osx/. [Accessed: 26-Aug-2014]. [5] Microsoft, “Webpage: Windows Phone (Deutschland).” [Online]. Available: http://www.windowsphone.com/de-DE. [Accessed: 26-Aug-2014]. [6] Google, “Webpage: Android Developers.” [Online]. Available: http://developer.android.com/index.html. [Accessed: 22-Jul-2014]. [7] Apple Inc., “Webpage: Apple – iOS 7.” [Online]. Available: https://www.apple.com/de/ios/. [Accessed: 26-Aug-2014]. [8] P. Maymounkov and D. Mazières, “Kademlia: A Peer-to-Peer Information System Based on the XOR Metric,” New York University. [9] “Standard ISO/IEC 14882:2011, C++.” [Online]. Available: http://www.iso.org/iso/catalogue_detail.htm?csnumber=50372. [10] Oracle, “Webpage: java.com: Java + Sie.” [Online]. Available: https://www.java.com/de/. [Accessed: 22-Jul-2014]. [11] A. Bhushan, “RFC 354: THE FILE TRANSFER PROTOCOL,” 1972. [12] P. Danielis, “Dissertation: Peer-to-Peer Technologie in Teilnehmerzugangsnetzen,” Universität Rostock, 2012. [13] R. S. Jörg Eberspächer, “Peer-to-Peer Systems and Applications,” 28th ed., Berlin Heidelberg: Springer Verlag, 2005, pp. 35–56. [14] R. Gubitz, “Masterarbeit; Entwurf eines echtzeitfähigen Peer-to-Peer-Clients,” Universität Rostock, 2013. [15] Microsoft, “Understanding Service-Oriented Architecture.” [Online]. Available: http://msdn.microsoft.com/en-us/library/aa480021.aspx. [Accessed: 24-Sep-2014]. Literaturverzeichnis 33 [16] Bitwise Group, “FreeRTOS - Market leading RTOS (Real Time Operating System) for embedded systems supporting 34 microcontroller architectures,” 2013. [Online]. Available: http://www.freertos.org/index.html. [Accessed: 08-Jul-2013]. [17] A. Dunkels, “Design and Implementation of the lwIP TCP / IP Stack,” Swedish Institute of Computer Science, 2001. [18] Raspberry Pi Foundation, “Webpage: Raspberry Pi Documentation.” [Online]. Available: http://www.raspberrypi.org/documentation/hardware/README.md. [Accessed: 08-Sep-2014]. [19] Google, “Webpage: dalvik - Code and documentation from Android&#39;s VM team - Google Project Hosting.” [Online]. Available: https://code.google.com/p/dalvik/. [Accessed: 08-Sep-2014]. [20] Google, “Webpage: Introducing ART | Android Developers.” [Online]. Available: https://source.android.com/devices/tech/dalvik/art.html. [Accessed: 08-Sep-2014]. [21] Oracle, “Webpage: Introduction to Java in Oracle9i.” [Online]. Available: http://docs.oracle.com/cd/B10501_01/java.920/a96656/intro.htm. [Accessed: 08Sep-2014]. [22] P. Danielis, J. Skodzik, C. Lorenz, D. Timmermann, T. Bahls, and D. Duchow, “Paper: P-DONAS : A Prototype for a P2P-based Domain Name System in Access Networks,” Rostock. [23] J. Skodzik, P. Danielis, V. Altmann, J. Rohrbeck, D. Timmermann, T. Bahls, and D. Duchow, “Paper: DuDE: A distributed computing system using a decentralized P2P environment,” Ieee, Rostock, Oct. 2011. [24] Xilinx, “Virtex-4 FPGA User Guide,” 2008. [25] Xilinx, “PowerPC Processor Reference Guide,” 2003. [26] Xilinx, “Documentation: Xilkernel,” 2006. [Online]. Available: http://www.xilinx.com/ise/embedded/edk91i_docs/xilkernel_v3_00_a.pdf. [Accessed: 08-Sep-2014]. [27] J. Skodzik, P. Danielis, V. Altmann, and D. Timmermann, “Time Synchronization in the DHT-based P2P Network Kad for Real-Time Automation Scenarios,” 2nd IEEE WoWMoM Workshop on the Internet of Things: Smart Objects and Services (IoT-SoS) 2013, Madrid, Spain, 2013. [28] J. Skodzik, P. Danielis, V. Altmann, and D. Timmermann, “HaRTKad: A Hard Real-Time Kademlia Approach,” 11th IEEE Consumer Communications & Networking Conference (CCNC), 2014. [29] V. Altmann, J. Skodzik, P. Danielis, J. Müller, F. Golatowski, and D. Timmermann, “A DHT-based Scalable Approach for Device and Service Discovery,” 12th IEEE International Conference on Embedded and Ubiquitous Computing (EUC), 2014. Literaturverzeichnis 34 [30] “ZedBoard documentations,” 2013. [Online]. Available: http://www.zedboard.org/documentation. [Accessed: 06-Jul-2013]. [31] ARM Ltd., “Webpage: ARM - The Architecture For The Digital World.” [Online]. Available: http://www.arm.com/. [Accessed: 17-Sep-2014]. [32] J. Mitschang, “Harte Echtzeit unter Linux Fallstudie RTAI vs. RT-Preempt,” Fraunhofer IESE, Kaiserslautern, 2007. [33] cplusplus.com, “Webpage: Headers and Includes: Why and How - C++ Forum.” [Online]. Available: http://www.cplusplus.com/forum/articles/10627/. [Accessed: 11-Sep-2014]. [34] Oracle, “What Is an Interface? (The Java Tutorials, Learning the Java Language, Object-Oriented Programming Concepts).” [Online]. Available: http://docs.oracle.com/javase/tutorial/java/concepts/interface.html. [Accessed: 24Sep-2014]. [35] C. Ullenboom, Java ist auch eine Insel, Das umfassende Handbuch. Galileo Computing, 2011, p. 1482. [36] cplusplus.com, “Webpage: malloc - C++ Reference.” [Online]. Available: http://www.cplusplus.com/reference/cstdlib/malloc/. [Accessed: 11-Sep-2014]. [37] cplusplus.com, “Webpage: free - C++ Reference.” [Online]. Available: http://www.cplusplus.com/reference/cstdlib/free/. [Accessed: 11-Sep-2014]. [38] Sun Microsystems, “Memory Management in the Java HotSpot(TM) Virtual Machine,” 2006. [39] Oracle, “Webpage: Runnable (Java Platform SE 7 ).” [Online]. Available: http://docs.oracle.com/javase/7/docs/api/java/lang/Runnable.html. [Accessed: 11Sep-2014]. [40] Oracle, “Webpage: Thread (Java Platform SE 7 ).” [Online]. Available: http://docs.oracle.com/javase/7/docs/api/java/lang/Thread.html. [Accessed: 11-Sep2014]. [41] Oracle, “Webpage: Semaphore (Java Platform SE 7 ).” [Online]. Available: http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/Semaphore.html. [Accessed: 11-Sep-2014]. [42] C. Ullenboom, Java 7 - Mehr als eine Insel, Das Handbuch zu den Java SEBibliotheken. Galileo Computing, 2012, p. 1433. [43] Darpa Internet Program, “RFC 793: Transmission Control Protocol,” California, 1981. [44] J. Postel, “RFC 768: User Datagram Protocol,” 1980. Literaturverzeichnis 35 [45] Information Sciences Institute and University of Southern California, RFC 791: INTERNET PROTOCOL DARPA INTERNET PROGRAM PROTOCOL SPECIFICATION. http://tools.ietf.org/pdf/rfc791.pdf, 1981. [46] Oracle, “Webpage: DatagramSocket (Java Platform SE 7 ).” [Online]. Available: http://docs.oracle.com/javase/7/docs/api/java/net/DatagramSocket.html. [Accessed: 11-Sep-2014]. [47] Oracle, “Webpage: LinkedList (Java Platform SE 7 ).” [Online]. Available: http://docs.oracle.com/javase/7/docs/api/java/util/LinkedList.html. [Accessed: 11Sep-2014]. [48] Oracle, “Webpage: HashMap (Java Platform SE 7 ).” [Online]. Available: http://docs.oracle.com/javase/7/docs/api/java/util/HashMap.html. [Accessed: 11Sep-2014]. [49] Oracle, “Webpage: System (Java 2 Platform SE 5.0).” [Online]. Available: http://docs.oracle.com/javase/1.5.0/docs/api/java/lang/System.html. [Accessed: 11Sep-2014]. [50] W. Steven, J. Kruys, K. J. Kim, and J. C. Zuniga, “IEEE 802.11s Tutorial, Overview of the Amendment for Wireless Local Area Mesh Networking,” Dallas, 2006. Anhang Verwendete Java-Klassen Klassenname Package Thread java.lang.Thread Semaphore java.util.concurrent.Semaphore DatagramSocket java.net.DatagramSocket DatagramPacket java.net.DatagramPacket InetAddress java.net.InetAddress MessageDigest java.security.MessageDigest System java.lang.System Eidesstattliche Erklärung Hiermit erkläre ich an Eides statt, dass ich die vorliegende Arbeit selbstständig und ohne Benutzung anderer als der angegebenen Hilfsmittel angefertigt habe. Die aus den Quellen direkt oder indirekt übernommenen Gedanken sind als solche kenntlich gemacht. Die Arbeit hat mit gleichem bzw. in wesentlichen Teilen gleichem Inhalt noch keiner anderen Prüfungsbehörde vorgelegen. Ort, Datum Unterschrift
