Early-stage · CPU verification prototype

Scientific code.Modern compute.

Parakern is building an AI-powered system to modernize scientific Fortran for GPUs, with numerical verification built into the optimization process.

Explore Parakern
Footage: Septimiu Lupea via Pexels

The starting point

Old code, carefully trusted.

Scientific computing depends on software developed and validated over decades. Much of it is written in Fortran, and moving it to modern accelerators can require substantial engineering effort.

Some computational routines contain parallelism that GPUs could exploit. The challenge is finding those opportunities without compromising the numerical behavior scientists depend on.

That’s the problem Parakern is working to solve.

Conceptual example

The same loop, made for GPUs.

An illustrative before and after. The original is never modified: each candidate is a separate version that has to pass numerical validation before anything else.

step.foriginal
      SUBROUTINE STEP(T, TNEW, N, M, K)      INTEGER N, M, I, J      REAL T(N,M), TNEW(N,M), K      DO 20 J = 2, M-1        DO 10 I = 2, N-1          TNEW(I,J) = T(I,J) + K*(T(I+1,J) + T(I-1,J)     &      + T(I,J+1) + T(I,J-1) - 4.0*T(I,J))   10   CONTINUE   20 CONTINUE      RETURN      END
step_candidate.f90candidate, illustrative
subroutine step(t, tnew, n, m, k)  integer :: n, m, i, j  real :: t(n,m), tnew(n,m), k  !$acc data copyin(t) copy(tnew)  !$acc parallel loop collapse(2)  do j = 2, m-1    do i = 2, n-1      tnew(i,j) = t(i,j) + k*(t(i+1,j) + t(i-1,j) &                 + t(i,j+1) + t(i,j-1) - 4.0*t(i,j))    end do  end do  !$acc end dataend subroutine step

Illustrative example. Highlighted lines on the left are the loop nest being considered; highlighted lines on the right are what a candidate adds.

Conceptual

Many cells at once.

Each cell of this grid can be computed independently of its neighbours in the same step. A GPU has thousands of small cores, so it can update many cells at the same moment. Whether a given routine is actually faster this way is measured, never assumed.

A CPU loop visits one cell at a time
A GPU can update many at once

Illustrative diagram. It implies no performance figure.

Conceptual interface

The workflow, one routine at a time.

Conceptual interface. The content is illustrative and nothing shown is a measured result.
CPU prototypeSimulatedPlanned
step_heat.f90 · conceptualIllustrative
Workflow

Analyze

CPU prototype

Reads the Fortran and finds the loops and routines that matter.

SUBROUTINE STEP(T,TNEW,N,M,K)
INTEGER N,M,I,J
REAL T(N,M),TNEW(N,M),K
DO 20 J=2,M-1  DO 10 I=2,N-1    TNEW(I,J)=T(I,J)+K*(T(I+1,J)+T(I-1,J)
 &  +T(I,J+1)+T(I,J-1)-4.0*T(I,J))
 10 CONTINUE
 20 CONTINUE

How it works

From legacy source to verified candidates.

Parakern is being designed to analyze scientific Fortran, propose GPU-oriented transformations, compile and execute candidates, and compare their outputs against the original.

Candidates that fail numerical validation are rejected. Candidates that pass can be evaluated for performance.

The goal is to automate this process while keeping every decision backed by inspectable evidence.

INPUT01020304 · 05060708 outside tolerance Fortran sourceyour original AnalyzeCPU prototype ProposeCPU prototype Candidate A Candidate B Candidate C Compile + runsimulated GPU ValidateCPU prototype Benchmarksimulated AI-driven · planned

Fortran source

CPU prototype

Your original code stays the reference throughout.

  1. Analyze CPU prototype

    Reads the Fortran and finds the loops and routines that matter.

  2. Propose CPU prototype

    Proposes GPU-oriented transformations. Proposals are scripted today; AI-generated proposals are planned.

  3. Transform CPU prototype

    Generates OpenACC candidates from the original.

  4. Compile Simulated

    Builds each candidate. GPU-oriented stages are developed and simulated.

  5. Execute Simulated

    Runs each candidate. Real NVIDIA GPU execution is not yet validated.

  6. Validate CPU prototype

    Compares the output with the original, within the tolerance you set. A candidate that fails does not move on.

  7. Benchmark Simulated

    Candidates that pass can be evaluated for performance. Simulated for now; no real GPU measurements yet.

  8. Iterate Planned

    Generating and evaluating transformations with AI, rather than scripted proposals alone, is planned.

Where it stands

Building toward autonomous optimization.

The same three markers are used in the interface and the diagram above, so you can always tell a working part from one that is simulated or planned.

Working

CPU prototype

A scripted optimization pipeline runs on CPU, evaluates candidates against a reference implementation, and produces verification evidence.

Not yet validated

GPU execution

GPU-oriented stages have been developed and simulated. Real NVIDIA GPU execution and performance validation remain upcoming milestones.

Planned

AI-driven optimization

The next stage is to generate and evaluate transformations using AI rather than relying solely on scripted proposals.

Principles

Performance without compromising scientific confidence.

Illustrative

The original is the reference.

Candidate outputs are compared against the original implementation using defined numerical tolerances.

Illustrative

Correctness comes before performance.

An optimization that fails validation cannot be accepted, regardless of its apparent speed.

Illustrative

Evidence over assumptions.

Performance claims require actual measurements. Numerical agreement within a tolerance provides evidence of correctness, not a mathematical proof.

Who it’s for

Built for the software science depends on.

Heat and diffusion

Numerical simulations involving grid-based calculations and stencil operations.

Fluid dynamics

Computational routines where performance matters and numerical behavior must be carefully checked.

Weather and climate

Long-lived scientific applications where modernization must respect established validation practices.

These are intended application areas, not current customer deployments.

Questions

Plain answers.

What does Parakern do?

It is being built to analyze scientific Fortran, propose GPU-oriented transformations, compile and execute candidates, and compare their outputs against the original within defined tolerances. Candidates that fail numerical validation are rejected. Today a CPU verification prototype works; GPU execution is not yet validated, and AI-driven optimization is planned.

How do I know the results are right?

Every candidate is compared with your original, within a tolerance you choose. Agreement within a tolerance is evidence, not a proof, so the tolerance and the judgement stay with you.

Will it make my code faster?

We cannot say yet. GPU-oriented stages have been developed and simulated, but real NVIDIA GPU execution and performance validation are upcoming milestones. We are not publishing a speed-up figure until one has been measured on real hardware and validated against the original.

Which languages and hardware?

The focus is scientific Fortran, OpenACC, and NVIDIA GPUs.

Is it available today?

It is early-stage. A CPU verification prototype works, and GPU execution is not yet validated. The best way to find out where it stands is to tell us what you run.

What about pricing, security and data handling?

We have not published pricing or a security policy yet, and we would rather say so than imply otherwise. Ask us and we will answer plainly.

Start with one routine.

We’re building Parakern for researchers and engineers working with computationally demanding scientific software.

Talk to us

Tell us a little about the code you run.