# PiDRAM: An FPGA-based Framework
for End-to-end Evaluation of Processing-in-DRAM Techniques

Ataberk Olgun§ Juan Gomez Luna§ Konstantinos Kanellopoulos§ Behzad Salami§
Hasan Hassan§ Oğuz Ergin$\dagger$ Onur Mutlu§

§ _ETH Zürich_ $\dagger$_TOBB University of Economics and Technology_

##  1 Background

DRAM-based main memory is used in nearly all computing systems as a major
component. Modern memory-intensive workloads have increasing memory bandwidth,
latency, and capacity requirements. However, DRAM vendors often prioritize
memory capacity scaling over latency and bandwidth [1, 2, 3, 4]. As a result,
main memory is an increasingly worsening bottleneck in computing systems [3,
5, 6, 7, 8, 9].

One way of overcoming the main memory bottleneck is to move computation near
memory, a paradigm known as _processing-in-memory_ (PiM) [10, 11, 12, 13, 14,
15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71,
72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107,
108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122,
123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 6, 136, 137,
138, 139, 7, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150]. PiM
reduces memory latency between the memory units and the compute units, enables
the compute units to exploit the large internal bandwidth within memory
devices, and reduces the overall power consumption of the system by
eliminating the need for transferring data over power-hungry off-chip
interfaces [3, 5, 9].

PiM techniques provide significant performance benefits and energy savings by
exploiting the high internal bit-level parallelism of DRAM for different
arithmetic [50, 71, 77, 74, 73, 52, 78, 76, 151, 75] and data movement
operations [51, 49, 68, 69]. Recent works [72, 76, 75, 151, 152] show that
some of these PiM techniques can already be supported in contemporary, off-
the-shelf DRAM chips with modifications only to the memory controller. Given
that DRAM is a dominant memory technology, such commodity DRAM based PiM
techniques provide a promising way to improve the performance and energy
efficiency of existing and future systems at _no additional DRAM hardware
cost_.

##  2 Motivation

Integration of PiM techniques in a real system imposes non-trivial challenges
that require further research to find appropriate solutions. For example, in-
DRAM copy and initialization techniques [51, 72] that copy data in bulk (e.g.,
one or multiple memory pages) require modifications related to memory
management that affect various different parts of the system. First, in-DRAM
copy and initialization techniques have specific memory allocation and
alignment requirements (e.g., page-granularity source and destination operands
should be allocated and aligned at row granularity within the same DRAM
subarray). These requirements are _not_ satisfied by existing system-level
memory allocation primitives (e.g., malloc [153], posix_memalign [154]).
Second, the source operands (usually one or more pages) of a copy operation
must be up to date in DRAM (i.e., it should not have dirty copies in CPU
caches). Existing cache coherence management operations (e.g., the x86 CLFLUSH
instruction [155]) cannot efficiently evict page-granularity source operands
from the caches [156, 85], as cache coherence management operations need to
query the coherence states of _all_ cache blocks of the source operands (i.e.,
even the coherence states of the cache blocks that are not present in CPU
caches are queried) [156].

###  2.1 Limitations of the State-of-the-Art

System integration challenges of PiM techniques can be efficiently studied in
existing general-purpose computing systems (e.g., personal computers, cloud
computers, embedded systems), special-purpose testing platforms (e.g., SoftMC
[157]), or system simulators (e.g., gem5 [158, 159], Ramulator [160, 161],
Ramulator-PIM [162], zsim [163]). First, many _commodity DRAM based PiM
techniques_ 111Commodity DRAM based PiM techniques are PiM techniques that can
already be supported in existing off-the-shelf DRAM chips with hardware
modifications _only_ to the memory controller. rely on non-standard DDRx
operation, where manufacturer-recommended timing parameters for DDRx commands
are violated [72, 75, 76, 151, 152] (or otherwise new DRAM commands are added,
which requires new chip designs and interfaces).222We are especially
interested in PiM techniques that do _not_ require any modification to the
DRAM chips or the DRAM interface. Existing general-purpose computing systems
do _not_ permit dynamically changing DDRx timing parameters [164, 165, 1, 76,
157], which is required to integrate these PiM techniques into real systems.
Second, prior works [75, 76, 72] show that the reliability of commodity DRAM
based PiM techniques is highly dependent on environmental conditions such as
temperature and voltage fluctuations. These effects are exacerbated by the
non-standard behavior of PiM techniques in real DRAM chips. Although special
purpose testing platforms (e.g., SoftMC [157]) can be used to conduct
reliability studies, these platforms do _not_ model an end-to-end computing
system, where system integration of PiM techniques can be studied. Third,
system simulators (e.g., gem5 [158, 159], Ramulator [160, 161], Ramulator-PIM
[162], zsim [163]) can model end-to-end computing systems. However, they (i)
do _not_ model DRAM operation beyond manufacturer-recommended timing
parameters, (ii) do _not_ have a way of interfacing with real DRAM chips that
embody undisclosed and unique characteristics that have implications on how
PiM techniques are integrated into real systems (e.g., proprietary and chip-
specific DRAM internal address mapping [166, 167]), and (iii) _cannot_ support
studies on the reliability of PiM techniques since system simulators do _not_
model environmental conditions.

Figure 1: PiDRAM overview. Modified hardware (in green) and software (in blue)
components. Unmodified components are in gray. A pimolib function executes
load and store instructions in the CPU to perform PiM operations (in red). We
use yellow to highlight the key hardware structures that are controlled by the
user to perform PiM operations.

##  3 PiDRAM Framework

Our goal is to design and implement a flexible framework that can be used to
solve system integration challenges and analyze trade-offs of end-to-end
implementations of commodity DRAM based PiM techniques. To this end, we
develop the PiDRAM (Processing-in-DRAM) framework, the first flexible, end-to-
end, and open source framework that enables system integration studies and
evaluation of real PiM techniques using real unmodified DRAM chips.

PiDRAM facilitates system integration studies of commodity DRAM based PiM
techniques by providing a set of four customizable hardware and software
components that can be used as a common basis to enable system support for
such techniques in real systems. Figure 1 presents an overview of PiDRAM’s
components.

###  3.1 Hardware Components

PiDRAM comprises two key hardware components. Both of these components are
designed with the goal to provide a flexible and easy to use framework for
evaluating PiM techniques.

❶ PiM Operations Controller (POC). POC decodes and executes PiDRAM
instructions (e.g., RowClone-Copy [51]) that are used by the programmer to
perform PiM operations. POC communicates with the rest of the system over two
well-defined interfaces. First, it communicates with the CPU over a memory-
mapped interface, where the CPU can send data to or receive data from POC
using memory store and load instructions. The CPU accesses the memory-mapped
registers (_instruction_ , _data_ , and _flag_ registers) in POC to execute
in-DRAM operations. This way, we improve the portability of the framework and
facilitate porting it to systems that employ different instruction set
architectures. Second, POC communicates with the memory controller to perform
PiM operations in the DRAM chip over a simple hardware interface. To do so,
POC (i) requests the memory controller to perform a PiM operation, (ii) waits
until the memory controller performs the operation, and (iii) receives the
result of the PiM operation from the memory controller. The CPU can read the
result of the operation by executing load instructions that target the _data_
register in POC.

❷ PiDRAM Memory Controller. PiDRAM’s memory controller provides an easy-to-
extend basis for commodity DRAM based PiM techniques that require issuing DRAM
commands with violated timing parameters [72, 76, 75, 151, 152]. The memory
controller is designed modularly and requires easy-to-make modifications to
its scheduler to implement new PiM techniques. For instance, our modular
design enables supporting RowClone [51] operations using only 60 additional
lines of Verilog code on top of the baseline custom memory controller’s
scheduler that implements conventional DRAM operations [167, 2, 168, 169, 170,
171, 172, 173, 174, 175, 176] (e.g., activate, precharge, read, write).

###  3.2 Software Components

PiDRAM comprises two key software components that complement and control
PiDRAM’s hardware components to provide a flexible and easy to use end-to-end
PiM framework.

❸ Extensible Software Library (pimolib). The extensible library (PiM
operations library) allows system designers to implement software support for
PiM techniques. Pimolib contains customizable functions that interface with
the POC to perform PiM operations in real unmodified DRAM chips. A typical
function in pimolib performs a PiM operation in four steps: It (i) writes a
PiDRAM instruction to the POC’s _instruction_ register, (ii) sets the _Start_
flag in the POC’s _flag_ register, (iii) waits for the POC to set the _Ack_
flag in the POC’s _flag_ register, and (iv) reads the result of the PiM
operation from the POC’s _data_ register (e.g., the true random number after
performing an in-DRAM true random number generation operation, Section 4.2).

❹ Custom Supervisor Software. The supervisor software contains the necessary
OS primitives (e.g., memory management, allocation, and alignment specialized
for RowClone [51]). This facilitates developing end-to-end integration of PiM
techniques in the system as these techniques require modifications across the
software stack. For example, integrating RowClone end-to-end in the full
system requires a new memory allocation mechanism (Section 4.2) that can
satisfy the memory allocation constraints of RowClone [51, 177].

Figure 2: Workflow for a PiDRAM RowClone-Copy operation.

###  3.3 General PiDRAM Execution Workflow

We describe the general workflow for a PiDRAM operation (e.g., RowClone-Copy
[51], random number generation using D-RaNGe [76]) in Figure 2 over an example
copy() function that is called by the user to perform a RowClone-Copy
operation in DRAM.

The user makes a system call to the custom supervisor software ① that in turn
calls the copy(source, destination) function in the pimolib ②. The function
executes two store instructions in the RISC-V core ③. The first store
instruction updates the _instruction_ register with the copy instruction
(i.e., the instruction that performs a RowClone-Copy operation in DRAM) ④ and
the second store instruction sets the Start flag in the flag register to
logic-1 ⑤ in the POC. When the Start flag is set, the POC instructs the PiDRAM
memory controller to perform a RowClone-Copy operation using violated timing
parameters ⑥. The POC waits until the memory controller starts executing the
operation, after which it sets the Start flag to logic-0 and the Ack flag to
logic-1 ⑦, indicating that it started the execution of the PiM operation. The
PiDRAM memory controller performs the RowClone-Copy operation by issuing a set
of DRAM commands with violated timing parameters ⑧. When the last DRAM command
is issued, the memory controller sets the Finish flag (denoted as Fin. in
Figure 2) in the flag register to logic-1 ⑨, indicating the end of execution
for the last PiM operation that the memory controller acknowledged. The copy
function periodically checks either the Ack or the Finish flag in the flag
register (depending on a user-supplied argument) by executing load
instructions that target the flag register ⑩. When the periodically checked
flag is set, the copy function returns. This way, the copy function optionally
blocks until the start (i.e., the Ack flag is set) or the end (i.e., the
Finish flag is set) of the execution of the PiM operation (in this example,
RowClone-Copy).333The data register is not used in RowClone-Copy [51]
operations because the result of the RowClone-Copy operation is stored _in
memory_ (i.e., the source memory row is copied to the destination memory row).
The data register is used in D-RaNGe [76] operations, as described in [177].
When used, the command scheduler stores the random numbers generated by the
D-RaNGe operation in the data register. To read the generated random numbers,
we implement a pimolib function called rand_dram() that executes load
instructions in the RISC-V core to retrieve the random numbers from the data
register in the POC.

##  4 FPGA Prototype & Case Studies

PiDRAM allows (i) interfacing with and performing in-DRAM operations on real
unmodified DRAM chips, (ii) observing the effects of environmental conditions
on PiM techniques, and (iii) conducting end-to-end system-level studies on PiM
techniques using real DRAM chips. We demonstrate the versatility and ease-of-
use of PiDRAM by prototyping it on an FPGA board and conducting two case
studies of PIM computation.

###  4.1 FPGA Prototype

We demonstrate a prototype of PiDRAM on an FPGA-based platform (Xilinx ZC706
[178]) that implements an open-source RISC-V system (Rocket Chip [179]). Our
custom supervisor software extends the RISC-V PK [180] to support the
necessary OS primitives on PiDRAM’s prototype. We perform in-DRAM operations
in real unmodified DDR3 DRAM chips that are connected to the FPGA-based
platform. Figure 3 shows our FPGA prototype.

Figure 3: PiDRAM’s FPGA prototype.

###  4.2 Case Studies

To demonstrate the flexibility and ease of use of PiDRAM, we implement two PiM
techniques on unmodified DRAM chips by violating timing parameters: (1)
_RowClone_ [51], an in-DRAM copy and initialization mechanism (using command
sequences proposed by ComputeDRAM [72]), and (2) _D-RaNGe_ [76], an in-DRAM
true random number generator based on DRAM activation-latency failures induced
by violation of manufacturer-recommended DRAM timing parameters.

To support RowClone, we (i) customize PiDRAM’s memory controller to issue
carefully-engineered sequences of DRAM commands that perform copy operations
in DRAM, and (ii) extend the custom supervisor software to implement a new
memory management mechanism that satisfies the memory allocation and alignment
requirements of RowClone [177, 51]. The key idea of the memory management
mechanism is to allocate physical addresses in the same DRAM subarray [167,
51, 50, 49] for the source and destination operands (i.e., rows) of the copy
operation. We develop a new methodology that checks if RowClone operations on
randomly-generated physical addresses succeed or fail, to find physical row
addresses that are in the same DRAM subarray. We explain this methodology and
our techniques in more detail in our arXiv paper [177].

To support D-RaNGe, we (i) make simple modifications to the PiDRAM memory
controller to implement a new storage structure that buffers random numbers
(i.e., a random number buffer) and (ii) extend the software library with
functions that retrieve data from the random number buffer and supply it to
the user program.

##  5 Key Results & Contributions

Our evaluation of RowClone shows that an end-to-end implementation of RowClone
achieves (i) 118.5$\times{}$ speedup for copy and 88.7$\times{}$ speedup for
initialization operations, assuming data in DRAM is up to date and the source
operand is not cached in CPU caches (i.e., no cache coherence management
operations are required) and (ii) 14.6$\times{}$ speedup for copy and
12.6$\times{}$ initialization operations assuming data in DRAM is up to date
but the source operand has cached copies in CPU caches (i.e., a cache
coherence management operation must be performed for every cache block of the
source operand) over CPU-based copy (i.e., conventional memcpy [181]) and
initialization (i.e., conventional calloc [182]) operations.

We make two observations from our evaluation of D-RaNGe. First, end-to-end
integration of D-RaNGe into a real system provides true random numbers at low
latency. Our implementation can generate a 4-bit random number in
$220\text{\,}\mathrm{ns}$. Second, an end-to-end integration of D-RaNGe into a
real system generates true random numbers at high throughput. Our
implementation achieves 8.30 Mb/s sustained throughput. PiDRAM’s D-RaNGe
implementation can be optimized to generate random numbers more frequently
(i.e., at higher throughput). We leave such optimizations to PiDRAM’s D-RaNGe
implementation for future work.

Over the Verilog and C++ codebase provided by PiDRAM, integrating RowClone
end-to-end in the full system takes 198 lines of Verilog and 565 lines of C++
code and integrating D-RaNGe end-to-end in the full system takes 190 lines of
Verilog and 78 lines of C++ code.

Our contributions are as follows:

  * •

We develop PiDRAM, the first flexible framework that enables end-to-end
integration and evaluation of PiM techniques using real unmodified DRAM chips.

  * •

We develop a prototype of PiDRAM on an FPGA-based platform. To demonstrate the
ease-of-use and evaluation benefits of PiDRAM, we implement two state-of-the-
art DRAM-based PiM techniques, RowClone and D-RaNGe, and evaluate them on
PiDRAM’s prototype using unmodified DDR3 DRAM chips.

  * •

We devise a new memory management mechanism that satisfies the memory
allocation and alignment requirements of RowClone [51]. We demonstrate that
our mechanism enables RowClone end-to-end in the full system, and provides
significant performance improvements over traditional CPU-based copy and
initialization operations (memcpy [181] and calloc [182]) as demonstrated on
our PiDRAM prototype.

  * •

We implement and evaluate a state-of-the-art DRAM true random number
generation technique (D-RaNGe [76]). Our implementation provides a solid
foundation for future work on system integration of DRAM-based PiM security
primitives (e.g., PUFs [152, 75], TRNGs[76, 151, 152]), implemented using real
unmodified DRAM chips.

  * •

PiDRAM is open sourced and freely available on Github: https://github.com/CMU-
SAFARI/PiDRAM.

##  6 Summary

We introduce the first flexible, end-to-end, and open source in-DRAM
computation framework, called PiDRAM. Unlike existing evaluation frameworks
and prior work, PiDRAM allows us to conduct end-to-end full system studies of
commodity DRAM based PiM techniques that use real unmodified DRAM chips. We
demonstrate PiDRAM’s versatility and ease of use by prototyping it on an FPGA
board and conducting case studies of two state-of-the-art PiM techniques for
in-DRAM data copy & initialization (RowClone [51]) and in-DRAM true random
number generation (D-RaNGe [76]). We show that an end-to-end implementation of
(i) RowClone greatly improves data copy and initialization performance at the
full system level, and (ii) D-RaNGe provides true random numbers to
applications at high throughput. We hope and believe that researchers and
industry will benefit from and build on PiDRAM to better evaluate PiM
techniques and their benefits in real systems.

## Acknowledgements

We thank the SAFARI Research Group members for valuable feedback and the
stimulating intellectual environment they provide. We acknowledge the generous
gifts provided by our industrial partners, including Google, Huawei, Intel,
Microsoft, and VMware. We acknowledge support from the Semiconductor Research
Corporation and the ETH Future Computing Laboratory.

This invited extended abstract is a summary version of our prior work [177]. A
presentation that describes this work can be found at [183].

## References

  * [1] K. K. Chang _et al._ , “Understanding Latency Variation in Modern DRAM Chips: Experimental Characterization, Analysis, and Optimization,” in _SIGMETRICS_ , 2016.
  * [2] D. Lee _et al._ , “Tiered-Latency DRAM: A Low Latency and Low Cost DRAM Architecture,” in _HPCA_ , 2013.
  * [3] O. Mutlu _et al._ , “A Modern Primer on Processing in Memory,” _Emerging Computing: From Devices to Systems - Looking Beyond Moore and Von Neumann_ , 2021.
  * [4] M. Patel _et al._ , “A Case for Transparent Reliability in DRAM Systems,” arXiv:2204.10378, 2022.
  * [5] S. Ghose _et al._ , “Processing-in-Memory: A Workload-driven Perspective,” _IBM JRD_ , 2019.
  * [6] O. Mutlu, “Memory Scaling: A Systems Architecture Perspective,” _IMW_ , 2013\.
  * [7] O. Mutlu _et al._ , “Research Problems and Opportunities in Memory Systems,” _SUPERFRI_ , 2014.
  * [8] O. Mutlu, “Main Memory Scaling: Challenges and Solution Directions,” 2015, Invited Book Chapter in More than Moore Technologies for Next Generation Computer Design, pp. 127-153, Springer.
  * [9] O. Mutlu _et al._ , “Processing Data Where It Makes Sense: Enabling In-Memory Computation,” _MicPro_ , 2019.
  * [10] I. Fernandez _et al._ , “NATSA: A Near-Data Processing Accelerator for Time Series Analysis,” in _ICCD_ , 2020.
  * [11] D. S. Cali _et al._ , “GenASM: A High-Performance, Low-Power Approximate String Matching Acceleration Framework for Genome Sequence Analysis,” in _MICRO_ , 2020.
  * [12] J. S. Kim _et al._ , “GRIM-Filter: Fast Seed Location Filtering in DNA Read Mapping Using Processing-in-Memory Technologies,” _BMC Genomics_ , 2018\.
  * [13] J. Ahn _et al._ , “PIM-Enabled Instructions: A Low-Overhead, Locality-Aware Processing-in-Memory Architecture,” in _ISCA_ , 2015.
  * [14] J. Ahn _et al._ , “A Scalable Processing-in-Memory Accelerator for Parallel Graph Processing,” in _ISCA_ , 2015.
  * [15] A. Boroumand _et al._ , “Google Workloads for Consumer Devices: Mitigating Data Movement Bottlenecks,” in _ASPLOS_ , 2018.
  * [16] A. Boroumand _et al._ , “CoNDA: Efficient Cache Coherence Support for near-Data Accelerators,” in _ISCA_ , 2019.
  * [17] A. Boroumand _et al._ , “LazyPIM: An Efficient Cache Coherence Mechanism for Processing-in-Memory,” _CAL_ , 2016.
  * [18] G. Singh _et al._ , “NAPEL: Near-memory Computing Application Performance Prediction via Ensemble Learning,” in _DAC_ , 2019.
  * [19] H. Asghari-Moghaddam _et al._ , “Chameleon: Versatile and Practical Near-DRAM Acceleration Architecture for Large Memory Systems,” in _MICRO_ , 2016.
  * [20] S. L. Xi _et al._ , “Beyond the Wall: Near-Data Processing for Databases,” in _DaMoN_ , 2015.
  * [21] A. Farmahini-Farahani _et al._ , “NDA: Near-DRAM acceleration architecture leveraging commodity DRAM devices and standard memory modules,” in _HPCA_ , 2015.
  * [22] M. Gao _et al._ , “Practical Near-Data Processing for In-Memory Analytics Frameworks,” in _PACT_ , 2015.
  * [23] M. Gao _et al._ , “HRL: Efficient and Flexible Reconfigurable Logic for Near-Data Processing,” in _HPCA_ , 2016.
  * [24] B. Gu _et al._ , “Biscuit: A Framework for Near-Data Processing of Big Data Workloads,” in _ISCA_ , 2016.
  * [25] M. Hashemi _et al._ , “Accelerating Dependent Cache Misses with an Enhanced Memory Controller,” in _ISCA_ , 2016.
  * [26] M. Hashemi _et al._ , “Continuous Runahead: Transparent Hardware Acceleration for Memory Intensive Workloads,” in _MICRO_ , 2016.
  * [27] K. Hsieh _et al._ , “Transparent Offloading and Mapping (TOM): Enabling Programmer-Transparent Near-Data Processing in GPU Systems,” in _ISCA_ , 2016.
  * [28] D. Kim _et al._ , “Neurocube: A Programmable Digital Neuromorphic Architecture with High-Density 3D Memory,” in _ISCA_ , 2016.
  * [29] G. Kim _et al._ , “Toward Standardized Near-Data Processing with Unrestricted Data Placement for GPUs,” in _SC_ , 2017.
  * [30] Z. Liu _et al._ , “Concurrent Data Structures for Near-Memory Computing,” in _SPAA_ , 2017.
  * [31] A. Morad _et al._ , “GP-SIMD Processing-in-Memory,” _ACM TACO_ , 2015\.
  * [32] L. Nai _et al._ , “GraphPIM: Enabling Instruction-Level PIM Offloading in Graph Computing Frameworks,” in _HPCA_ , 2017.
  * [33] A. Pattnaik _et al._ , “Scheduling Techniques for GPU Architectures with Processing-in-Memory Capabilities,” in _PACT_ , 2016.
  * [34] S. H. Pugsley _et al._ , “NDC: Analyzing the Impact of 3D-Stacked Memory+Logic Devices on MapReduce Workloads,” in _ISPASS_ , 2014.
  * [35] D. P. Zhang _et al._ , “TOP-PIM: Throughput-Oriented Programmable Processing in Memory,” in _HPDC_ , 2014.
  * [36] Q. Zhu _et al._ , “Accelerating Sparse Matrix-Matrix Multiplication with 3D-Stacked Logic-in-Memory Hardware,” in _HPEC_ , 2013.
  * [37] B. Akin _et al._ , “Data Reorganization in Memory Using 3D-Stacked DRAM,” in _ISCA_ , 2015.
  * [38] M. Gao _et al._ , “Tetris: Scalable and Efficient Neural Network Acceleration with 3D Memory,” in _ASPLOS_ , 2017.
  * [39] M. P. Drumond Lages de Oliveira _et al._ , “The Mondrian Data Engine,” in _ISCA_ , 2017.
  * [40] G. Dai _et al._ , “GraphH: A Processing-in-Memory Architecture for Large-scale Graph Processing,” _IEEE TCAD_ , 2018.
  * [41] M. Zhang _et al._ , “GraphP: Reducing Communication for PIM-based Graph Processing with Efficient Data Partition,” in _HPCA_ , 2018.
  * [42] Y. Huang _et al._ , “A Heterogeneous PIM Hardware-Software Co-Design for Energy-Efficient Graph Processing,” in _IPDPS_ , 2020.
  * [43] Y. Zhuo _et al._ , “GraphQ: Scalable PIM-based Graph Processing,” in _MICRO_ , 2019.
  * [44] C. Giannoula _et al._ , “SynCron: Efficient Synchronization Support for Near-Data-Processing Architectures,” in _HPCA_ , 2021.
  * [45] S. Aga _et al._ , “Compute Caches,” in _HPCA_ , 2017.
  * [46] C. Eckert _et al._ , “Neural Cache: Bit-serial In-cache Acceleration of Deep Neural Networks,” in _ISCA_ , 2018.
  * [47] D. Fujiki _et al._ , “Duality Cache for Data Parallel Acceleration,” in _ISCA_ , 2019.
  * [48] M. Kang _et al._ , “An Energy-Efficient VLSI Architecture for Pattern Recognition via Deep Embedding of Computation in SRAM,” in _ICASSP_ , 2014\.
  * [49] K. K. Chang _et al._ , “Low-Cost Inter-Linked Subarrays (LISA): Enabling Fast Inter-Subarray Data Movement in DRAM,” in _HPCA_ , 2016.
  * [50] V. Seshadri _et al._ , “Ambit: In-Memory Accelerator for Bulk Bitwise Operations Using Commodity DRAM Technology,” in _MICRO_ , 2017.
  * [51] V. Seshadri _et al._ , “RowClone: Fast and Energy-Efficient In-DRAM Bulk Data Copy and Initialization,” in _MICRO_ , 2013.
  * [52] S. Angizi _et al._ , “Graphide: A Graph Processing Accelerator Leveraging In-dram-computing,” in _GLSVLSI_ , 2019.
  * [53] S. Li _et al._ , “Pinatubo: A Processing-in-Memory Architecture for Bulk Bitwise Operations in Emerging Non-Volatile Memories,” in _DAC_ , 2016.
  * [54] S. Angizi _et al._ , “PIMA-Logic: A Novel Processing-in-Memory Architecture for Highly Flexible and Energy-efficient Logic Computation,” in _DAC_ , 2018.
  * [55] S. Angizi _et al._ , “CMP-PIM: An Energy-Efficient Comparator-Based Processing-in-Memory Neural Network Accelerator,” in _DAC_ , 2018.
  * [56] S. Angizi _et al._ , “AlignS: A Processing-in-Memory Accelerator for DNA Short Read Alignment Leveraging SOT-MRAM,” in _DAC_ , 2019.
  * [57] Y. Levy _et al._ , “Logic Operations in Memory Using a Memristive Akers Array,” _Microelectronics Journal_ , 2014.
  * [58] S. Kvatinsky _et al._ , “MAGIC—Memristor-Aided Logic,” _IEEE TCAS II: Express Briefs_ , 2014.
  * [59] A. Shafiee _et al._ , “ISAAC: A Convolutional Neural Network Accelerator with In-Situ Analog Arithmetic in Crossbars,” in _ISCA_ , 2016.
  * [60] S. Kvatinsky _et al._ , “Memristor-Based IMPLY Logic Design Procedure,” in _ICCD_ , 2011.
  * [61] S. Kvatinsky _et al._ , “Memristor-Based Material Implication (IMPLY) Logic: Design Principles and Methodologies,” _TVLSI_ , 2014.
  * [62] P.-E. Gaillardon _et al._ , “The Programmable Logic-in-Memory (PLiM) Computer,” in _DATE_ , 2016.
  * [63] D. Bhattacharjee _et al._ , “ReVAMP: ReRAM based VLIW Architecture for In-Memory Computing,” in _DATE_ , 2017.
  * [64] S. Hamdioui _et al._ , “Memristor Based Computation-in-Memory Architecture for Data-intensive Applications,” in _DATE_ , 2015.
  * [65] L. Xie _et al._ , “Fast Boolean Logic Mapped on Memristor Crossbar,” in _ICCD_ , 2015.
  * [66] S. Hamdioui _et al._ , “Memristor for Computing: Myth or Reality?” in _DATE_ , 2017.
  * [67] J. Yu _et al._ , “Memristive Devices for Computation-in-Memory,” in _DATE_ , 2018.
  * [68] S. H. S. Rezaei _et al._ , “NoM: Network-on-Memory for Inter-Bank Data Transfer in Highly-Banked Memories,” _CAL_ , 2020.
  * [69] Y. Wang _et al._ , “FIGARO: Improving System Performance via Fine-Grained In-DRAM Data Relocation and Caching,” in _MICRO_ , 2020.
  * [70] J. A. Mandelman _et al._ , “Challenges and Future Directions for the Scaling of Dynamic Random-Access Memory (DRAM),” _IBM JRD_ , 2002.
  * [71] X. Xin _et al._ , “ELP2IM: Efficient and Low Power Bitwise Operation Processing in DRAM,” in _HPCA_ , 2020.
  * [72] F. Gao _et al._ , “ComputeDRAM: In-Memory Compute Using Off-the-Shelf DRAMs,” in _MICRO_ , 2019.
  * [73] S. Li _et al._ , “DRISA: A DRAM-Based Reconfigurable In-Situ Accelerator,” in _MICRO_ , 2017.
  * [74] Q. Deng _et al._ , “DrAcc: a DRAM Based Accelerator for Accurate CNN Inference,” in _DAC_ , 2018.
  * [75] J. Kim _et al._ , “The DRAM Latency PUF: Quickly Evaluating Physical Unclonable Functions by Exploiting the Latency–Reliability Tradeoff in Modern DRAM Devices,” in _HPCA_ , 2018.
  * [76] J. Kim _et al._ , “D-RaNGe: Using Commodity DRAM Devices to Generate True Random Numbers with Low Latency and High Throughput,” in _HPCA_ , 2019\.
  * [77] N. Hajinazar _et al._ , “SIMDRAM: A Framework for Bit-Serial SIMD Processing Using DRAM,” in _ASPLOS_ , 2021.
  * [78] M. F. Ali _et al._ , “In-Memory Low-Cost Bit-Serial Addition Using Commodity DRAM Technology,” in _TCAS-I_ , 2019.
  * [79] R. Ronen _et al._ , “The Bitlet Model: A Parameterized Analytical Model to Compare PIM and CPU Systems,” _J. Emerg. Technol. Comput. Syst._ , 2022\.
  * [80] Y. Zha _et al._ , “Liquid Silicon: A Nonvolatile Fully Programmable Processing-In-Memory Processor with Monolithically Integrated ReRAM for Big Data/Machine Learning Applications,” in _Symposium on VLSI Circuits_ , 2019\.
  * [81] E. Testa _et al._ , “Inversion Optimization in Majority-Inverter Graphs,” in _NANOARCH_ , 2016.
  * [82] J. Borghetti _et al._ , “Memristive Switches Enable Stateful Logic Operations via Material Implication,” _Nature_ , 2010.
  * [83] Intel, “Taking Neuromorphic Computing to the Next Level with Loihi 2,” Technology Brief, 2022.
  * [84] G. W. Burr _et al._ , “Neuromorphic Computing Using Non-volatile Memory,” _Advances in Physics: X_ , 2017.
  * [85] V. Seshadri, “Simple DRAM and Virtual Memory Abstractions to Enable Highly Efficient Memory Systems,” Ph.D. dissertation, Carnegie Mellon University, 2016\.
  * [86] V. Seshadri _et al._ , “Fast Bulk Bitwise AND and OR in DRAM,” _CAL_ , 2015.
  * [87] V. Seshadri _et al._ , “Buddy-RAM: Improving the Performance and Efficiency of Bulk Bitwise Operations Using DRAM,” arXiv:1611.09988, 2016.
  * [88] V. Seshadri _et al._ , “Simple Operations in Memory to Reduce Data Movement,” in _Advances in Computers, Volume 106_ , 2017.
  * [89] V. Seshadri _et al._ , “The Processing Using Memory Paradigm: In-DRAM Bulk Copy, Initialization, Bitwise AND and OR,” arXiv:1610.09603, 2016.
  * [90] Q. Guo _et al._ , “3D-Stacked Memory-Side Acceleration: Accelerator and System Design,” in _WoNDP_ , 2014.
  * [91] S. Cho _et al._ , “McDRAM v2: In-Dynamic Random Access Memory Systolic Array Accelerator to Address the Large Model Problem in Deep Neural Networks on the Edge,” _IEEE Access_ , 2020.
  * [92] J. D. Ferreira _et al._ , “pLUTo: In-DRAM Lookup Tables to Enable Massively Parallel General-Purpose Computation,” arXiv:2104.07699, 2021.
  * [93] Y. Kang _et al._ , “FlexRAM: Toward an Advanced Intelligent Memory System,” in _ICCD_ , 1999.
  * [94] C. Giannoula _et al._ , “Towards Efficient Sparse Matrix Vector Multiplication on Real Processing-in-Memory Architectures,” in _SIGMETRICS_ , 2022.
  * [95] R. C. Murphy _et al._ , “The Characterization of Data Intensive Memory Workloads on Distributed PIM Systems,” in _Intelligent Memory Systems_. Springer, 2001.
  * [96] J. Landgraf _et al._ , “Combining Emulation and Simulation to Evaluate a Near Memory Key/Value Lookup Accelerator,” arXiv:2015.06594, 2021.
  * [97] H. Ahmed _et al._ , “A Compiler for Automatic Selection of Suitable Processing-in-Memory Instructions,” in _DATE_ , 2019.
  * [98] G. Singh _et al._ , “FPGA-based Near-Memory Acceleration of Modern Data-Intensive Applications,” _IEEE Micro_ , 2021.
  * [99] A. Rodrigues _et al._ , “Towards a Scatter-Gather Architecture: Hardware and Software Issues,” in _MEMSYS_ , 2019.
  * [100] N. M. Ghiasi _et al._ , “GenStore: A High-Performance and Energy-Efficient In-Storage Computing System for Genome Sequence Analysis,” in _ASPLOS_ , 2022.
  * [101] G. F. Oliveira _et al._ , “DAMOV: A New Methodology and Benchmark Suite for Evaluating Data Movement Bottlenecks,” _IEEE Access_ , 2021.
  * [102] S. Jain _et al._ , “Computing-in-Memory with Spintronics,” in _DATE_ , 2018.
  * [103] A. Boroumand _et al._ , “Google Neural Network Models for Edge Devices: Analyzing and Mitigating Machine Learning Inference Bottlenecks,” arXiv:2109.14320, 2021.
  * [104] V. Zois _et al._ , “Massively Parallel Skyline Computation for Processing-in-Memory Architectures,” in _PACT_ , 2018.
  * [105] A. Boroumand _et al._ , “Google Neural Network Models for Edge Devices: Analyzing and Mitigating Machine Learning Inference Bottlenecks,” in _PACT_ , 2021.
  * [106] W. H. Kautz, “Cellular Logic-in-Memory Arrays,” _IEEE TC_ , 1969.
  * [107] R. Nair, “Evolution of Memory Architecture,” _Proceedings of the IEEE_ , 2015.
  * [108] S. Lloyd _et al._ , “Near Memory Key/Value Lookup Acceleration,” in _MEMSYS_ , 2017.
  * [109] P. C. Santos _et al._ , “Operand Size Reconfiguration for Big Data Processing in Memory,” in _DATE_ , 2017.
  * [110] Y. Zha _et al._ , “Hyper-AP: Enhancing Associative Processing Through A Full-Stack Optimization,” in _ISCA_ , 2020.
  * [111] P. Gu _et al._ , “iPIM: Programmable In-Memory Image Processing Accelerator using Near-Bank Architecture,” in _ISCA_ , 2020.
  * [112] B. Asgari _et al._ , “FAFNIR: Accelerating Sparse Gathering by Using Efficient Near-Memory Intelligent Reduction,” in _HPCA_ , 2021.
  * [113] C. Giannoula _et al._ , “SparseP: Towards Efficient Sparse Matrix Vector Multiplication on Real Processing-In-Memory Systems,” arXiv:2201.05072, 2022\.
  * [114] A. Boroumand _et al._ , “Polynesia: Enabling Effective Hybrid Transactional Analytical Databases with Specialized Hardware Software Co-Design,” in _ICDE_ , 2022.
  * [115] Y. Xi _et al._ , “In-Memory Learning With Analog Resistive Switching Memory: A Review and Perspective,” _Proceedings of the IEEE_ , 2020.
  * [116] R. Balasubramonian _et al._ , “Near-Data Processing: Insights from a MICRO-46 Workshop,” _IEEE Micro_ , 2014.
  * [117] J. M. Herruzo _et al._ , “Enabling Fast and Energy-Efficient FM-Index Exact Matching Using Processing-Near-Memory,” _The Journal of Supercomputing_ , 2021.
  * [118] A. C. Jacob _et al._ , “Compiling for the Active Memory Cube,” Tech. rep. RC25644 (WAT1612-008). IBM Research Division, Tech. Rep., 2016.
  * [119] D. Fujiki _et al._ , “In-Memory Data Parallel Processor,” in _ASPLOS_ , 2018.
  * [120] M. Gokhale _et al._ , “Processing in Memory: The Terasys Massively Parallel PIM Array,” _IEEE Computer_ , 1995.
  * [121] D. G. Elliott _et al._ , “Computational RAM: Implementing Processors in Memory,” _IEEE Design & Test of Computers_, 1999.
  * [122] R. Nair _et al._ , “Active Memory Cube: A Processing-in-Memory Architecture for Exascale Systems,” _IBM JRD_ , 2015.
  * [123] S. Lloyd _et al._ , “Design Space Exploration of Near Memory Accelerators,” in _MEMSYS_ , 2018.
  * [124] G. Singh _et al._ , “NERO: A Near High-Bandwidth Memory Stencil Accelerator for Weather Prediction Modeling,” in _FPL_ , 2020.
  * [125] D. Lavenier _et al._ , “Variant Calling Parallelization on Processor-in-Memory Architecture,” in _BIBM_ , 2020.
  * [126] P. M. Kogge, “EXECUBE - A New Architecture for Scaleable MPPs,” in _ICPP_ , 1994.
  * [127] D. E. Shaw _et al._ , “The NON-VON Database Machine: A Brief Overview,” _IEEE Database Eng. Bull._ , 1981.
  * [128] K. Mai _et al._ , “Smart Memories: A Modular Reconfigurable Architecture,” in _ISCA_ , 2000.
  * [129] M. Besta _et al._ , “SISA: Set-Centric Instruction Set Architecture for Graph Mining on Processing-in-Memory Systems,” in _MICRO_ , 2021.
  * [130] D. Patterson _et al._ , “A Case for Intelligent RAM,” _IEEE Micro_ , 1997.
  * [131] L. Yavits _et al._ , “GIRAF: General Purpose In-Storage Resistive Associative Framework,” _IEEE TPDS_ , 2021.
  * [132] A. Boroumand _et al._ , “Polynesia: Enabling Effective Hybrid Transactional/Analytical Databases with Specialized Hardware/Software Co-Design,” arXiv:2103.00798, 2021.
  * [133] K. Hsieh _et al._ , “Accelerating Pointer Chasing in 3D-Stacked Memory: Challenges, Mechanisms, Evaluation,” in _ICCD_ , 2016.
  * [134] H. S. Stone, “A Logic-in-Memory Computer,” _IEEE TC_ , 1970.
  * [135] A. Denzler _et al._ , “Casper: Accelerating stencil computation using near-cache processing,” arXiv:2112.14216, 2021.
  * [136] S. Lloyd _et al._ , “In-memory Data Rearrangement for Irregular, Data-intensive Computing,” _Computer_ , 2015.
  * [137] Z. Sura _et al._ , “Data Access Optimization in a Processing-in-Memory System,” in _CF_ , 2015.
  * [138] W.-M. Hwu _et al._ , “Rebooting the Data Access Hierarchy of Computing Systems,” in _ICRC_ , 2017.
  * [139] P. Chi _et al._ , “PRIME: A Novel Processing-In-Memory Architecture for Neural Network Computation In ReRAM-Based Main Memory,” in _ISCA_ , 2016\.
  * [140] G. F. Oliveira _et al._ , “DAMOV: A New Methodology and Benchmark Suite for Evaluating Data Movement Bottlenecks,” arXiv:2105.03725, 2021.
  * [141] S. Diab _et al._ , “High-throughput Pairwise Alignment with the Wavefront Algorithm using Processing-in-Memory,” in _HICOMB_ , 2022.
  * [142] J. Draper _et al._ , “The Architecture of the DIVA Processing-in-Memory Chip,” in _SC_ , 2002.
  * [143] G. Singh _et al._ , “Accelerating Weather Prediction using Near-Memory Reconfigurable Fabric,” _ACM TRETS_ , 2021.
  * [144] H. Shin _et al._ , “McDRAM: Low latency and energy-efficient matrix computations in DRAM,” _IEEE TCADICS_ , 2018.
  * [145] M. Gokhale _et al._ , “Near Memory Data Structure Rearrangement,” in _MEMSYS_ , 2015.
  * [146] M. Oskin _et al._ , “Active Pages: A Computation Model for Intelligent Memory,” in _ISCA_ , 1998.
  * [147] L. Zheng _et al._ , “RRAM-based TCAMs for pattern search,” in _ISCAS_ , 2016.
  * [148] A. Boroumand, “Practical Mechanisms for Reducing Processor-Memory Data Movement in Modern Workloads,” Ph.D. dissertation, Carnegie Mellon University, 2020.
  * [149] O. O. Babarinsa _et al._ , “JAFAR: Near-Data Processing for Databases,” in _SIGMOD_ , 2015.
  * [150] S. Diab _et al._ , “High-throughput Pairwise Alignment with the Wavefront Algorithm using Processing-in-Memory,” arXiv:2204.02085, 2022.
  * [151] A. Olgun _et al._ , “QUAC-TRNG: High-Throughput True Random Number Generation Using Quadruple Row Activation in Commodity DRAM Chips,” in _ISCA_ , 2021.
  * [152] B. M. S. Bahar Talukder _et al._ , “Exploiting DRAM Latency Variations for Generating True Random Numbers,” in _ICCE_ , 2019.
  * [153] Linux man-pages Project, “malloc(3) — Linux manual page,” https://man7.org/linux/man-pages/man3/malloc.3.html, 2022.
  * [154] Linux man-pages Project, “posix_memalign(3) — Linux manual page,” https://man7.org/linux/man-pages/man3/posix_memalign.3.html, 2022.
  * [155] Intel, “Intel 64 and IA-32 Architectures Software Developer Manuals,” 2011. [Online]. Available: http://www.intel.com/content/www/us/en/processors/architectures-software-developer-manuals.html
  * [156] V. Seshadri _et al._ , “The Dirty-Block Index,” in _ISCA_ , 2014.
  * [157] H. Hassan _et al._ , “SoftMC: A Flexible and Practical Open-Source Infrastructure for Enabling Experimental DRAM Studies,” in _HPCA_ , 2017\.
  * [158] J. Power _et al._ , “gem5-gpu: A Heterogeneous CPU-GPU Simulator,” _CAL_ , Jan 2015.
  * [159] N. Binkert _et al._ , “The gem5 Simulator,” _CAN_ , 2011.
  * [160] SAFARI Research Group, “Ramulator: A DRAM Simulator – GitHub Repository,” https://github.com/CMU-SAFARI/ramulator/, 2015.
  * [161] Y. Kim _et al._ , “Ramulator: A Fast and Extensible DRAM Simulator,” _CAL_ , 2015.
  * [162] S. R. Group, “Ramulator-PIM: A Processing-in-Memory Simulation Framework – GitHub Repository,” https://github.com/CMU-SAFARI/ramulator-pim, 2021\.
  * [163] D. Sanchez _et al._ , “ZSim: Fast and Accurate Microarchitectural Simulation of Thousand-Core Systems,” in _ISCA_ , 2013.
  * [164] D. Lee _et al._ , “Adaptive-Latency DRAM: Optimizing DRAM Timing for the Common-Case,” in _HPCA_ , 2015.
  * [165] J. Kim _et al._ , “Solar-DRAM: Reducing DRAM Access Latency by Exploiting the Variation in Local Bitlines,” in _ICCD_ , 2018.
  * [166] L. Cojocar _et al._ , “Are We Susceptible to Rowhammer? An End-to-End Methodology for Cloud Providers,” in _S &P_, 2020.
  * [167] Y. Kim _et al._ , “A Case for Exploiting Subarray-Level Parallelism (SALP) in DRAM,” in _ISCA_ , 2012.
  * [168] D. Lee _et al._ , “Decoupled Direct Memory Access: Isolating CPU and IO Traffic by Leveraging a Dual-Data-Port DRAM,” in _PACT_ , 2015.
  * [169] K. K. Chang _et al._ , “Understanding Reduced-Voltage Operation in Modern DRAM Devices: Experimental Characterization, Analysis, and Mechanisms,” in _SIGMETRICS_ , 2017.
  * [170] S. Ghose _et al._ , “What Your DRAM Power Models Are Not Telling You: Lessons from a Detailed Experimental Study,” in _SIGMETRICS_ , 2018.
  * [171] M. Patel _et al._ , “The Reach Profiler (REAPER): Enabling the Mitigation of DRAM Retention Failures via Profiling at Aggressive Conditions,” in _ISCA_ , 2017.
  * [172] H. Luo _et al._ , “CLR-DRAM: A Low-Cost DRAM Architecture Enabling Dynamic Capacity-Latency Trade-Off,” in _ISCA_ , 2020.
  * [173] S. Ghose _et al._ , “Demystifying Complex Workload-DRAM Interactions: An Experimental Study,” in _SIGMETRICS_ , 2019.
  * [174] K. K. Chang, “Understanding and Improving the Latency of DRAM-Based Memory Systems,” Ph.D. dissertation, Carnegie Mellon University, 2017.
  * [175] Y. Kim, “Architectural Techniques to Enhance DRAM Scaling,” Ph.D. dissertation, Carnegie Mellon University, 2015.
  * [176] D. Lee, “Reducing DRAM Latency at Low Cost by Exploiting Heterogeneity,” Ph.D. dissertation, Carnegie Mellon University, 2016.
  * [177] A. Olgun _et al._ , “PiDRAM: A Holistic End-to-end FPGA-based Framework for Processing-in-DRAM,” arXiv:2111.00082, 2021.
  * [178] Xilinx, “Xilinx Zynq-7000 SoC ZC706 Evaluation Kit,” 2021. [Online]. Available: https://www.xilinx.com/products/boards-and-kits/ek-z7-zc706-g.html
  * [179] K. Asanović _et al._ , “The Rocket Chip Generator,” Technical Report No. UCB/EECS-2016-17, 2016.
  * [180] RISC-V, “RISC-V Proxy Kernel,” https://github.com/riscv-software-src/riscv-pk, 2022.
  * [181] Linux man-pages Project, “memcpy(3) — Linux manual page,” https://man7.org/linux/man-pages/man3/memcpy.3.html, 2022.
  * [182] Linux man-pages Project, “calloc(3p) — Linux manual page,” https://man7.org/linux/man-pages/man3/calloc.3p.html, 2022.
  * [183] A. Olgun, “Projects and Seminars on PIM, Invited Talk, End-to-end Framework for Processing-using-Memory,” https://youtu.be/s_z_S6FYpC8, 2021.


# Considerations on Quantum Gravity Phenomenology

Carlo Rovelli  Aix Marseille University, Université de Toulon, CNRS, CPT,
13288 Marseille, France,
Perimeter Institute, 31 Caroline Street North, Waterloo, Ontario, Canada, N2L
2Y5,
The Rotman Institute of Philosophy, 1151 Richmond St. N London, Ontario,
Canada, N6A 5B7.

###### Abstract

I describe two phenomenological windows on quantum gravity that seem promising
to me. I argue that we already have important empirical inputs that should
orient research in quantum gravity.

I do two things in this brief note. First, I describe the two directions
towards quantum gravity phenomenology that seem more promising to me. Then, I
list some considerable empirical information that we have obtained lately,
which I think is relevant for understanding the quantum properties of gravity,
and I believe are unwisely disregarded. This is also the opportunity for some
general considerations on the topic.

##  I Where Are We Going to See Quantum Gravity Effects

###  I.1 Gravity-Induced Entanglement

It is possible to probe a plausible and genuine quantum gravity effect in the
laboratory with technology that is not far from the one available today.
Surprisingly, nobody had realized that this was the case until a few years
ago. The trick that makes this possible is that this is a (genuine, but) non-
relativistic quantum gravitational effect.

Here is the main idea Bose2017a ; Marletto2017a  (for related ideas, see
Howl2020 ). Two systems, $A$ and $B$, each with mass $m$, are each put into
the quantum superpositions of two different positions, say, $L$ and $R$. This
generates a state formed by four branches:

$\displaystyle(|R\rangle_{A}+|L\rangle_{A})\otimes(|R\rangle_{B}+|L\rangle_{B})=$
$\displaystyle\hskip
28.45274pt|R,R\rangle+|R,L\rangle+|L,R\rangle+|L,L\rangle.$ (1)

The systems are arranged in such a way that in one of these four branches, the
two masses are at a small distance $d$ from each other, and they are kept so
for a time $t$. Then, the components of each of the two systems are
recombined.

The vicinity of the masses in one of the branches generates a gravitational
interaction. This has the effect of altering the evolution of the phase of the
branch. In a relativistic picture, this is because the gravitational field is
different in each of the branches: the gravitational field is in a
superposition of classical configurations; in the branch where the particles
are close, each particle feels the time dilatation due to the vicinity of the
other mass Christodoulou2018c . In the non-relativistic picture, the same
effect is interpreted as due to gravitational potential energy $V=-Gm^{2}/d$.
Since the phase evolves with the energy $H$ as in $exp\\{-iHt/\hbar\\}$, the
total change in the phase of that branch with respect to the others is then
clearly

$\delta\phi=\frac{Gm^{2}t}{\hbar d}.$ (2)

The change of phase in one branch has the effect of entangling the two
systems, which, as (1) shows, were not entangled to start with. The fact that
they are entangled can then be tested in the lab.

The crucial observation is that today’s technology is not far from the
possibility of keeping nano-particles in a superposition and at a distance $d$
from each other for a time $t$, such that $\delta\phi\sim\pi$ Bose2017a .
Hence, if the gravitational field can be in a superposition, the effect
follows. Since we know from general relativity that the gravitational field is
the same entity as the geometry of spacetime, the measurement of this effect
amounts to detecting an effect that follows from the superposition of
spacetime geometries.

The power of this setup is in fact even stronger. The reason is a well-known
fact in quantum information: it is not possible to entangle two quantum
systems by having them both interact with a third classical system. In this
setup, the two systems are $A$ and $B$, and the third system is the
gravitational field. If we find $A$ and $B$ entangled by the gravitational
interaction, then the gravitational field cannot be classical Marletto2017a .

To be sure, the knowledge that gravity is mediated by a field (in fact, a
relativistic field) is needed for the interpretation of the experiment. If
gravity was an instantaneous action at a distance and not mediated by a field,
then we could not conclude anything from the experiment itself. Hence, the
subtlety at the basis of this experiment is that it can be performed in a non-
relativistic regime, but its full implication requires the knowledge (that we
have) that gravity is mediated by a relativistic field. In other words, a
positive outcome of the experiment is not compatible with a description of
gravity as the result of a classical field.

When successfully performed, the importance of this experiment will be major.
It could well be the first clear manifestation of the fact that spacetime
geometry is not classical.

Since it is a non-relativistic regime, the experiment would not differentiate
current tentative theories of gravity (such as loop quantum gravity, string
theory, asymptotic safety, or others). All current tentative theories predict
it. It would rule out, on the other hand, speculations such as those exploring
the (very unlikely) possibility that gravity is not quantized, or that there
is a gravitationally induced physical collapse of the wave function. Variants
of the experiment have been proposed that might actually access the
relativistic regime and test the discreteness of proper time
Christodoulou2018b ; Christodoulou2020 , but these require a much higher
experimental sensitivity.

In the past, there have been numerous other ideas on testing hypothetical
quantum gravity effects, but—as far as I could understand—none considered a
plausible effect; namely, an effect actually predicted by the current credible
quantum gravity theories. The gravity-induced entanglement experiment does so.

This, I believe, is a general point. I find that there is a common false
impression that since quantum gravity is an open problem, then “everything is
possible” and any wide speculation can be counted as a “possible” quantum
gravity phenomenon. This is not good science, in my opinion. Quantum gravity
is an open problem because no quantum gravity effect has been measured yet,
because there are a few competing theories about what exactly happens at the
Planck scale, and because we do not have a way of empirically probing them.
But all these theories are expected to give the same indications about what
does or does not happen at lower scales.

As always in science, a priori everything is possible, but there is a profound
difference between an implausible wild speculation and the predictions of a
plausible, coherent framework. This is a distinction a bit too much
disregarded in today’s fundamental physics, in my opinion.

###  I.2 Dark Matter as Quantum Gravity Stabilized White Holes

The first black hole signal was detected long before any black hole signal was
recognized as such. In fact, a strong radio signal from Sagittarius A*, the
gigantic black hole at the center of our galaxy, has been detected by radio
antennas since the dawn of radio astronomy, without people suspecting it could
be due to a black hole.

It might be the same with quantum gravity. Dark matter is a major unclear
phenomenon Adam2016 . There are many candidate theories for explaining dark
matter, virtually all of which require the hypothesis of new physics. But
there is also a possibility that dark matter could be explained without any
recourse to new physics (which makes this hypothesis more, not less,
interesting). The possibility is that dark matter might be formed by long-
living Planck-size remnants of evaporated black holes. The black holes could
have been formed in the early universe, or alternatively, if the Big Bang was
a Big Bounce, they might have crossed the bounce.

The idea of black hole remnants is an old one, recently revived by quantum
gravity calculations that provide them with a realistic model: white holes
with a large interior and a small horizon stabilized by quantum gravity
Bianchi2018e . A large body of theoretical research converge today, indicating
that spacetime can be continued past the central singularity of a black hole
and into an anti-trapped region, namely, a white hole. The singularity itself
is replaced by a quantum region where the Einstein equations are briefly
violated.

Macroscopic white holes are unstable because they can easily re-collapse into
black holes, but Planck-size ones are stabilized by quantum theory
rovelli2018small . White hole remnants need to be long-lived because the
information they store needs a long time to exit, in the form of low-frequency
radiation.

This scenario is attractive, difficult to falsify, but also hard to confirm.
In this article, I do not cover the current work that explores its
phenomenology Vidotto2018a . What I intended to point out is that it might
(well) be that we are already seeing a massive quantum gravity effect: dark
matter.

##  II What Do We Already Know about Quantum Gravity?

I come to the second topic—results that are relevant to quantum gravity, which
are already providing us with crucial information.

###  II.1 Lorentz Invariance

The breaking of Lorentz invariance at the Planck scale may simplify the
construction of a quantum theory of gravity Horava29 . This observation
sparked a large theoretical enthusiasm for Lorentz-breaking theories some time
ago, and rightly so. But that bubble of enthusiasm has been deflated by
empirical observations. A large campaign of astrophysical observations has
failed to reveal the Planck-scale breaking of the Lorentz invariance in
situations where it would have been expected if this track for understanding
quantum gravity had been the good one Liberati2013 .

A methodological consideration is important at this point. Popperian
falsifiability is an important demarcation criterium for scientific theories
(that is, if a theory is not falsifiable, we better not call it “science”);
however, Popperian falsification is rarely the way theories gain or lose
credibility in science.

The way scientific theories gain or loose credibility in real science is
rather through a Bayesian gradual increase or decrease of the positive or
negative confirmation from empirical data. That is, when a theory predicts a
novel phenomenon and we this to be right, our confidence in the theory grows;
when it predicts a novel phenomenon and we do not find it, our confidence in
the theory decreases. Failed predictions rarely definitely kill a theory,
because theoreticians are very good at patching up and adjusting. But failed
predictions do make the success of a research program far less probable: we
loose confidence in it.

Hence, this has been the effect of not finding Lorentz violations in
astrophysics: tentative quantum gravity theories that break Lorentz invariance
might perhaps still be viable in principle, but in practice, far fewer people
bet on them.

###  II.2 Supersymmetry

What I wrote above is particularly relevant to the spectacular non-discovery
of supersymmetry at the LHC Canepa2019 . While in the Popperian sense, the
non-appearance of supersymmetric particles at the TeV scale does not rule out
all the theories based on supersymmetry, including string theory, in practice,
the strong disappointment of not finding what was expected counts heavily as a
strong dis-confirmation, in the Bayesian sense, of all those theories.

People have written that the non-discovery of supersymmetry is a crisis for
theoretical physics. This is nonsense, of course. It is only a crisis for
those who bet on supersymmetry and string theory. For all the alternative
theoretical quantum gravity programs that were never convinced by the
arguments for low-energy supersymmetry, the non-discovery of supersymmetry is
not a crisis: it is a victory.

Precisely for the same reason that the discovery of supersymmetry would have
been a confirmation of the ideas supporting the string supersymmetry research
direction, the non-discovery of supersymmetry at the LHC is a strong empirical
indication against the search for quantum gravity in the direction of
supersymmetric theories and strings.

Nature talks, and we better listen.

###  II.3 Cosmological Constant

A case similar to the one above but even stronger concerns the sign of the
cosmological constant. The cosmological constant is a fundamental constant of
nature, part of the Einstein equations (since 1917), whose value had not been
measured until recently. An entire research community has long worked, and is
still working, under general hypotheses that lead to the expectation for the
sign of the cosmological constant to be negative. Even today, the vast
majority of the theoretical work in that community assume it to be so.

Except that the sign of the cosmological constant is not negative. It is
positive, as observation has convincingly shown Adam2016 .

Once again, this counts as a strong dis-confirmation of the hypotheses on
which a large community has worked in the past, and is still working on today.

So far, we lack any direct evidence of a quantum gravitational phenomenon;
however, the non-detection of Lorentz violations around the Planck scale, the
non-discovery of super symmetric particles at the LHC, and the measurement of
a positive cosmological constant are strong indications from Nature that
disfavor the tentative quantum gravity theories that naturally imply these
phenomena.

## References

  * (1) Bose, S.; Mazumdar, A.; Morley, G.W.; Ulbricht, H.; Toroš, P.M.M.; Geraci, A.A.; Barker, P.F.; Kim, M.S.; Milburn, G. Spin Entanglement Witness for Quantum Gravity. Phy. Rev. Lett. 2017, _119_ , 240401, arXiv:1707.06050.
  * (2) Marletto, C.; Vedral, V. Witness gravity’s quantum side in the lab. Nature 2017, _547_ , 156–158. http://dx.doi.org/10.1038/547156a.
  * (3) Howl, R.; Vedral, V.; Naik, D.; Christodoulou, M.; Rovelli, C.; Iyer, A. Non-Gaussianity as a Signature of a Quantum Theory of Gravity. arXiv 2021, arXiv:2004.01189.
  * (4) Christodoulou, M.; Rovelli, C. On the possibility of laboratory evidence for quantum superposition of geometries. Phys. Lett. B 2018, _792_ , 64–68, arXiv:1808.05842.
  * (5) Christodoulou, M.; Rovelli, C. On the possibility of experimental detection of the discreteness of time. _arXiv_ 2018, arXiv:1812.01542v1.
  * (6) Christodoulou, M.; Di Biagio, A: Martin Dussaud, P. An experiment to test the discreteness of time arXiv:2007.08431.
  * (7) Adam, R. Planck 2015 results: I. Overview of products and scientific results. Astron. Astrophys. 2016, _594_ , 1–38. arXiv:1502.01582.
  * (8) Bianchi, E.; Christodoulou, M.; Ambrosio, F.D.; Haggard, H.M.; Rovelli, C. White holes as remnants: A surprising scenario for the end of a black hole. Class. Quantum Grav. 2018, _35_ , 225003. arXiv:1802.04264.
  * (9) Rovelli, C.; Vidotto, F. Small black/white hole stability and dark matter. Universe 2018, _4_ , 127. arXiv:1805.03872.
  * (10) Vidotto, F. Quantum insights on Primordial Black Holes as Dark Matter. PoS 2018, EDSU2018, 046. arXiv:1811.08007.
  * (11) Horava, P. Quantum gravity at a Lifshitz point. Phys. Rev. D Part. Fields Grav. Cosmol. 2009, _79_ , 084008. arXiv:0901.3775.
  * (12) Liberati, S. Tests of Lorentz invariance: A 2013 update. Class. Quantum Grav. 2013, _30_ , 133001. arXiv:1304.5795.
  * (13) Canepa, A. Searches for supersymmetry at the Large Hadron Collider. Rev. Physics 2019, _4_ , 100033. http://dx.doi.org/10.1016/j.revip.2019.100033.