Das Problem des Mooreschen Gesetzes

Question

Angenommen, Sie müssen ein Programm auf dem schnellsten Supercomputer der Welt ausführen, das 10 Jahre benötigt. Das könnten Sie:

• 250 Millionen Dollar jetzt ausgeben
• Programm seit 9 Jahren, Mooresches Gesetz Beschleunigung (4.000x schneller), Ausgaben von 1 Mio. $ in 10 Jahren, Fertigstellung in 2 Wochen.

Was ist die optimale Strategie?

_{Frage von " <a href="https://research.microsoft.com/~Gray/talks/IO_talk_2006.ppt" rel="nofollow noreferrer">Langzeitspeicher-Trends und Sie </a>"}

Answer 1

Mooresches Gesetz geht es nicht um Geschwindigkeit, sondern um die Anzahl der Transistoren auf einer bestimmten Siliziumfläche. Es gibt keine Garantie dafür, dass sich die Geschwindigkeit in 9 Jahren um das 4000-fache erhöhen wird. Wenn überhaupt, dann hat sich die GHz-Geschwindigkeit in den letzten Jahren eingependelt. Was derzeit zunimmt, ist die Anzahl der Kerne in einer CPU.

Wenn sich das Programm nicht für eine Vektorisierung eignet (d.h. in verschiedene Teile aufgespalten werden kann, die parallel berechnet werden können), dann bringt es keinen Vorteil, 9 Jahre zu warten, denn es wird nicht viel schneller sein, da sich die Taktraten in den dazwischen liegenden Jahren kaum erhöhen dürften.

Answer 2

Angenommen, das Programm ist unendlich parallelisierbar (es kann also immer alle Kerne aller verfügbaren CPUs nutzen)...
Angenommen, Das Programm kann nicht angehalten und während der Ausführung auf eine andere Maschine verschoben werden...
Angenommen, das einzige Problem ist die Zeit (vielleicht haben wir einen großen Forschungszuschuss und verwenden immer die besten verfügbaren Computer)...

Wir haben vier Gleichungen (na ja, eigentlich sind zwei davon Funktionen):

1. endtime(startyear) = startyear + (calculations / speed(startyear))
2. speed(year) = speed(year-1.5) 4 (das Problem geht davon aus, dass sich die Geschwindigkeit sowohl der Hardware als auch der Software alle 18 Monate verdoppelt)
3. endtime(0) = 0 + (calculations/speed(0)) = 10 years
4. speed(0) = calculations/(10 years) (impliziert durch #3)

Ich habe angefangen, Ableitungen zu verwenden, um die Endzeit zu minimieren, aber ich habe gemerkt, dass ich mir meine Differentialgleichungen nicht mehr gut merken kann. Also habe ich #2 in die Äquivalente Exponential-Wachstums-Formel :

speed(year) = speed(0)*4 (Jahr/1,5) = (calculations/10)*4 (Jahr/1,5)

Dann habe ich dieses kleine BeanShell-Skript geschrieben:

calculations() {
    return 10000000; // random constant (gets cancelled out anyway)
}
speed(year) {
    speed0 = calculations()/10; // constant factor
    return speed0*Math.pow(4.0, year/1.5);
}
endtime(startyear) {
    return startyear + calculations()/speed(startyear);
}
findmin() {
    start = 0.0;
    finish = 10.0;
    result = 0.0;
    // home in on the best solution (there should only be one minimum)
    for (inc = 1; inc > 0.00000001; inc /= 2.0) {
        result = findmin(start,finish,inc);
        start = result-2*inc;
        finish = result+inc;
    }
    print("Minimum value is " + result + ", taking a total of " +
            endtime(result) + " years");
}
findmin(start,finish,inc) {
    lastNum = 0;
    lastVal = Double.MAX_VALUE;
    for (i = start; i < finish; i += inc) {
        result = endtime(i);
        if (result > lastVal) {
            print("Minimum value between " + start + " and " + finish +
                    " is " + lastVal + ", occurring at " + lastNum);
            return i;
        }
        lastNum = i;
        lastVal = result;
    }
    return lastNum;
}

Sortie :

bsh % source("moore.bsh");
bsh % findmin();
Minimum value between 0.0 and 10.0 is 3.5749013123685915, occurring at 2.0
Minimum value between 1.0 and 4.0 is 3.4921256574801243, occurring at 2.5
Minimum value between 2.0 and 3.5 is 3.4921256574801243, occurring at 2.5
Minimum value between 2.25 and 3.0 is 3.4886233976754246, occurring at 2.375
Minimum value between 2.25 and 2.625 is 3.488620519067143, occurring at 2.4375
Minimum value between 2.375 and 2.5625 is 3.488170701257679, occurring at 2.40625
Minimum value between 2.375 and 2.46875 is 3.488170701257679, occurring at 2.40625
Minimum value between 2.390625 and 2.4375 is 3.488170701257679, occurring at 2.40625
(snip)
Minimum value between 2.406149387359619 and 2.4061494767665863 is 3.4881706965827037,
occurring at 2.4061494171619415
Minimum value is 2.4061494320631027, taking a total of 3.488170696582704 years

Unter den oben genannten Voraussetzungen lautet die Antwort also: abwarten. 2.406149... Jahre (oder ungefähr 2 Jahre, 148 Tage (laut Google).

---

Editar: Ich habe festgestellt, dass die Lösung der zweiten Formel, die wie oben beschrieben umgeschrieben wurde, nur einfache Berechnungen erfordert.

endtime(x) = x + c/speed(x) (where c = calculations)
speed(x) = speed(0) * 4^(x/1.5) = (c/10)*4^(2x/3)
=> endtime(x) = x + c/((c/10)*4^(2x/3))
              = x + 10*(4^(-2x/3))
d/dx endtime(x) = 1 + 10*ln(4)*(-2/3)*(4^(-2x/3))

Kritischer Punkt ist, wenn d/dx = 0, also

1 + 10*ln(4)*(-2/3)*(4^(-2x/3)) = 0
=> 4^(-2x/3) = 1/(10*ln(4)*(2/3))

Nehmen Sie log4 von beiden Seiten: (denken Sie daran, dass log4(x) = ln(x)/ln(4) und dass ln(1/x) = -ln(x) )

-2x/3 = ln(1/(10*ln(4)*(2/3))) / ln(4)
      = -ln(10*ln(4)*2/3) / ln(4)
=> x = (-3/2) * -ln(1/(10*ln(4)*2/3)) / ln(4)
     = 3*ln(10*ln(4)*(2/3)) / 2*ln(4)

Das sieht nach einem furchtbaren Durcheinander aus (es hilft auch nicht, dass es hier keine gute Möglichkeit gibt, mathematische Formeln darzustellen). Aber wenn du es in deinen Taschenrechner einträgst, solltest du Folgendes erhalten 2.4061494159159814141268120293221 (zumindest wenn Sie den Windows-Rechner verwenden, wie ich es gerade getan habe). Meine vorherige Antwort war also bis auf sieben Nachkommastellen korrekt (die bei einem Problem wie diesem natürlich bedeutungslos sind).

(Ich sollte anmerken, dass dies nur ein kritischer Punkt ist, nicht unbedingt ein Minimum. Aber die zweite Ableitung (die die folgende Form hat -(some constant)*4 -2x/3 ) ist immer negativ. Die Funktion ist also immer konkav nach oben, daher ist der einzige kritische Punkt das Minimum).

Answer 3

Mooresches Gesetz befasst sich mit der Anzahl der Transistoren, die auf einem einzigen Chip untergebracht werden y bezieht sich nicht auf die Geschwindigkeit von Mikroprozessoren im Allgemeinen.

Der derzeitige Trend zeigt jedoch, dass wahrscheinlich immer mehr Kerne in einem einzigen Prozessorchip Platz finden werden, so dass die gleichzeitige Programmierung immer wichtiger wird, um die in einem Prozessor verfügbare Rechenleistung zu nutzen.

Es ist also schwer zu sagen, ob man es jetzt tun oder abwarten soll - wie auch immer, so oder so, die gleichzeitige Programmierung oder das verteilte Rechnen ins Spiel kommen wird als wir werden nicht erleben, dass ein einzelner Kernprozessor exponentiell schneller wird (in Bezug auf die Taktrate) aufgrund der physikalischen Grenzen der derzeitigen Halbleitertechnologie und der Naturgesetze.

Answer 4

Stellen Sie sicher, dass Ihr Programm pausieren und fortfahren kann, und setzen Sie es dann auf immer schnellere Maschinen, wenn diese auftauchen. Das Beste aus beiden Welten...

Answer 5

Vereinfachen Sie das Modell, um eine Schätzung zu erstellen, die Sie jetzt durchführen können. Wenn mehr/bessere Ressourcen zur Verfügung stehen, verfeinern Sie das Modell, um genauere Ergebnisse zu erzielen.