Processing-in-memory (PIM) aims to reduce the cost of moving data by performing selected operations within, or close to, memory. For industrial automation teams handling growing volumes of machine data, analytics, and computationally intensive workloads, this approach highlights an important design question: should every byte travel to the CPU before it can be processed?
PIM is one form of near-data processing (NDP), a broader architectural approach that places computation near the physical location of data. Rather than transferring raw datasets through the memory hierarchy to a host processor, a system can process some data locally and send back a smaller result. The approach can improve performance and resource efficiency when the transfer itself is a major constraint, but it also requires changes across hardware, software, and system design.
Why data movement has become a bottleneck
Traditional computer architectures follow a data-to-code model: data moves to the processing unit, where program instructions operate on it. This model is widely used and supports familiar software and system designs. Its limitation is that performance depends not only on how quickly a processor can calculate, but also on how quickly data can reach it.
Modern workloads can intensify this challenge. Large scans, analytics, machine learning, and hybrid transactional and analytical processing may work across substantial datasets, sometimes with irregular access patterns and limited reuse of data in CPU caches. When the data does not fit in main memory, it must also move through other levels of the storage hierarchy. These transfers consume bandwidth and can leave processing resources waiting.
Adding processor cores does not automatically solve the problem. Parallel execution can increase demand for data, while available bandwidth and the system’s ability to distribute work can limit the benefit. Improvements in memory capacity have also outpaced improvements in latency, contributing to the longstanding “memory wall.”
How processing-in-memory works
PIM places processing elements within a memory module or directly within a DRAM chip. Related NDP approaches can locate computation near other storage levels, including secondary storage. The central idea is to execute a suitable operation close to the data and transfer the result rather than the full input.
This can be useful when the output is much smaller than the original dataset, such as when a local operation filters or summarizes data. It may also make sense when performing the operation near storage is more efficient than moving the data to the host. The advantage depends on the workload and the balance between computation, data transfer, and result size; PIM is not automatically beneficial for every task.
Different implementations use different processing elements, from fixed-function logic to programmable or reconfigurable units. A PIM kernel—the portion of an application assigned to the near-memory processor—might perform part of a larger workload while the host CPU manages other tasks. Depending on the design, computation may be distributed across memory modules or integrated with other accelerators.
Potential relevance to industrial data workloads
Industrial systems generate machine and operational data that may be used in analytics or machine-learning workloads. The source describes these kinds of large data volumes and computationally intensive applications as part of the broader shift toward data-intensive computing. In that context, PIM is a potential way to address data-transfer costs when workloads involve substantial scans or have low data locality.
For example, a data-management operation that scans records and applies a filter could, in principle, run near the stored data. Only matching results would then need to travel back to the host. The same general reasoning applies to some aggregation or analytical operations. Whether this is practical depends on the available hardware, the operation’s implementation, and how much data the result contains.
These are architectural opportunities rather than assurances of a particular plant-level outcome. The whitepaper does not establish that PIM will improve every industrial workload. Engineers should first identify whether data movement is a significant constraint and whether the workload can be partitioned into operations that are suitable for local execution.
What engineers must account for
Moving computation toward data affects more than processor placement. PIM changes the relationship between host CPUs, memory, and software, raising integration questions that span the system:
- Programming and toolchains: Developers need ways to express which operations run near memory, compile them for different processing elements, and debug or profile execution.
- Memory addressing: The host and PIM units need a workable approach to virtual addresses, address translation, and shared data.
- Coherence and synchronization: If the CPU and near-memory processors access the same data, systems must manage consistent results and coordinate execution. Conventional cache-coherence approaches may not scale efficiently across many processing domains.
- Workload placement: Data and computation need to be distributed so that operations run close to the relevant data. Poor placement can undermine the benefit of local processing.
- Interfaces and operating-system support: Hardware, memory models, operating systems, and database or analytics software must work together rather than treating PIM as an isolated component.
Programming models such as OpenCL, OpenMP, OpenACC, and MapReduce have been considered as possible foundations, but PIM implementations may require extensions or specialized support. Preserving familiar development practices can make adoption easier, yet the hardware’s heterogeneous nature still calls for careful integration and optimization.
Conclusion: evaluate the bottleneck before the architecture
Processing-in-memory addresses a core limitation of conventional computing: moving data can cost time and resources, especially for large, bandwidth-intensive workloads with limited data reuse. By executing suitable operations close to storage, PIM can reduce unnecessary transfers and make better use of internal memory bandwidth.
For automation engineers and technical decision-makers, the practical first step is to examine workload behavior: where data resides, how often it moves, how much locality it offers, and whether results are substantially smaller than inputs. PIM is most relevant when those factors make data movement a material constraint. Its wider use will also depend on mature interfaces, programming tools, memory management, and coordination between host and near-data processors.