Using HDFS Caching with Impala (CDH 5.1 or later only)
HDFS caching provides performance and scalability benefits in production environments where Impala queries and other Hadoop jobs operate on quantities of data much larger than the physical RAM on the data nodes, making it impractical to rely on the Linux OS cache, which only keeps the most recently used data in memory. Data read from the HDFS cache avoids the overhead of checksumming and memory-to-memory copying involved when using data from the Linux OS cache.
- Overview of HDFS Caching for Impala
- Setting Up HDFS Caching for Impala
- Enabling HDFS Caching for Impala Tables and Partitions
- Loading and Removing Data with HDFS Caching Enabled
- Administration for HDFS Caching with Impala
- Performance Considerations for HDFS Caching with Impala
For background information about how to set up and manage HDFS caching for a CDH cluster, see the CDH documentation.
Overview of HDFS Caching for Impala
On CDH 5.1 and higher, Impala can use the HDFS caching feature to make more effective use of RAM, so that repeated queries
can take advantage of data
Setting Up HDFS Caching for Impala
To use HDFS caching with Impala, first set up that feature for your CDH cluster:
- Decide how much memory to devote to the HDFS cache on each host. Remember that the total memory available for cached data is the sum of the cache sizes on all the hosts. (Any data block is only cached on one host. Once a data block is cached on one host, all requests to process that block are routed to that same host.)
Issue hdfs cacheadmin commands to set up one or more cache pools, owned by the same
user as the impalad daemon (typically impala). For example:
hdfs cacheadmin -addPool four_gig_pool -owner impala -limit 4000000000For details about the hdfs cacheadmin command, see the CDH documentation.
Once HDFS caching is enabled and one or more pools are available, see Enabling HDFS Caching for Impala Tables and Partitions for how to choose which Impala data to load into the HDFS cache. On the Impala side, you specify the cache pool name defined by the hdfs cacheadmin command in the Impala DDL statements that enable HDFS caching for a table or partition, such as CREATE TABLE ... CACHED IN pool or ALTER TABLE ... SET CACHED IN pool.
Enabling HDFS Caching for Impala Tables and Partitions
Begin by choosing which tables or partitions to cache. For example, these might be lookup tables that are accessed by many different join queries, or partitions corresponding to the most recent time period that are analyzed by different reports or ad hoc queries.
In your SQL statements, you specify logical divisions such as tables and partitions to be cached. Impala translates these requests into HDFS-level directives that apply to particular directories and files. For example, given a partitioned table CENSUS with a partition key column YEAR, you could choose to cache all or part of the data as follows:
-- Cache the entire table (all partitions). alter table census set cached in 'pool_name'; -- Remove the entire table from the cache. alter table census set uncached; -- Cache a portion of the table (a single partition). -- If the table is partitioned by multiple columns (such as year, month, day), -- the ALTER TABLE command must specify values for all those columns. alter table census partition (year=1960) set cached in 'pool_name'; -- At each stage, check the volume of cached data. -- For large tables or partitions, the background loading might take some time, -- so you might have to wait and reissue the statement until all the data -- has finished being loaded into the cache. show table stats census; +-------+-------+--------+------+--------------+--------+ | year | #Rows | #Files | Size | Bytes Cached | Format | +-------+-------+--------+------+--------------+--------+ | 1900 | -1 | 1 | 11B | NOT CACHED | TEXT | | 1940 | -1 | 1 | 11B | NOT CACHED | TEXT | | 1960 | -1 | 1 | 11B | 11B | TEXT | | 1970 | -1 | 1 | 11B | NOT CACHED | TEXT | | Total | -1 | 4 | 44B | 11B | | +-------+-------+--------+------+--------------+--------+
CREATE TABLE considerations:
The HDFS caching feature affects the Impala CREATE TABLE statement as follows:
- You can put a CACHED IN 'pool_name' clause at the end of a CREATE TABLE statement to automatically cache the entire contents of the table, including any partitions added later. The pool_name is a pool that you previously set up with the hdfs cacheadmin command.
- Once a table is designated for HDFS caching through the CREATE TABLE statement, if new partitions are added later through ALTER TABLE ... ADD PARTITION statements, the data in those new partitions is automatically cached in the same pool.
- If you want to perform repetitive queries on a subset of data from a large table, and it is not practical to designate the entire table or specific partitions for HDFS caching, you can create a new cached table with just a subset of the data by using CREATE TABLE ... CACHED IN 'pool_name' AS SELECT ... WHERE .... When you are finished with generating reports from this subset of data, drop the table and both the data files and the data cached in RAM are automatically deleted.
See CREATE TABLE Statement for the full syntax.
Other memory considerations:
Certain DDL operations, such as ALTER TABLE ... SET LOCATION, are blocked while the underlying HDFS directories contain cached files. You must uncache the files first, before changing the location, dropping the table, and so on.
When data is requested to be pinned in memory, that process happens in the background without blocking access to the data while the caching is in progress. Loading the data from disk could take some time. Impala reads each HDFS data block from memory if it has been pinned already, or from disk if it has not been pinned yet. When files are added to a table or partition whose contents are cached, Impala automatically detects those changes and performs a REFRESH automatically once the relevant data is cached.
The amount of data that you can pin on each node through the HDFS caching mechanism is subject to a quota that is enforced by the underlying HDFS service. Before requesting to pin an Impala table or partition in memory, check that its size does not exceed this quota.
Loading and Removing Data with HDFS Caching Enabled
When HDFS caching is enabled, extra processing happens in the background when you add or remove data through statements such as INSERT and DROP TABLE.
Inserting or loading data:
- When Impala performs an INSERT or LOAD DATA statement for a table or partition that is cached, the new data files are automatically cached and Impala recognizes that fact automatically.
- If you perform an INSERT or LOAD DATA through Hive, as always, Impala only recognizes the new data files after a REFRESH table_name statement in Impala.
- If the cache pool is entirely full, or becomes full before all the requested data can be cached, the Impala DDL statement returns an error. This is to avoid situations where only some of the requested data could be cached.
- When HDFS caching is enabled for a table or partition, new data files are cached automatically when they are added to the appropriate directory in HDFS, without the need for a REFRESH statement in Impala. Impala automatically performs a REFRESH once the new data is loaded into the HDFS cache.
Dropping tables, partitions, or cache pools:
- When you issue a DROP TABLE for a table that is entirely cached, or has some partitions cached, the DROP TABLE succeeds and all the cache directives Impala submitted for that table are removed from the HDFS cache system.
- The same applies to ALTER TABLE ... DROP PARTITION. The operation succeeds and any cache directives are removed.
- As always, the underlying data files are removed if the dropped table is an internal table, or the dropped partition is in its default location underneath an internal table. The data files are left alone if the dropped table is an external table, or if the dropped partition is in a non-default location.
- If you designated the data files as cached through the hdfs cacheadmin command, and the data files are left behind as described in the previous item, the data files remain cached. Impala only removes the cache directives submitted by Impala through the CREATE TABLE or ALTER TABLE statements. It is OK to have multiple redundant cache directives pertaining to the same files; the directives all have unique IDs and owners so that the system can tell them apart.
- If you drop an HDFS cache pool through the hdfs cacheadmin command, all the Impala data files are preserved, just no longer cached. After a subsequent REFRESH, SHOW TABLE STATS reports 0 bytes cached for each associated Impala table or partition.
Relocating a table or partition:
The HDFS caching feature interacts with the Impala ALTER TABLE ... SET LOCATION statement as follows:
- If you have designated a table or partition as cached through the CREATE TABLE or ALTER TABLE statements, subsequent attempts to relocate the table or partition through an ALTER TABLE ... SET LOCATION statement will fail. You must issue an ALTER TABLE ... SET UNCACHED statement for the table or partition first. Otherwise, Impala would lose track of some cached data files and have no way to uncache them later.
Administration for HDFS Caching with Impala
Here are the guidelines and steps to check or change the status of HDFS caching for Impala data:
hdfs cacheadmin command:
- If you drop a cache pool with the hdfs cacheadmin command, Impala queries against the associated data files will still work, by falling back to reading the files from disk. After performing a REFRESH on the table, Impala reports the number of bytes cached as 0 for all associated tables and partitions.
You might use hdfs cacheadmin to get a list of
existing cache pools, or detailed information about the pools, as follows:
hdfs cacheadmin -listDirectives # Basic info Found 122 entries ID POOL REPL EXPIRY PATH 123 testPool 1 never /user/hive/warehouse/tpcds.store_sales 124 testPool 1 never /user/hive/warehouse/tpcds.store_sales/ss_date=1998-01-15 125 testPool 1 never /user/hive/warehouse/tpcds.store_sales/ss_date=1998-02-01 ... hdfs cacheadmin -listDirectives -stats # More details Found 122 entries ID POOL REPL EXPIRY PATH BYTES_NEEDED BYTES_CACHED FILES_NEEDED FILES_CACHED 123 testPool 1 never /user/hive/warehouse/tpcds.store_sales 0 0 0 0 124 testPool 1 never /user/hive/warehouse/tpcds.store_sales/ss_date=1998-01-15 143169 143169 1 1 125 testPool 1 never /user/hive/warehouse/tpcds.store_sales/ss_date=1998-02-01 112447 112447 1 1 ...
Impala SHOW statement:
- For each table or partition, the SHOW TABLE STATS or SHOW PARTITIONS statement displays the number of bytes currently cached by the HDFS caching feature. If there are no cache directives in place for that table or partition, the result set displays NOT CACHED. A value of 0, or a smaller number than the overall size of the table or partition, indicates that the cache request has been submitted but the data has not been entirely loaded into memory yet. See SHOW Statement for details.
- You can enable or disable HDFS caching through Cloudera Manager, using the configuration setting Maximum Memory Used for Caching for the HDFS service. This control sets the HDFS configuration parameter dfs_datanode_max_locked_memory, which specifies the upper limit of HDFS cache size on each node.
- All the other manipulation of the HDFS caching settings, such as what files are cached, is done through the command line, either Impala DDL statements or the Linux hdfs cacheadmin command.
Impala memory limits:
The Impala HDFS caching feature interacts with the Impala memory limits as follows:
- The maximum size of each HDFS cache pool is specified externally to Impala, through the hdfs cacheadmin command.
- All the memory used for HDFS caching is separate from the impalad daemon address space and does not count towards the limits of the --mem_limit startup option, MEM_LIMIT query option, or further limits imposed through YARN resource management or the Linux cgroups mechanism.
- Because accessing HDFS cached data avoids a memory-to-memory copy operation, queries involving cached data require less memory on the Impala side than the equivalent queries on uncached data. In addition to any performance benefits in a single-user environment, the reduced memory helps to improve scalability under high-concurrency workloads.
Performance Considerations for HDFS Caching with Impala
In Impala 1.4.0 and higher, Impala supports efficient reads from data that is pinned in memory through HDFS caching. Impala takes advantage of the HDFS API and reads the data from memory rather than from disk whether the data files are pinned using Impala DDL statements, or using the command-line mechanism where you specify HDFS paths. The SHOW TABLES command also now has a SHOW CACHED TABLES variant to examine which Impala tables are currently being cached.
When you examine the output of the impala-shell SUMMARY command, or look in the metrics report for the impalad daemon, you see how many bytes are read from the HDFS cache. For example, this excerpt from a query profile illustrates that all the data read during a particular phase of the query came from the HDFS cache, because the BytesRead and BytesReadDataNodeCache values are identical.
HDFS_SCAN_NODE (id=0):(Total: 11s114ms, non-child: 11s114ms, % non-child: 100.00%) - AverageHdfsReadThreadConcurrency: 0.00 - AverageScannerThreadConcurrency: 32.75 - BytesRead: 10.47 GB (11240756479) - BytesReadDataNodeCache: 10.47 GB (11240756479) - BytesReadLocal: 10.47 GB (11240756479) - BytesReadShortCircuit: 10.47 GB (11240756479) - DecompressionTime: 27s572ms
For queries involving smaller amounts of data, or in single-user workloads, you might not notice a significant difference in query response time with or without HDFS caching. Even with HDFS caching turned off, the data for the query might still be in the Linux OS buffer cache. The benefits become clearer as data volume increases, and especially as the system processes more concurrent queries. HDFS caching improves the scalability of the overall system. That is, it prevents query performance from declining when the workload outstrips the capacity of the Linux OS cache.
The Impala HDFS caching feature interacts with the SELECT statement and query performance as follows:
- Impala automatically reads from memory any data that has been designated as cached and actually loaded into the HDFS cache. (It could take some time after the initial request to fully populate the cache for a table with large size or many partitions.) The speedup comes from two aspects: reading from RAM instead of disk, and accessing the data straight from the cache area instead of copying from one RAM area to another. This second aspect yields further performance improvement over the standard OS caching mechanism, which still results in memory-to-memory copying of cached data.
For small amounts of data, the query speedup might not be noticeable in terms of wall clock time. The
performance might be roughly the same with HDFS caching turned on or off, due to recently used data being held
in the Linux OS cache. The difference is more pronounced with:
- Data volumes (for all queries running concurrently) that exceed the size of the Linux OS cache.
- A busy cluster running many concurrent queries, where the reduction in memory-to-memory copying and overall memory usage during queries results in greater scalability and throughput.
- Thus, to really exercise and benchmark this feature in a development environment, you might need to simulate realistic workloads and concurrent queries that match your production environment.
One way to simulate a heavy workload on a lightly loaded system
is to flush the OS buffer cache (on each data node) between iterations of queries against the same tables or
$ sync $ echo 1 > /proc/sys/vm/drop_caches
- Impala queries take advantage of HDFS cached data regardless of whether the cache directive was issued by Impala or externally through the hdfs cacheadmin command, for example for an external table where the cached data files might be accessed by several different Hadoop components.
- If your query returns a large result set, the time reported for the query could be dominated by the time needed to print the results on the screen. To measure the time for the underlying query processing, query the COUNT() of the big result set, which does all the same processing but only prints a single line to the screen.