TorsoHPC Documentation

What is TorsoHPC?

TorsoHPC is a high-performance, secure remote linear algebra framework. It solves the problem of "Compute Gravity"—where large-scale scientific problems (millions of unknowns) require specialized hardware (HPC clusters, NVIDIA GPUs, Intel Xeon processors) that isn't typically available on a user's workstation or browser.

Simplicity & Speed: TorsoHPC is designed to be fast and minimal. By using a custom C++ core and zero-overhead binary streaming, it delivers near-native performance over the network.

AI & Heavy Workloads: Beyond standard linear algebra, TorsoHPC's optimized BLAS kernels (SGEMM/SGEMV) and CUDA acceleration make it ideal for heavy AI inference workloads, where massive matrix multiplications must be offloaded to dedicated GPU nodes without the complexity of a full ML framework.

System Architecture

TorsoHPC uses a decoupled architecture where clients define the problem and the remote server provides the "muscle".

[ WEB BROWSER ] <----(V3 Streaming)----> [ WEB GATEWAY ]  
(Zero-RAM UI)                            (Session Mgr)
                                              |
                                              | (Secure Blob)
[ PYTHON CLI ]  <----(V2 Framed)---->    [ COMPUTE SERVER ]
(Data Science)                           (Remote Cluster)
                                         /      |       \
[ C++ CLIENT ]  <----(V2 Framed)----> [INTEL] [NVIDIA] [LAPACK]
(Automation)                           (MKL)   (CUDA)   (DENSE)

Under One Hood

Scientific computing often requires juggling different libraries. TorsoHPC unifies these under a single Secure Blob Protocol. You no longer need to write custom CUDA or LAPACK code—just one call away from:

  • MKL PARDISO: Direct sparse solver for extreme precision.
  • FGMRES: Iterative Krylov subspace methods for massive systems.
  • CUDA / AMGCL: GPU-accelerated algebraic multigrid solvers.
  • Sparse Eigen: Eigensolvers for structural and vibration analysis.

Multi-Tier Storage

To balance performance and scalability, TorsoHPC supports three distinct storage tiers. Users can toggle these tiers dynamically via the UI or CLI to optimize for microsecond latency or massive horizontal scale.

  • LOCAL (Default): Standard Load-on-Demand. Blobs are stored on the server's local NVMe drive and loaded/decrypted only when needed. Ideal for one-off computations.
  • NFS (Shared Filesystem): Optimized for multi-VM cloud deployments. Blobs are stored on a shared network mount (Google Filestore, AWS EFS). This allows infinite horizontal scaling as any compute node can access any user's data instantly.
  • VRAM (Resident Memory): The LLM-style "Cheat Mode." Pins the decrypted matrix into the server's RAM (or GPU VRAM). Subsequent operations skip disk I/O and decryption entirely, running in microseconds.

Note: If VRAM is full, TorsoHPC will gracefully degrade to LOCAL/NFS loading without failing the request.

Browser Interface

The TorsoHPC Web UI provides a zero-RAM streaming pipeline for managing massive datasets directly from your browser.

  • Precision Selection: Use the dropdown next to the + UPLOAD button to select FP64, FP32, or FP16 before uploading. Precision is fixed at birth to ensure CAS consistency.
  • Storage Toggling: Use the Storage column in the Workspace table to switch tiers. Set a matrix to VRAM for high-frequency iterative solves.
  • Hardware Fallback: If you request a GPU solver (e.g., KOKKOS) on a server without CUDA, TorsoHPC will automatically trigger an FP32 Backdoor fallback on the CPU, emitting a warning in the server logs while ensuring the compute finishes.
  • Workspace Sync: Click SYNC WORKSPACE to discover blobs already present on the server. TorsoHPC's CAS ensures you never upload the same data twice.

Compute Credits

One credit buys one core-minute of server compute — equivalently $3.00 per core-hour. Time is metered by the second, and charges are rounded down to the last whole cent with a one cent minimum per operation. Current price: 5¢ per credit. New accounts start with 100 credits, worth $5.00.

  • What is billed: only the time a solve is actually executing. Uploads, workspace sync, storage-tier changes and CAS lookups are free.
  • Dispatched solves: a solve sent to the compute server is metered as one core for its execution time, so a 40-second solve costs 0.6 credits (3¢) regardless of how many ranks the server used internally. Anything under 12 seconds lands on the one cent minimum.
  • Reading the meter: every charge lands in your transaction history with the operation, solver and duration, so you can see where a balance went.
  • Vouchers: redeem a voucher code from the credits panel in the top bar. A voucher is valid on TorsoHPC or TorsoCAE, not both, and can be redeemed once. A voucher sent to a specific email address only works while you are signed in with that email address.
  • Running out: a running solve is never killed for lack of credits — it finishes and settles at the end, even if that takes the balance below zero. While the balance is negative a new solve is refused before it starts, so you never lose work part-way through. Redeem a voucher or top up and it unlocks.

TorsoCAE bills at the same rate but meters parallel solves against their real core count: 4 cores for 30 seconds is 120 core-seconds, or 2 credits. See the Compute Credits section of the TorsoCAE documentation for measured per-operation costs.

Account & Sign-in

One Torso account works on both TorsoHPC and TorsoCAE. Sign-in happens on auth.torsoweb.com, so signing in on one site signs you in on the other.

  • Ways to sign in: Google, or email and password.
  • New email account: choose Continue with email, enter your address and open the link we send to set your password. If the email is not in your inbox, check your spam or junk folder; marking it "Not spam" keeps later Torso emails in your inbox.
  • Passwords: at least 8 characters, including a number and a symbol.
  • Forgot password: use Forgot password? on the sign-in page to get a reset link. Links expire, and each works once.
  • Signing out: signs you out of both TorsoHPC and TorsoCAE.
  • CLI sign-ins: your profile lists every machine signed in with torsosolver login. Revoke any you no longer use or don't recognise.

Intelligent Caching (CAS)

TorsoHPC implements Content-Addressable Storage (CAS) to solve the bottleneck of large-scale data transfer. Instead of identifying files by name or random UUIDs, TorsoHPC identifies data by its unique Intrinsic Mathematical Signature.

Key Benefits:

  • Instant File Reuse: If you or any other client has already uploaded a specific matrix, the server recognizes it instantly. Subsequent "uploads" take 0 milliseconds.
  • Zero-Copy Scalability: Workspaces are automatically synchronized. When you refresh the page or connect from a different device, all server-side blobs are discovered and registered automatically.
  • Reduced Deployment Overhead: Ideal for CI/CD pipelines and automated testing. Testing 10 different solvers on the same 1GB dataset requires only 1GB of total network transfer, not 10GB.

torsosolver CLI

torsosolver runs solves from the terminal. It supports multiple precisions via the --dtype flag and signs in with your Torso account.

Authentication & Identity

torsosolver login prints a link and a short code. Open the link on any device, sign in with your Torso account, check the code matches your terminal and click Authorize; the CLI then saves a token to the owner-only ~/.torso_auth file. The code expires after 10 minutes. Only authorize codes you started yourself.

Your CLI sign-ins are listed in your profile, where you can revoke any of them. Signing in again on the same machine replaces its previous sign-in. If a run reports Sign-in expired or revoked, run torsosolver login again. To use a different token for one run, pass --token.

# Sign in through the browser (once per machine)
torsosolver login

# Revoke this machine's sign-in
torsosolver logout

# The Python client shares the same sign-in
python3 torsosolver.py login

Executing Operations

# Standard sparse solve
torsosolver solve A.mtx b.mtx PARDISO

# FP16 GEMV with Kokkos
torsosolver gemv --dtype=FP16 large_A.bin vector_x.bin KOKKOS

# Python client, pinning data to VRAM
python3 torsosolver.py --dtype FP16 --storage VRAM compute gemv large_A.bin vector_x.bin KOKKOS

Native C++ API

Integrate TorsoHPC directly into your own C++ application. Requests need a compute token: POST to /api/compute-token with Authorization: Bearer <CLI token> (from ~/.torso_auth) and pass the returned token, valid for 5 minutes, to set_token.

#include "torso_client.hpp"

// Initialize client
torso::RemoteTorsoClient client(server_address, port);
client.set_token(compute_token);

// Pack and Solve
std::vector> buffers = { ... };
auto [meta, results] = client.solve(problem_json, buffers);

Python Usage

Leverage pytorso for data-science workflows. Get a compute token as in the C++ API above.

from pytorso import RemoteTorsoClient
client = RemoteTorsoClient(server_address, port)
client.set_token(compute_token)

# Define problem
problem = {
    "operation": "solve",
    "solver": "PARDISO",
    "matrix_A": {"path": "large_A.mtx", "weight": "Sparse"},
    "vector_B": {"path": "vector_b.mtx", "weight": "Dense"}
}

# One-call solution
metadata, results = client.solve(json.dumps(problem), [])