Disks, RAM and other tips
As with any persistence solution, performance depends a lot on the persistence media used. In general, the faster storage you have, and the more of your data you can fit in RAM, the better performance you will get. This page provides an overview of performance considerations for disk and RAM when running Neo4j.
There are many performance characteristics to consider for your storage solutions. The performance can vary hugely in orders of magnitude. Generally, having all your data in RAM achieves maximum performance.
If you have multiple disks or persistence media available, it may be a good idea to divide the store files and transaction logs across those disks. Keeping the store files on disks with low seek time can do wonders for read operations.
Use tools like
vmstat to gather information when your application is running.
If the swap or paging numbers are high, that is a sign that the database does not quite fit in memory.
In this case, database access can have high latencies.
To achieve maximum performance, it is recommended to provide Neo4j with as much RAM as possible to avoid hitting the disk.
When Neo4j starts up, its page cache is empty and needs to warm up. The pages, and their graph data contents, are loaded into memory on demand as queries need them. This can take a while, especially for large stores. It is not uncommon to see a long period with many blocks being read from the drive, and high IO wait times. This will show up in the page cache metrics as an initial spike in page faults. The page fault spike is then followed by a gradual decline of page fault activity, as the probability of queries needing a page that is not yet in memory drops.
Neo4j Enterprise Edition has a feature called active page cache warmup, which is enabled by default via the
db.memory.pagecache.warmup.enable configuration setting.
How it works
It shortens the page fault spike and makes the page cache warm up faster. This is done by periodically recording cache profiles of the store files while the database is running. These profiles contain information about what data is and is not in memory and are stored in the data/databases/mydatabase/profiles directory. When Neo4j is restarted next time, it looks for these cache profiles and loads the same data that was in memory when the profile was created. The profiles are also copied as part of the online backup and cluster store-copy operations and help warm up new databases that join a cluster.
The setting should remain enabled for most scenarios. However, when the workload changes after the database restarts, the setting can be disabled to avoid spending time fetching data that will be directly evicted.
- Load the entire database into memory
It is also possible to configure
db.memory.pagecache.warmup.preloadto load the entire database data into memory. This is useful when the size of the database store is smaller than the available memory for the page cache. When enabled, it disables warmup by profile and prefetches data into the page cache as part of the startup.
- Load specified files into memory
The files that you want to prefetched can be filtered using the
db.memory.pagecache.warmup.preload.allowlistsetting. It takes a regular expression as a value to match the files.
For example, if you want to load only the nodes and relationships, you can use the regex
.*(node|relationship).* to match the name of the store files.
The active page cache warmup will prefetch the content of the following files:
And can be verified using unix
ls neo4j/ | grep -E '.*(node|relationship).*'
- Configure the profile frequency for the page cache
The profile frequency is the rate at which the profiles are re-generated. More frequent means more accurate. A profile contains information about those parts of the files that are currently loaded into memory. By default, it is set to
db.memory.pagecache.warmup.profile.interval=1m. It takes some time to generate these profiles, and therefore
1mis a good interval. If the workload is very stable, then the profile will not change much. Accordingly, if the workload changes often, the profile will thus often become outdated.
Neo4j flushes its page cache in the background as part of its checkpoint process.
This will show up as a period of elevated write IO activity.
If the database is serving a write-heavy workload, the checkpoint can slow the database down by reducing the IO bandwidth that is available to query processing.
Running the database on a fast SSD, which can service a lot of random IOs, significantly reduces this problem.
If a fast SSD is not available in your environment, or if it is insufficient, then an artificial IOPS limit can be placed on the checkpoint process.
db.checkpoint.iops.limit restricts the IO bandwidth that the checkpoint process is allowed to use.
Each IO is, in the case of the checkpoint process, an 8 KiB write.
An IOPS limit of 600, for instance, would thus only allow the checkpoint process to write at a rate of roughly 5 MiB per second.
This will, on the other hand, make checkpoints take longer to complete.
A longer time between checkpoints can cause more transaction log data to accumulate, and can lengthen recovery times.
See the Checkpointing and log pruning section for more details on the relationship between checkpoints and log pruning.
The IOPS limit can be changed at runtime, making it possible to tune it until you have the right balance between IO usage and checkpoint time.