guide:architecture@de

Leitfäden

Architektur, von einem Check bis zu Spanner

Die Server und Datenbanken hinter Zanzibar, verfolgt anhand einer einzelnen Check-Anfrage und des Watch-Streams.

Fakten geprüft am Abschnitte im Paper §3, §3.1, §3.2.5, §3.2.6, §3.2.7, §4

Zanzibar ist eine Menge von Servern vor einer Menge von Spanner-Datenbanken. Diese Seite benennt die Teile, verfolgt dann eine Check-Anfrage durch sie hindurch und betrachtet anschließend, wie die Daten auf der Platte angeordnet sind. Die Zahlen am Ende sind diejenigen, die das Paper für den Produktivbetrieb im Jahr 2018 angibt.

Die Teile

Welche Kästen gibt es, und in welche Richtung fließen Daten zwischen ihnen? Das Paper antwortet mit seiner Abbildung 2. Die Version unten behält deren Farben (Clients blau, Server gelb, Spanner-Datenbanken grün) und lässt Details weg.

Zanzibar-Architektur, vereinfachtClients senden Check, Read, Expand und Write an die aclserver in einem Zanzibar-Serving-Cluster; der watchserver ist wie im Paper außerhalb des Clusters gezeichnet. Die aclserver laden Namespace-Konfigurationen aus Spanner, lesen und schreiben Relationstupel in einer Spanner-Datenbank pro Namespace und hängen jeden Schreibvorgang an das Changelog an, ebenfalls in Spanner. Ein watchserver liest das Changelog fortlaufend und streamt Änderungen an Clients (die Watch-API) und an Leopard (Abbildung 2 des Papers zeichnet Leopard als separates Indexierungssystem). Eine periodische Offline-Pipeline liest die Tupeldatenbanken, erstellt Snapshot-Dumps und entfernt alte Versionen per Garbage Collection; Leopard baut seinen Index aus diesen Snapshots auf und beantwortet Mengenberechnungen für die aclserver.Zanzibar-Serving-ClusterSpannerClientsaclserverwatchserverClientsNamespace-KonfigurationenRelationstupel(eine DB pro Namespace)ChangelogOffline-Pipeline(periodisch)LeopardCheck, Read,Expand, Writeladenlesen, schreibenanhängenmitlesenWatchÄnderungenDump,GCSnapshotsMengen-berechnung
Neu gezeichnet und vereinfacht nach Abbildung 2 des Papers. Pfeile zeigen die Richtung des Datenflusses. Clients erscheinen nur zweimal, damit die Linien getrennt bleiben: Dieselben Clients rufen die aclserver auf und abonnieren Watch.

Die Clients sprechen mit zwei Arten von Servern. aclservers beantworten die vier Anfragetypen; watchservers streamen nur Änderungen. In den Worten des Papers: aclservers “are organized in clusters and respond to Check, Read, Expand, and Write requests” (sind in Clustern organisiert und beantworten Check-, Read-, Expand- und Write-Anfragen), während watchservers “tail the changelog and serve a stream of namespace changes to clients in near real time” (§3) (das Changelog fortlaufend lesen und Clients nahezu in Echtzeit einen Stream von Namespace-Änderungen liefern). Leopard ist ein Index für große und tief verschachtelte Gruppen; er hat eine eigene Seite.

Die Offline-Pipeline erzeugt “dumps of the relation tuples in each namespace at a known snapshot timestamp” (Dumps der Relationstupel jedes Namespace zu einem bekannten Snapshot-Zeitstempel) und entfernt per Garbage Collection “tuple versions older than a threshold configured per namespace” (§3) (Tupelversionen, die älter sind als ein pro Namespace konfigurierter Schwellenwert).

Ein Check, Schritt für Schritt

Die Anfrage, der wir folgen: Ist Beto ein Betrachter des Readmes? Im durchgehenden Beispiel gehören zu den Betrachtern des Readmes die Mitglieder von group:eng, und Beto ist eines davon, also lautet die Antwort ja. Zanzibar muss das herausfinden, indem es zwei Objekte liest, doc:readme und group:eng.

Sie landet auf einem beliebigen Server, der sie auffächert

Welcher Server erledigt die Arbeit? Jeder kann die Anfrage annehmen, und die Arbeit wird dann nach Objekten verteilt.

Ein Check fächert sich über einen Cluster aufEin Client sendet Check an aclserver A. Server A fragt aclserver B, der für doc:readme zuständig ist, ob Beto ein Betrachter des Readmes ist. Server B stellt fest, dass Mitglieder von group:eng Betrachter sind, und fragt aclserver C, der für group:eng zuständig ist, ob Beto ein Mitglied ist. Die Antworten laufen über dieselben Pfeile zurück zu A, der dem Client antwortet.Clientaclserver Aempfängt Checkaclserver BSchlüssel: doc:readmeaclserver CSchlüssel: group:engCheckviewer des Readmes?member von eng?
Check(user:beto, viewer, doc:readme). Die Antworten kommen über dieselben Pfeile zurück; A antwortet dem Client.

Server A musste keines der beiden Objekte besitzen. Das Paper beschreibt genau diese Form: “Requests arrive at any server in a cluster and that server fans out the work to other servers in the cluster as necessary. Those servers may in turn contact other servers to compute intermediate results. The initial server gathers the final result and returns it to the client.” (§3) (Anfragen treffen bei einem beliebigen Server eines Clusters ein, und dieser Server fächert die Arbeit nach Bedarf auf andere Server im Cluster auf. Diese Server können ihrerseits andere Server kontaktieren, um Zwischenergebnisse zu berechnen. Der ursprüngliche Server sammelt das Endergebnis und gibt es an den Client zurück.)

Konsistentes Hashing wählt den Partner

Woher wusste A, dass es B nach dem Readme fragen muss? Die Server eines Clusters bilden einen gemeinsamen verteilten Cache: “Cache entries are distributed across Zanzibar servers with consistent hashing” (§3.2.5) (Cache-Einträge werden mit konsistentem Hashing über die Zanzibar-Server verteilt). Das Verfahren stammt von Karger et al. (STOC ’97), die das Paper als [20] zitiert. Für die meisten Namespaces wird der Weiterleitungsschlüssel aus der Objekt-ID berechnet (§3.2.5).

Weiterleitungsschlüssel auf einem Ring von ServernVier aclserver, A, B, C und D, liegen auf einem Ring. Die Anfragen doc:readme#viewer und doc:readme#owner werden beide über das Objekt doc:readme gehasht und gehen an Server B. group:eng#member geht an Server C. folder:A#viewer geht an Server D.aclserver Aaclserver Baclserver Caclserver Ddoc:readme#viewerdoc:readme#ownergroup:eng#memberfolder:A#viewerhash(doc:readme)hash(doc:readme)hash(group:eng)hash(folder:A)
Beide Readme-Anfragen gehen an B, weil der Schlüssel das Objekt ist, nicht die Relation. Der Ring ist das Lehrbuchbild des konsistenten Hashings; das Paper sagt nicht, welche Variante Zanzibar verwendet.

viewer und owner auf dem Readme treffen sich auf demselben Server. Genau das ist der Zweck, den Schlüssel aus dem Objekt zu bilden: “processing a check on ⟨object#relation⟩ often involves indirect ACL checks on other relations of the same object and reading relation tuples of the object. These checks and reads can be processed by the same server since they share the same forwarding key with the parent check request.” (§3.2.5) (Die Verarbeitung einer Prüfung auf ⟨object#relation⟩ umfasst oft indirekte ACL-Prüfungen auf anderen Relationen desselben Objekts und das Lesen von Relationstupeln des Objekts. Diese Prüfungen und Lesevorgänge können vom selben Server verarbeitet werden, da sie denselben Weiterleitungsschlüssel wie die übergeordnete Check-Anfrage haben.) Karger et al. entwerfen konsistentes Hashing so, dass beim Hinzufügen oder Entfernen eines Caches nur der minimale Anteil an Objekten verschoben werden muss, der nötig ist, um die Last ausgeglichen zu halten; deshalb eignet es sich für einen Cache.

Für heiße Schlüssel ergänzt das Paper, dass es Slicer verwendet, “to help distribute hot keys to multiple servers” (§3.2.5) (um heiße Schlüssel auf mehrere Server zu verteilen).

Beide Enden eines Aufrufs cachen die Antwort

Was passiert, wenn viele Server gleichzeitig C nach group:eng fragen, etwa weil eine Seite mit Suchergebnissen Dutzende von Dokumenten prüft, die alle mit eng geteilt sind?

Caches bei Aufrufer und Aufgerufenem bilden einen BaumDrei aclserver, A, D und E, jeder mit einem Cache, fragen aclserver C, ob ein Benutzer Mitglied von group:eng ist. Server C hat seinen eigenen Cache und liest die Tupel von group:eng nur bei einem Fehltreffer aus Spanner.aclserver A+ Cacheaclserver D+ Cacheaclserver E+ Cacheaclserver C+ CacheGruppentupel(Spanner)member von eng?bei Fehltreffer
Ein Treffer beim Aufrufer spart einen RPC an C. Ein Treffer bei C spart einen Lesevorgang in Spanner.

Die Caches der Aufrufer und der Cache des Aufgerufenen stapeln sich zu einem Baum: “To handle hot forwarding keys, we cache results at both the caller and the callee of internal RPCs, effectively forming cache trees.” (§3.2.5) (Um heiße Weiterleitungsschlüssel zu behandeln, cachen wir Ergebnisse sowohl beim Aufrufer als auch beim Aufgerufenen interner RPCs und bilden so effektiv Cache-Bäume.) Cache-Schlüssel enthalten den Snapshot-Zeitstempel, und Zeitstempel werden “rounded up to a coarse granularity, such as one or ten seconds” (auf eine grobe Granularität aufgerundet, etwa eine oder zehn Sekunden), sodass die meisten aktuellen Anfragen Einträge teilen (§3.2.5). Im Produktivbetrieb hatte das Caching von Prüfungen “a 10% hit rate on the delegate’s side” (eine Trefferquote von 10 % auf der Seite des Delegierten) und “a 2% hit rate” (eine Trefferquote von 2 %) auf der Seite des Delegierenden; das Paper merkt an, dass diese Quoten zwar niedrig aussehen, “they prevent 500K internal RPCs per second from creating hot spots” (§4.4) (sie aber verhindern, dass 500.000 interne RPCs pro Sekunde Hotspots erzeugen).

Die Sperrtabelle fasst identische Anfragen zusammen

Ein Cache hilft erst, wenn er die Antwort enthält. Kommen viele identische Anfragen an, bevor die erste fertig ist, würden alle den Cache verfehlen und alle zu Spanner gehen: ein Cache Stampede (Referenz [3] des Papers). Wie vermeidet C das?

Eine Sperrtabelle lässt eine von mehreren identischen Anfragen durchAnfrage 1 fragt C nach dem Cache-Schlüssel K; C verfehlt den Cache und trägt K in seine Sperrtabelle ein. Anfrage 2 fragt nach demselben Schlüssel und muss warten. C liest die Zeilen einmal aus Spanner, füllt den Cache und gibt den Eintrag frei. Beide Anfragen erhalten die Antwort.ZeitAnfrage 1aclserver CAnfrage 2SpannerSchlüssel K anfragenFehltreffer: K sperrenSchlüssel K anfragenK gesperrt: warteneinmal lesenZeilenCache füllenAntwortAntwort
Anfrage 2 blockiert, statt zu Spanner zu gehen. Für Schlüssel K wird nur ein Lesevorgang abgesetzt.

Das Paper: “we maintain a lock table on each server to track outstanding reads and checks. Among requests sharing the same cache key only one request will begin processing; the rest block until the cache is populated.” (§3.2.5) (Wir führen auf jedem Server eine Sperrtabelle, um ausstehende Lesevorgänge und Prüfungen zu verfolgen. Von den Anfragen, die denselben Cache-Schlüssel teilen, beginnt nur eine mit der Verarbeitung; die übrigen blockieren, bis der Cache gefüllt ist.) Bei Prüfungen sparte die Sperrtabelle “an additional 12%” (weitere 12 %) auf der Seite des Delegierten und “an additional 3%” (weitere 3 %) auf der Seite des Delegierenden (§4.4).

Zwei Verfeinerungen kamen später hinzu (§3.2.5). Für ein sehr beliebtes Objekt liest und cacht Zanzibar alle Tupel von ⟨object#relation⟩ auf einmal, “trading read bandwidth for cacheability” (es tauscht Lesebandbreite gegen Cachebarkeit). Und weil eine abgebrochene Teilprüfung ihren Cache-Schlüssel leer lässt, verzögert es “eager cancellation when there are waiters on the corresponding lock table entry” (den frühzeitigen Abbruch, wenn auf den entsprechenden Eintrag der Sperrtabelle gewartet wird).

Lesevorgänge an Spanner werden gebündelt

Nehmen Sie nun eine Prüfung, die mehrere Relationen eines Objekts berührt: Ist Chen ein Betrachter des Readmes? Mit der Konfiguration aus Abbildung 1 des Papers enthält viewer editor, editor enthält owner, und Betrachter des Ordners parent sind Betrachter des Dokuments. Server B muss also vier Tupelmengen des Readmes lesen.

Blatt-Lesevorgänge einer Prüfung teilen einen PoolUm auszuwerten, ob Chen ein Betrachter von doc:readme ist, werden die viewer-, editor-, owner- und parent-Tupel des Readmes benötigt. Die vier Blätter werden gleichzeitig auf aclserver B ausgewertet, der ihre Lesevorgänge bündelt, bevor er sie an die doc-Datenbank in Spanner sendet.doc:readme#viewerdoc:readme#editordoc:readme#ownerdoc:readme#parentaclserver Bbündelt Lesevorgängedoc-Tupel(Spanner)weniger RPCs
Check(user:chen, viewer, doc:readme). Alle vier Blätter starten gleichzeitig; ihre Lesevorgänge gehen gemeinsam hinaus.

Die Blätter laufen nebenläufig: “we evaluate all leaf nodes of the boolean expression tree concurrently. When the outcome of one node determines the result of a subtree, evaluation of other nodes in the subtree is cancelled.” (§3.2.3) (Wir werten alle Blattknoten des booleschen Ausdrucksbaums gleichzeitig aus. Wenn das Ergebnis eines Knotens das Ergebnis eines Teilbaums bestimmt, wird die Auswertung der anderen Knoten im Teilbaum abgebrochen.) Ihre Lesevorgänge werden gruppiert: “We apply a pooling mechanism to group reads for the same ACL check to minimize the number of read RPCs to Spanner.” (§3.2.3) (Wir wenden einen Pooling-Mechanismus an, um Lesevorgänge für dieselbe ACL-Prüfung zu gruppieren und so die Zahl der Lese-RPCs an Spanner zu minimieren.) Das Tupel parent zeigt dann auf folder:A, und folder:A#viewer wird an den Server weitergeleitet, dem folder:A gehört, wo Chen gefunden wird. Das Paper sagt nicht, zu wie vielen RPCs ein Pool wird; weiter als „weniger“ geht es nicht.

Die Anordnung der Tupel macht das günstig: Die Reihenfolge des Primärschlüssels “allows us to look up all relation tuples for a given object ID or (object ID, relation) pair” (§3.1.1, siehe Speicherung unten) (erlaubt es uns, alle Relationstupel für eine gegebene Objekt-ID oder ein Paar (Objekt-ID, Relation) nachzuschlagen).

Langsame Spanner-Lesevorgänge werden gehedgt

Manche Lesevorgänge werden aus Gründen langsam sein, die nichts mit der Anfrage zu tun haben. Für Aufrufe an Spanner und an Leopard verwendet Zanzibar Request-Hedging nach Dean und Barroso, „The Tail at Scale“ (CACM, 2013), Referenz [16] des Papers. Wann geht die zweite Anfrage hinaus?

Ein verzögerter gehedgter LesevorgangDer aclserver sendet einen Lesevorgang an Spanner-Replikat 1, das langsam ist. Nach der Hedging-Verzögerung sendet der aclserver denselben Lesevorgang an Replikat 2. Replikat 2 antwortet zuerst; der aclserver verwendet diese Antwort und bricht den Lesevorgang bei Replikat 1 ab.ZeitaclserverSpanner-Replikat 1Spanner-Replikat 2HedgeabbrechenLesevorgang sendenlangsamVerzögerung vorbeigleicher LesevorgangAntworterste Antwort nutzenabgebrochen
Der Hedge wird erst gesendet, wenn bekannt ist, dass der erste Lesevorgang langsam ist.

Hedging bedeutet: “we send the same request to multiple servers, use whichever response comes back first, and cancel the other requests” (§3.2.7) (wir senden dieselbe Anfrage an mehrere Server, verwenden die Antwort, die zuerst zurückkommt, und brechen die anderen Anfragen ab). Die zweite Anfrage wartet: “we first send one request and defer sending hedged requests until the initial request is known to be slow” (wir senden zuerst eine Anfrage und schieben das Senden gehedgter Anfragen auf, bis bekannt ist, dass die erste Anfrage langsam ist), wobei die Verzögerung durch einen Schätzer einer “Nth percentile latency based on recent measurements” (§3.2.7) (Latenz des N-ten Perzentils auf Grundlage aktueller Messungen) festgelegt wird. Im Produktivbetrieb “1% of Spanner reads, or 200K reads per second, benefit from hedging” (§4.4) (profitieren 1 % der Spanner-Lesevorgänge, also 200.000 Lesevorgänge pro Sekunde, vom Hedging).

Jeder Client wird eingehegt

Ein gemeinsam genutzter Dienst muss verhindern, dass ein Client die anderen ausbremst. §3.2.6 nennt vier Grenzen:

  • CPU: Jeder RPC wird in “generic cpu-seconds” (generischen CPU-Sekunden) bemessen; jeder Client hat ein globales CPU-Limit, und “its RPCs will be throttled if it exceeds the limit and there is no spare capacity in the overall system.” (seine RPCs werden gedrosselt, wenn er das Limit überschreitet und im Gesamtsystem keine freie Kapazität vorhanden ist.)
  • Ausstehende RPCs: Jeder Server begrenzt die Gesamtzahl und die Zahl pro Client.
  • Spanner: “the maximum number of concurrent reads per (object, client) and per client on each Spanner server.” (die maximale Zahl gleichzeitiger Lesevorgänge pro (Objekt, Client) und pro Client auf jedem Spanner-Server.)
  • Sperrtabellen: “different lock table keys for requests from different clients” (unterschiedliche Sperrtabellenschlüssel für Anfragen verschiedener Clients), damit eine Drosselung eines Clients durch Spanner keinen anderen blockiert.

Der Watch-Pfad

Schreibvorgänge speisen auch einen Stream. Wohin geht eine Änderung, nachdem Anne ein Tupel geschrieben hat?

Von einem Schreibvorgang zum Watch-StreamEin Client sendet ein Write an einen aclserver. In einer einzigen Spanner-Transaktion schreibt der aclserver das Tupel in die Datenbank des Namespace doc und einen Eintrag in einen Changelog-Shard. Der watchserver liest das Changelog fortlaufend und streamt die Änderung an Watch-Clients und an den inkrementellen Indexer von Leopard.ClientWriteaclserverdoc-TupelChangelog-ShardwatchserverWatch-ClientsLeopard-IndexerTupeldieselbe Txndieselbe TxnmitlesenÄnderungen
Das Tupel und sein Changelog-Eintrag werden in einer Transaktion committet, sodass der Stream keinen Schreibvorgang verpassen und keinen zeigen kann, der nicht committet wurde.

“Every Zanzibar write is committed to both the tuple storage and the changelog shard in a single transaction.” (Jeder Zanzibar-Schreibvorgang wird in einer einzigen Transaktion sowohl in den Tupelspeicher als auch in den Changelog-Shard committet.) Der Spanner-Server, der den Changelog-Shard hostet, fungiert als Transaktionskoordinator, “to minimize blocking of changelog reads on pending transactions” (§3.1.2) (um das Blockieren von Changelog-Lesevorgängen durch ausstehende Transaktionen zu minimieren). Leopard ist ein Konsument dieses Streams: Sein inkrementeller Indexer “calls Zanzibar’s Watch API to receive a temporally ordered stream of Zanzibar tuple modifications” (§3.2.4) (ruft die Watch-API von Zanzibar auf, um einen zeitlich geordneten Stream von Zanzibar-Tupeländerungen zu empfangen).

Speicherung

Welche Datenbanken gibt es, und wie sieht eine Zeile aus? Es gibt drei Arten (§3).

Die Spanner-Datenbanken von ZanzibarEine Datenbank pro Namespace enthält Relationstupel: hier doc, group und folder. Eine einzige Datenbank für Namespace-Konfigurationen enthält die Konfigurationen und ein Changelog der Konfigurationsänderungen. Eine einzige Changelog-Datenbank, die alle Namespaces teilen, zeichnet Tupelaktualisierungen auf. Die aclserver lesen und schreiben die Tupeldatenbanken, laden und überwachen die Konfigurationsdatenbank und hängen an das Changelog an.doc-Tupelgroup-Tupelfolder-TupelaclserverNamespace-Konfigurationen(+ deren Changelog)Changelog(alle Namespaces)lesen, schreibenladen, überwachenanhängen
Eine Tupeldatenbank pro Namespace (links), eine Konfigurationsdatenbank und ein Changelog, die alle Namespaces teilen (rechts).

Tupeldatenbanken. “We store relation tuples of each namespace in a separate database, where each row is identified by primary key (shard ID, object ID, relation, user, commit timestamp).” (§3.1.1) (Wir speichern die Relationstupel jedes Namespace in einer separaten Datenbank, in der jede Zeile durch den Primärschlüssel (Shard-ID, Objekt-ID, Relation, Benutzer, Commit-Zeitstempel) identifiziert wird.) Weil der Commit-Zeitstempel Teil des Schlüssels ist, bleiben alte Versionen in eigenen Zeilen, “so that we can evaluate checks and reads at any timestamp within the garbage collection window” (damit wir Prüfungen und Lesevorgänge zu jedem Zeitstempel innerhalb des Garbage-Collection-Fensters auswerten können). Die Tupel des durchgehenden Beispiels lägen so in den Datenbanken doc und group:

Datenbank Shard-ID Objekt-ID Relation Benutzer Commit-Zeitstempel
doc s(readme) readme owner user:anne t₁
doc s(readme) readme parent folder:A#... t₂
doc s(readme) readme viewer group:eng#member t₃
group s(eng) eng member user:beto t₄

Die Zeilen eines Objekts liegen in der Sortierung beieinander; das Paper sagt, diese Schlüsselreihenfolge “allows us to look up all relation tuples for a given object ID or (object ID, relation) pair” (erlaubt es uns, alle Relationstupel für eine gegebene Objekt-ID oder ein Paar (Objekt-ID, Relation) nachzuschlagen). “Usually the shard ID is determined solely by the object ID” (Meist wird die Shard-ID allein durch die Objekt-ID bestimmt); bei Gruppen mit sehr vielen Mitgliedern kann sie “computed from both object ID and user” (§3.1.1) (aus Objekt-ID und Benutzer berechnet) werden. Das Paper gibt die Shard-Funktion nicht an, s(…) oben ist also ein Platzhalter, und auch die genaue Kodierung der Benutzerspalte ist nicht beschrieben.

Changelog. Eine Datenbank für alle Namespaces mit dem Schlüssel (Changelog-Shard-ID, Zeitstempel, eindeutige Update-ID), “where a changelog shard is randomly selected for each write” (§3.1.2) (wobei für jeden Schreibvorgang ein Changelog-Shard zufällig ausgewählt wird).

Namespace-Konfigurationen. Eine Datenbank mit zwei Tabellen: die Konfigurationen, “keyed by namespace IDs” (mit Namespace-IDs als Schlüssel), und “a changelog of config updates” (ein Changelog der Konfigurationsänderungen), “keyed by commit timestamps” (mit Commit-Zeitstempeln als Schlüssel). Ein Server lädt beim Start jede Konfiguration und folgt dann diesem Changelog (§3.1.3).

Replikation. “Replicas exist in dozens of locations around the world, with multiple replicas per region. The 5 voting replicas are in eastern and central United States, in 3 different metropolitan areas to isolate failures but within 25 milliseconds of each other so that Paxos transactions commit quickly.” (§3.1.4) (Replikate existieren an Dutzenden von Standorten weltweit, mit mehreren Replikaten pro Region. Die 5 stimmberechtigten Replikate befinden sich im Osten und in der Mitte der Vereinigten Staaten, in 3 verschiedenen Ballungsräumen, um Ausfälle zu isolieren, aber innerhalb von 25 Millisekunden voneinander, damit Paxos-Transaktionen schnell committen.) Spanner selbst ist beschrieben in Corbett et al. (OSDI ’12), Referenz [15] des Papers.

Betriebszahlen

§4 des Papers berichtet diese Zahlen. Die Spitzenwerte pro API und die Latenzen stammen aus 7-Tage-Zeiträumen im Dezember 2018 (§4, §4.2); für die übrigen Zahlen nennt das Paper keinen Zeitraum. Jede Zelle ist so zitiert, wie sie dort steht.

Was Die Worte des Papers §
Zeit im Produktivbetrieb “more than 5 years” (mehr als 5 Jahre) 4
Namespaces “more than 1,500 namespaces defined by hundreds of client applications” (mehr als 1.500 Namespaces, definiert von Hunderten von Client-Anwendungen) 4
Tupel “more than 2 trillion relation tuples that occupy close to 100 terabytes” (mehr als 2 Billionen Relationstupel, die fast 100 Terabyte belegen) 4
Replikation “fully replicated in more than 30 locations around the world” (vollständig repliziert an mehr als 30 Standorten weltweit) 4
Client-Last “more than 10 million client queries per second (QPS)” (mehr als 10 Millionen Client-Anfragen pro Sekunde) 4
Spitze pro API “Check requests peak at roughly 4.2M QPS, Read at 8.2M, Expand at 760K, and Write at 25K” (Check-Anfragen erreichen Spitzen von etwa 4,2 Mio. QPS, Read 8,2 Mio., Expand 760.000 und Write 25.000) 4
Server “more than 10,000 servers organized in several dozen clusters around the world” (mehr als 10.000 Server, organisiert in mehreren Dutzend Clustern weltweit) 4
Server pro Cluster “from fewer than 100 to more than 1,000, with the median near 500” (von weniger als 100 bis mehr als 1.000, mit einem Median von etwa 500) 4
Latenz von Check Safe “At the 50th, 95th, 99th, and 99.9th percentiles it peaks at roughly 3, 11, 20, and 93 msec, respectively.” (Im 50., 95., 99. und 99,9. Perzentil erreicht sie Spitzen von etwa 3, 11, 20 bzw. 93 ms.) 4.2
Verfügbarkeit “above 99.999% over the past 3 years of operation at Google” (über 99,999 % in den letzten 3 Betriebsjahren bei Google) 4.3
Interne RPCs “22 million internal “delegated” RPCs per second, split about evenly between reads and checks” (22 Millionen interne „delegierte“ RPCs pro Sekunde, etwa gleichmäßig aufgeteilt auf Lesevorgänge und Prüfungen) 4.4
Cache-Lookups “approximately 200 million lookups per second at peak, 150 million from checks and 50 million from reads” (in der Spitze etwa 200 Millionen Lookups pro Sekunde, 150 Millionen aus Prüfungen und 50 Millionen aus Lesevorgängen) 4.4
Lesevorgänge an Spanner “only 20 million read RPCs per second to Spanner” (nur 20 Millionen Lese-RPCs pro Sekunde an Spanner) 4.4
Spanner-Leselatenz “0.5 msec at the median, and 2 msec at the 95th percentile” (0,5 ms im Median und 2 ms im 95. Perzentil) 4.4
Gehedgte Lesevorgänge “1% of Spanner reads, or 200K reads per second, benefit from hedging” (1 % der Spanner-Lesevorgänge, also 200.000 Lesevorgänge pro Sekunde, profitieren vom Hedging) 4.4

Beachten Sie das Verhältnis in den letzten Zeilen: 200 Millionen Cache-Lookups pro Sekunde gegenüber 20 Millionen Lese-RPCs an Spanner, also etwa zehn Lookups im Arbeitsspeicher für jeden Lesevorgang, der an den Speicher geht.

Quellen