Wie lange dauert es, bis ein PC auf eine Billion zählt

Diese Frage kam nach einer Diskussion mit einem Kollegen über ein Unternehmen im Wert von über 20 Billionen Dollar – und wir konnten uns einfach nicht vorstellen, wie so viel Geld in bar aussehen würde. Nur um eine Vorstellung davon zu bekommen, haben wir berechnet, wie viele hundert Dollarnoten nötig wären, um die Erde einmal zu umkreisen – die Antwort war, glaube ich, um 240.000.000, was ungefähr 24 Milliarden US-Dollar bedeutet. Das ist eine Menge Geld. Wie viel würde eine Person brauchen, um so viel Geld zu zählen? Nun, niemand kann sicher sagen.

Aber wir können einen ziemlich guten Eindruck davon machen, wie viel ein Computer brauchen würde, um bis zu einer Billion zu zählen. Um einfach zu iterieren, keine andere Aktion dazwischen. Dafür habe ich einen einfachen Code geschrieben, der misst, wie viel es braucht, um bis zu einer Million zu zählen, und dann einige einfache Berechnungen durchführt, um zu schätzen, wie viel es dauern würde, bis zu verschiedenen Werten zu zählen, und dann die Ergebnisse auf freundliche Weise mit einer Methode mit freundlicher Genehmigung von StackOverflow.

Die Ergebnisse sind interessant. Und die Antwort lautet: es hängt von Ihrer Maschine ab. Selbst auf derselben Maschine erhalten Sie je nach Belastung unterschiedliche Ergebnisse. Aber schauen wir uns meine ein wenig an:

• Eine Milliarde (9 Nullen) wird schnell erreicht – 15 Sekunden
• aber um zu einer Billion (12 Nullen) zu gelangen – der Unterschied ist erstaunlich – 4 Stunden und 10 Minuten. Grundsätzlich 1000 mal mehr.
• die Unterschiede werden noch beeindruckender, wenn wir bis zu Billiarden (15 Nullen) gehen, die 173 Tage dauern würden, und dann Quintillionen (18 Nullen), die 475 Jahre dauern würden
• Der letzte, für den ich die Mathematik gemacht habe, ist ein Sextillion (21 Nullen) und mach dich bereit – mein Laptop würde genau 7708 Jahre, 292 Tage, 6 Stunden, 43 Minuten und 52 Sekunden brauchen, um zu diesem Wert zu iterieren.

Wie gesagt – diese Werte hängen stark von der Maschine ab. Sie können es also selbst ausprobieren und vielleicht die Ergebnisse teilen. Code unten:

static void Main(string args){ var startTimestamp = DateTime.Now; for (int i = 0; i <= 1000000; i++); var elapsedTime = DateTime.Now - startTimestamp; Console.WriteLine(string.Format("{0} for 1 billion (9 zeros),", GetReadableString(new TimeSpan(elapsedTime.Ticks * 1000)))); Console.WriteLine(string.Format("{0} for 1 trillion (12 zeros)", GetReadableString(new TimeSpan(elapsedTime.Ticks * 1000000)))); Console.WriteLine(string.Format("{0} for 1 quadrillion (15 zeros)", GetReadableString(new TimeSpan(elapsedTime.Ticks * 1000000000)))); Console.WriteLine(string.Format("{0} for 1 quintillion (18 zeros)", GetReadableString(new TimeSpan(elapsedTime.Ticks * 1000000000000)))); Console.WriteLine(string.Format("and {0} for it to count up to 1 sextillion (21 zeros).", GetReadableString(new TimeSpan(elapsedTime.Ticks * 1000000000000000)))); Console.ReadKey();} private static string GetReadableString(TimeSpan span){ string formatted = string.Format("{0}{1}{2}{3}{4}", span.Duration().Days > 364 ? string.Format("{0:0} year{1}, ", span.Days / 365, span.Days == 365 ? string.Empty : "s") : string.Empty, span.Duration().Days > 0 ? string.Format("{0:0} day{1}, ", span.Days % 365, span.Days % 365 == 1 ? String.Empty : "s") : string.Empty, span.Duration().Hours > 0 ? string.Format("{0:0} hour{1}, ", span.Hours, span.Hours == 1 ? String.Empty : "s") : string.Empty, span.Duration().Minutes > 0 ? string.Format("{0:0} minute{1}, ", span.Minutes, span.Minutes == 1 ? String.Empty : "s") : string.Empty, span.Duration().Seconds > 0 ? string.Format("{0:0} second{1}", span.Seconds, span.Seconds == 1 ? String.Empty : "s") : string.Empty); if (formatted.EndsWith(", ")) formatted = formatted.Substring(0, formatted.Length - 2); if (string.IsNullOrEmpty(formatted)) formatted = "0 seconds"; return formatted;}

Wie wäre es mit dem Durchlaufen aller GUIDs?

Dann wechselte ich im wahren Geist eines Ingenieurs zu einem anderen Thema – das (für mich) völlig verwandt war – der Einzigartigkeit von GUIDs. Ich hatte mich zuvor gefragt, wie einzigartig eine GUID tatsächlich ist. Und ich habe meine Antwort damals etwas bekommen, aber jetzt denke ich, dass es noch klarer ist.

Um zu beginnen – GUIDs werden normalerweise als 32 hexadezimale Ziffern dargestellt – das bedeutet 10 mehr Ziffern als eine Sechstillion. Andererseits kann jede der Ziffern in einer GUID Werte von 0 bis F (16 Werte) haben, verglichen mit einer normalen Ganzzahl, die nur 0 bis 9 (dh 10 Werte) zulässt. Und wo wir im vorherigen Beispiel bis zu einer gezählt haben, gehen wir hier bis zu F.

Wenn meine Mathematik korrekt ist, nehmen wir die Zeit von der Sechstillion (7708 Jahre) – multiplizieren sie mit 10.000.000.000 (die zehn Nullen), dann mit 1,6 – es gibt 1,6 weitere Werte für jede Ziffer – und dann mit 16 (F).

Das sind ungefähr 1.973.248.000.000.000 Jahre – also 1.973.248 Millionen Jahrtausende. So viel würde mein Laptop brauchen, um alle möglichen Werte einer GUID zu durchlaufen. Wie einzigartig ist das?