Industrial telemetry meets GPU execution inside PostgreSQL
Factories, substations, renewable-energy installations and process plants emit data continuously: machine operating conditions, production and quality records, meter and inverter readings. The hard part is not only volume but the path the data travels. A conventional chain pushes measurements from sensors and SCADA into a historian, through ETL into a data lake, and onward to a GPU cluster — adding latency, extra processing and several representations of the same information that teams must maintain. By the time analytics or ML sees the data, it may no longer reflect current operations.
CYBERTEC PGEE GPU targets the computational bottleneck inside that chain: the time needed to scan, aggregate and join large datasets in PostgreSQL. Instead of routing analytical work to a separate engine, it adds a GPU execution path to the PostgreSQL environment, leaving transactions, data visibility and query planning under PostgreSQL's control. Operational records, historical measurements and analytical workloads can therefore coexist in one system.
Where GPU execution fits — and where it does not
PostgreSQL handles transactional processing, indexed lookups, concurrent writes and a broad range of SQL well. The pressure point is the large analytical query — hundreds of millions or billions of rows to total production, group measurements by equipment or find trends. With a sound plan, the CPU memory hierarchy often becomes the dominant cost, and adding cores does not yield proportional gains when memory bandwidth or parallel record processing is the limit. GPUs offer many parallel units and high-bandwidth device memory, which suits large scans and aggregations. PGEE GPU plugs that capability into query execution.
Planner-driven selection, query by query
GPU alternatives join PostgreSQL's planning process. The planner picks a GPU path when its estimated cost is lower and the operation can still produce the correct PostgreSQL result. Candidates include large scans, scalar aggregates, GROUP BY, DISTINCT, COUNT(DISTINCT) and supported star-schema joins. Transactional operations, writes and non-qualifying operations stay on the CPU, and a single query can mix paths — a large scan and aggregate on the GPU while index scans remain on the CPU. Applications keep standard SQL, their existing schema and ordinary PostgreSQL access; no GPU-specific programming model is required.
Visibility rules and result equivalence
Acceleration is only useful if results stay correct. PostgreSQL decides which rows a query may see, and the GPU path must honor those rules against data represented in GPU memory. Cached data is validated against PostgreSQL's visibility machinery; anything that cannot safely be served from the GPU cache falls back to the CPU within the same query. Our reporting of the engine's testing covers 18,329 byte-identity checks with zero mismatches in a two-hour concurrency test, plus tests for concurrent writes, serializable transactions and crash recovery.
A three-tier data path for industrial deployments
1. Local collection and processing
PostgreSQL can run at the factory, substation, wind farm or process plant, filtering incoming records, computing aggregates and flagging events before data leaves the site — which reduces transfer volume. Local autonomy keeps operations running when connectivity drops. Replication and high-availability mechanisms support these site deployments; they are part of PostgreSQL's architecture, not the GPU execution feature itself.
2. Central consolidation and acceleration
Selected data — raw measurements, aggregates or events, depending on requirements — flows into a central PostgreSQL instance running PGEE GPU, with replication letting disconnected sites catch up on reconnect. Headquarters can then query across equipment fleets, facilities or distributed energy assets rather than site by site, with large scans, aggregations and supported joins eligible for GPU execution when the planner judges it worthwhile. PostgreSQL remains the database technology across the whole chain.
3. From analysis to decisions
The architecture is aimed at data-intensive work such as:
- Predictive maintenance — patterns of wear or potential failure across equipment fleets.
- Quality and process optimisation — correlations between production measurements, process variation, yield and scrap.
- Grid balancing and forecasting — demand and renewable-output changes from meter and generation data.
- Energy trading and demand response — generation, demand and trading positions.
- Anomaly and safety monitoring — unusual behaviour examined with historical context.
- Digital twins and simulation — analytical systems fed with current operational state.
These are application areas enabled by the broader architecture. PGEE GPU does not by itself perform predictive maintenance, forecasting or safety decisions; that requires application logic, models and operational systems. Its contribution is database-side analytical capacity over large volumes of underlying data.
Reading the benchmark numbers correctly
A CYBERTEC benchmark on a COUNT(*) over 2.4 billion rows reports the following:
| Configuration | Execution time |
| 32 CPU cores | 12.3 seconds |
| 4 NVIDIA H200 GPUs | 1.10 milliseconds |
That is roughly 2.18 trillion rows per second on the GPU configuration, about 11,200 times the throughput of the 32-core CPU baseline. The figures describe this specific benchmark and hardware; query shape, data representation, cache state and hardware all affect outcomes, so they are not a general speedup guarantee.
The wider performance materials give another view. In a 100 GB TPC-DS query suite, 68 of the 99 standard queries are reported to accelerate with zero wrong answers, and the strongest curated result is a 474× speedup for one query against an estimated single CPU core. This is a like-for-like engineering comparison, not an audited TPC-DS result. Gains vary: the median across all 99 queries is close to break-even against a strong 20-core CPU baseline — which is why the planner, not a forced setting, decides when the GPU runs. For a real deployment, evaluate representative queries against your own data, hardware and execution conditions.
Machine learning without the export round-trip
Analytics often feeds ML: failure-risk estimates from equipment measurements, quality outcomes from production variables, demand patterns from energy data. Classically, records are exported, parsed or transformed in Python and then copied to GPU memory for model execution — extra movement and preparation. The PGEE GPU ML client offers a shorter route for suitable workflows: it exposes GPU-resident PostgreSQL columns to PyTorch through DLPack, so a co-located training process can map the existing GPU memory pages as read-only tensors instead of doing a bulk export and re-import. The pgee_gpu export bridge exposes that data to the ML process, and write_back can return predictions to a PostgreSQL table. The client handles data access and movement; it is not an in-database training engine or a complete inference platform.
Benchmark materials report a 20-million-row, eight-column feature matrix taking 18.1 seconds via the traditional path versus 0.15 seconds via zero-copy — a measured 124x difference — with a separate five-million-row benchmark at 112.7x. These figures concern data access and preparation, not model-training speed. The practical benefit is a more direct path from data already on the GPU into an external ML workflow, with less repeated movement.
Deployment planning and the limits of acceleration
Industrial workloads are not uniform. A recurring aggregation over a large, stable dataset has little in common with a small transactional lookup, or with an analytical query issued straight after a restart. PGEE GPU's cost-based planner is built to tell these cases apart: if the GPU path is unsuitable, or cannot be shown to yield the correct result, the query remains on the CPU. That behaviour is what allows GPU acceleration to sit alongside ordinary PostgreSQL workloads.
GPU memory is a second constraint. PGEE GPU keeps GPU-friendly representations of the columns that eligible queries need, so later queries can reuse them. Constructing that cached representation carries a cost, which makes the distinction between cold and warm execution relevant in production. Published performance timings reflect warm data; deployments must still plan for cache construction and restart behaviour.
An industrial evaluation should therefore cover representative data volumes, real query patterns, expected concurrency, replication behaviour and the operational requirements of each site. Benchmarks show what is achievable in principle; only a workload-specific assessment shows whether those gains translate into the intended outcome.
Combining the architecture with GPU execution
The industrial architecture and the PGEE GPU execution model cover complementary parts of the same problem. PostgreSQL gathers and processes data at distributed sites and consolidates selected information centrally. Inside PostgreSQL, PGEE GPU accelerates eligible analytical operations, with the planner deciding between CPU and GPU. The ML client then exposes GPU-resident data to external machine-learning workflows without the customary bulk export and import cycle.
Taken together, these capabilities give a PostgreSQL-centred foundation for industrial data collection, large-scale analytics and machine-learning data access.
The outcome still hinges on workload selection and careful architectural design. PGEE GPU does not speed up every query, and the database does not take over the applications that make operational decisions. Its scope is narrower: faster execution for suitable PostgreSQL analytical workloads, while preserving PostgreSQL's data model, SQL interface and correctness requirements.
Assessing a specific workload
Where large scans, aggregations or analytical joins account for a significant share of PostgreSQL execution time, CYBERTEC offers to evaluate the workload together with the customer. A representative query and its current CPU baseline are the starting point for determining where PGEE GPU can help.



