1. LandOffer
  2. Blog
  3. All articles
  4. HPC Portfolio for Scientific Computing Jobs: Present a Scaling Study Honestly

Job search

HPC Portfolio for Scientific Computing Jobs: Present a Scaling Study Honestly

Build a reproducible local scaling study with numerical correctness checks, every repeated timing, strong and weak plots, and explicit measurement limits.

9 min readLandOffer team

An HPC portfolio scaling study should show a fixed workload, a correctness reference, the resource configurations tested and every repeated timing. Explain whether you held total work or work per worker constant, and define what the clock includes. Keep the whole set of repeats: its fastest member cannot establish scalability. Multiple local worker counts also do not make the experiment a cluster benchmark.

LandOffer publishes this guide; use recent scientific-computing and software roles to identify which performance evidence a team requests. The original experiment below actually ran on one local machine on October 23, 2026, Pacific time. It includes a complete measurement record and separate strong- and weak-scaling plot artifacts. No MPI, GPU, cluster, production solver or external compute service was used. The results describe this teaching workload and timing boundary, not a candidate’s employment history.

A researcher partitions one fixed tray of sampling pieces at a desk with a reference notebook and stopwatch.

Choose a numerical task whose answer you can check

This project approximates the integral of 4/(1+x*x) from zero to one using midpoint quadrature. Its analytic value is π. For N samples, the midpoint of interval i is (i+0.5)/N; the implementation sums the function values and divides by N. Each task computes a partial sum with Python’s math.fsum, and the parent combines those partial sums.

The example has a deliberately small scientific scope. It demonstrates partitioning a numerical workload, checking an answer and reporting measurements. It is not a climate simulation, a validated physics model or evidence that the implementation is a competitive quadrature library. The integrand and interval were selected for a compact reproducible demonstration, not for a production performance requirement.

Before timing, the script computes an untimed same-N serial reference for each problem size. Every warmup and measured result must agree with both that reference and math.pi within absolute tolerance 1e-10. Partition assertions check that the intervals cover all indices without gaps or overlaps. A separate uneven 1,003-point, four-way partition also agrees with its serial calculation.

All 36 recorded runs passed their checks. The largest absolute difference from π was approximately 2.09e-14. That is a result for these problem sizes and arithmetic, not a universal error bound for midpoint integration or a claim of arbitrary-precision computation. Faster results would not be retained as successful if the prescribed check failed.

Define strong and weak scaling before running

NERSC’s parallelism documentation distinguishes strong scaling, which fixes the total problem size, from weak scaling, which fixes problem size per processing element. This study applies those definitions to requested local worker processes. NERSC’s discussion of its own systems does not make these processes MPI ranks or allocated cluster nodes.

The strong study keeps 8,000,000 samples total and requests one, two or four workers. The weak study keeps 2,000,000 samples per requested worker, so total samples increase from two million to four million to eight million. The quadrature rule and implementation remain the same. Do not compare the weak two-million baseline to the strong eight-million case and call the difference a parallel speedup.

The one-worker baseline also uses a newly created process pool. It is not the untimed serial reference. Every baseline and parallel timing includes a fresh spawn-pool lifecycle; the untimed correctness reference never enters the speedup ratio. A direct serial-loop baseline or persistent worker pool would answer a different performance question and would need separately labeled measurements.

Worked asset one: complete configuration and repeated measurements

The run used the project’s existing CPython 3.12.14 interpreter on an Apple M5 Pro, Darwin 25.6.0, arm64. The system reported 18 logical and physical CPUs and 68,719,476,736 bytes of memory. Those reported counts do not prove that a requested worker ran on a particular core. No affinity, power, thermal or background-activity control was applied.

This is Python source: no project C or C++ compilation occurred, so there are no benchmark compiler flags to report. The environment receipt separately preserves Python’s build information. No dependencies were installed for the computation or analysis. The scripts use the existing standard library.

The implementation explicitly selects the spawn multiprocessing context. Python’s multiprocessing documentation explains that this starts a fresh interpreter and documents the importable entry-point requirement. The benchmark guards its entry point accordingly. The current documentation displays patch version 3.12.15; the actual tested interpreter remains 3.12.14.

Each configuration received one full warmup, followed by five measured repeats. All six warmups remain in the raw record but are excluded from the summaries. Measured configuration order rotates deterministically between rounds; it is not randomized. This spreads configurations across the run without eliminating time-dependent effects.

The following table contains all 30 measured wall times, rounded to six decimal places. The raw JSON and CSV retain nanosecond values and sequence order.

Study Workers Total samples Repeat 1 Repeat 2 Repeat 3 Repeat 4 Repeat 5
Strong 1 8,000,000 0.530995 0.527518 0.530739 0.576879 0.516338
Strong 2 8,000,000 0.280580 0.283773 0.290295 0.282548 0.286922
Strong 4 8,000,000 0.167801 0.170048 0.166696 0.169455 0.165990
Weak 1 2,000,000 0.156211 0.158386 0.161748 0.161130 0.161556
Weak 2 4,000,000 0.160003 0.157507 0.166071 0.163450 0.160440
Weak 4 8,000,000 0.164344 0.164723 0.168525 0.170606 0.163900

The largest strong one-worker time, 0.576879 seconds, remains included. It was not replaced by a cleaner-looking run. A reviewer can inspect the full spread and see exactly how the retained slower run affects the summary.

State exactly what the timer measured

The parent reads perf_counter_ns immediately before creating a fresh pool. Timing includes process creation, task dispatch and local inter-process communication, numerical computation, parent-side combination of results, and pool close/join. Input partition construction, the serial reference, correctness assertions, JSON output and plotting are outside that interval.

Python’s timing documentation describes the performance counter and its nanosecond variant. Here the runtime reported a monotonic mach_absolute_time() implementation. The measurements are elapsed wall time, including time when the process is not running. They are not CPU time, GPU execution time or network latency.

Warmup does not remove fresh-process startup from later trials: each measured run still creates a new pool. This boundary can be useful when the task is a short-lived job. It cannot answer how a persistent numerical service or a long-running MPI application would perform. Labeling the interval prevents another reader from mistaking the numbers for kernel-only timings.

Local communication is included only as part of total elapsed time. The study has no isolated IPC or synchronization measurement and no inter-node communication at all. Consequently, it cannot assign a fraction of runtime to communication or claim to have identified a communication bottleneck.

Worked asset two: plots, ratios and bounded interpretation

The companion project contains the completed scientific artifacts strong-scaling.svg and weak-scaling.svg, alongside rasterized inspection copies. They are generated from the saved run by the author’s small SVG plotting script, not by ImageGen. Each chart shows all five measured points, a median and the observed minimum-to-maximum range. The range is not a confidence interval.

The strong plot adds an ideal reference of the one-worker median divided by the worker count. The weak plot adds a constant one-worker reference. These dashed references help compare shapes; neither predicts a real runtime or removes startup costs from the measured baseline. The actual chart titles, axes, worker labels and legends identify the local process-pool scope.

Study Workers Median seconds Observed min–max seconds Speedup Efficiency
Strong 1 0.530739 0.516338–0.576879 1.000× 100.00%
Strong 2 0.283773 0.280580–0.290295 1.870× 93.51%
Strong 4 0.167801 0.165990–0.170048 3.163× 79.07%
Weak 1 0.161130 0.156211–0.161748 Not applicable 100.00%
Weak 2 0.160440 0.157507–0.166071 Not applicable 100.43%
Weak 4 0.164723 0.163900–0.170606 Not applicable 97.82%

Strong speedup is the one-worker median divided by the same-total-work median at p workers. Strong efficiency divides that ratio by p. Weak efficiency divides the one-worker, two-million-sample median by the p-worker median at p times that total work. Ratios are calculated from unrounded timings, rather than the six-decimal display values.

The strong four-worker result is approximately 3.163× faster under this boundary, not a general claim of four-core or cluster acceleration. Weak runtime stays close to its baseline as total work grows fourfold. The two-worker weak efficiency of 100.43% does not establish meaningful superlinear behavior. Its range overlaps the one-worker range, and conditions were uncontrolled.

Strong four-worker and weak four-worker cases both process eight million samples with the same code and requested worker count. Their timing ranges overlap. The study labels do not represent separate optimizations, and their small median difference should not become a claim that “weak scaling is faster.”

A researcher compares one fixed partitioned tray with increasing numbers of equally filled bowls beside a measurement notebook.

Explain possible limits without inventing a profile

The curves show elapsed-time behavior; they do not isolate its causes. Fresh-process startup, local IPC, scheduling, different core assignments and background activity are possible contributors. Without profiling or a controlled comparison, these remain hypotheses. The experiment does not demonstrate a memory-bandwidth limit, cache effect, network bottleneck or thermal throttling.

Choose one question for a follow-up experiment and preserve the present run as its comparison record. For example, comparing fresh pools with a separately timed persistent-pool implementation could investigate lifecycle cost. Repeating the study on a declared target machine could test portability of the observed behavior. Neither experiment has been performed here, so neither supplies an explanation for the present curves.

Preserve the existing run before exploring alternatives. Changing problem size, timing boundaries or startup policy and replacing the old results would obscure which claim each result supports. A slowdown, a wider range or a failed correctness check is information to explain, not a reason to search for a more flattering configuration.

Package a reviewer can rerun

The included project keeps the benchmark, analyzer, README, environment, raw 36-trial record, complete CSV, summary and both plots together. Measurement refuses to overwrite an existing run. The README gives the exact original interpreter and commands; another timing run should use a new destination and record its own environment. Matching timings are not guaranteed.

Two fresh analysis processes regenerated identical summaries, CSVs and SVGs from the saved measurements. Those matching files demonstrate deterministic analysis of the saved run. They are not new timing measurements or independent performance replication. Three negative fixtures were actually rejected: a missing repeat, an incorrect weak-study size and a failed correctness record. These checks protect the declared finite input contract, not every possible benchmark design.

A truthful portfolio summary is: “Ran a local CPython process-pool quadrature study across one, two and four requested workers; checked analytic and serial references, retained all repeated timings, and reported strong/weak scaling with explicit lifecycle and environment limits.” It does not claim MPI development, scientific production validation or cluster operations. For a role in a LandOffer job shortlist, identify the measurement requirement this project demonstrates and the target-system experiments it leaves untested.

Sources and Further Reading