Skip to content
TheChatArchiveThe Chat Archive
Geminigemini-2.5-flash-preview-04-17· GoogleHugging Face LMArena Human Preference 140K

how fast do I have to go back in time for my iphone to outperform the best super…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Geminigemini-2.0-flash-001’s answer.
  1. User

    how fast do I have to go back in time for my iphone to outperform the best super computer of the time at supercomuting workloads (whatever those were at the time)

    don't just look at raw flops numbers, consider the workload

  2. Gemini Assistant

    Okay, let's break this down, considering the nuances beyond just raw peak FLOPS.

    Historical supercomputing workloads often relied heavily on:

    1. Double-Precision (FP64) Floating-Point Arithmetic: Crucial for accuracy and stability in simulations (climate, physics, fluid dynamics, etc.).
    2. Large Amounts of Memory: To hold the entire problem domain (grids, matrices, etc.).
    3. High Memory Bandwidth: To feed data quickly to the processors.
    4. Specific Architectures: Vector processors (70s/80s) or Massively Parallel Processors (MPP) with high-speed interconnects (90s onwards), optimized for specific types of problems (highly regular loops for vector, distributed domain decomposition for MPP).

    Now let's look at a modern iPhone (let's assume a recent Pro model with an A-series chip and GPU):

    1. Double-Precision (FP64): This is a major bottleneck. Mobile GPUs are optimized for single-precision (FP32) for graphics. Their FP64 performance is often very low compared to their FP32 peak (sometimes 1/16th or less). The CPU cores have decent FP64 performance for a few cores, but don't scale like a supercomputer.
    2. Memory: A modern iPhone has perhaps 6-8 GB of RAM. While fast, this is tiny compared to the hundreds of GBs or even TBs of distributed memory in historical supercomputers.
    3. Memory Bandwidth: Decent for a mobile device, but significantly lower than dedicated supercomputing nodes or shared-memory vector systems of the past.
    4. Architecture: Optimized for mobile tasks (CPU general purpose, GPU for graphics/FP32 compute, Neural Engine for ML/matrix ops). It doesn't have vector registers in the old sense, nor the inter-node communication fabric of an MPP system.

    Comparing Workloads:

    To "outperform" on a supercomputing workload, your iPhone would need to complete a representative problem faster than the supercomputer could at that time. This means either: a) Running the same size problem faster (unlikely due to memory limits). b) Running a scaled-down but representative version of the problem faster. c) Performing the core computational kernels (e.g., a specific matrix multiply, a simulation step) faster.

    Given the FP64, memory, and architectural differences, comparing peak FP32 TFLOPS of an iPhone to historical FP64 GFLOPS is misleading. We need to compare the effective speed on the actual type of calculations used.

    Historical Timeline (Focus on FP64 Peak):

    • 1970s: Cray-1 (~160 MFLOPS FP64 peak). Vector machine.
    • Late 1980s: Cray Y-MP (~2.3 GFLOPS FP64 peak). Vector machine.
    • Early 1990s: Fujitsu Numerical Wind Tunnel (~124 GFLOPS FP64 peak), Intel Paragon (~143 GFLOPS FP64 peak). Rise of MPPs.
    • Mid-1990s: Fujitsu VPP500 (~317 GFLOPS FP64 peak). Hybrid vector/parallel.
    • Late 1990s: ASCI Red (~1.3 TFLOPS FP64 peak). First TFLOP machine.

    iPhone vs. History:

    • Against 1970s/1980s Vector Machines (Cray-1, Cray Y-MP): A modern iPhone's CPU cores alone can achieve multi-GFLOPS of FP64 performance combined. The total FP64 capability across CPU and GPU is likely in the tens of GFLOPS range (maybe 50-100 GFLOPS peak if the workload is favorable, but sustained will be lower). This puts its theoretical capability above the peak FP64 of the Cray-1 and likely comparable to or exceeding the Cray Y-MP. While the vector machines had specific advantages on vectorizable code, the iPhone's raw speed and better memory latency for non-vector access mean it could likely outperform them on many representative computations, especially if the problem fits in its memory.
    • Against Early 1990s MPPs (Paragon, VPP500): These systems pushed into the 100+ GFLOPS FP64 range using many processors or powerful vector units. Their advantage was not just peak speed, but the ability to tackle much larger problems due to distributed memory. A single iPhone's sustained FP64 performance and limited memory would struggle to compete with these systems on their typical large-scale workloads.

    Conclusion:

    Considering the need for FP64 and typical workload characteristics, your iPhone likely surpasses the computational power of the best supercomputers from the late 1980s to the very early 1990s.

    You would need to go back in time to an era before supercomputing consistently broke the ~50-100 GFLOPS FP64 barrier, and before systems routinely had access to hundreds of GBs of memory for a single job. The peak vector machines of the late 80s (like the Cray Y-MP) are likely the point where a modern iPhone starts to consistently look faster on relevant computational kernels if memory wasn't the bottleneck.

    So, aim for around 1988-1991. Before the Fujitsu Numerical Wind Tunnel and Intel Paragon pushed performance clearly into the realm that a single mobile device couldn't match on its own for typical supercomputing tasks.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.