Extents are often blamed for performance problems; however, their impact on performance is minimal and can be completely avoided. In fact, careful use of extents can improve your response time by distributing your I/O operations across multiple devices. To understand the impact of extents on performance, you need to consider the two different methods of reading data from a table: by RowID and by full table scan.
Oracle's preferred method of reading records for OLTP applications is by the row's RowID value. For example, an index range scan may generate a list of RowIDs that match a query's limiting condition. The query in the following listing would perform a range scan on the SALES table's primary key index (a two-column composite index on the Company_ID and Period_ID columns).
Since all columns are selected from the SALES table, the index alone cannot satisfy the query. Once the index has been scanned for the RowID values for rows that meet the limiting condition on the Company_ID column, the SALES table will be accessed via a TABLE ACCESS BY ROWID operation.
In Oracle7, the RowID pseudo-column has three components. The RowID components are, in order: a block number (of the block within the file), a sequence number (of the row within the block), and a file number (of the file within the database). For example, the RowID 00001234.0000.0009 corresponds to the first row (sequence number 0000) in block 00001234 of file 09 (note that the numbers are in hexadecimal). Once Oracle has the RowID for a row, it knows exactly which block of which file the row is located in, and it knows exactly where within the block the row resides.
In Oracle8, the extended RowID format is available. In the extended RowID format, the size of each part of the RowID has been increased to support a greater number of files and blocks per file. Additionally, the data object identifier was added to the RowID. When displaying an extended RowID, a base-64 character string is returned. For example, the following query shows the new RowID and its parts:
The first six base-64 digits are for the object number. In the extended RowID, ‘A’ stands for zero, ‘B’ for 1, ‘C’ for 2, and ‘s’ for 44. Therefore, the object number AAAACs in base 64 is equal to 2*64+44=172, which matches the Object_ID value returned by the ROWID_OBJECT procedure. The next three base-64 digits are the relative file number (AAB=1). The next six digits are the block number, and the last three digits are the row number inside the block.
What the RowID does not contain—information regarding the extent in which the row resides—is just as significant as what it does contain. Accesses to the table that use a RowID-based method, such as indexed-based accesses, are blind to the extent allocation within the segment. Extents only impact full table scans.
Note: The following comparison of the extent size with respect to I/O size for saving I/O is significant only when the I/O size (64KB) and the extent size are of the same order of magnitude. It becomes insignificant if I/O size is much less than extent size.
During a full table scan, Oracle uses its multiblock read capability to scan multiple blocks at a time. The number of blocks read at a time is determined by the database's DB_FILE_MULTIBLOCK_READ_COUNT setting in the init.ora file and by the limitations of the operating system's read buffers. For example, if you are limited to a 64KB buffer for the operating system, and the database block size is 4KB, you can read no more than 16 database blocks during a single read.
Consider the SALES table again, with an 8MB initial extent and a 4MB second extent. For this example, assume that the highwatermark of SALES is located at the end of the second extent. In the first extent, there are 2048 database blocks, 4KB each in size (8 MB/4 KB = 2048). During a full table scan, those blocks will be read 16 at a time, for a total of 128 reads (2048/16 = 128). In the second extent, there are 1024 database blocks. During a full table scan, those blocks will be read 16 at a time, for a total of 64 reads (1024/16=64). Thus, scanning the entire table will require 192 reads (128 for the first extent, plus 64 for the second extent).
What if the two extents were combined, with the table having the same highwatermark? The combined extent would be 12MB in size, consisting of 3072 database blocks. During a full table scan, those blocks will be read 16 at a time, for a total of 192 reads. Despite the fact that the extents have been compressed into a single extent, the exact same number of reads is required because of the way the extents were sized. As you will see in the next section, the location of the extents may influence the efficiency of the reads, but the number of reads is the same in both the single- and two-extent examples.
What if SALES had 192 extents, each one 16 blocks in length? A full table scan would read 16 blocks at a time, for a total of 192 reads. Thus, whether the SALES table had 1, 2, or 192 extents, the exact same number of reads was required to perform the full table scan. The size of the extents is critical—the size of each extent must be a multiple of the number of blocks read during each multiblock read (set via the DB_FILE_MULTIBLOCK_READ_COUNT init.ora parameter value).
In the 192-extent example, the extent size matched the setting of the DB_FILE_MULTIBLOCK_READ_COUNT value (16). If each extent had been 20 blocks (instead of 16 blocks), how many reads would be required?
The SALES table contains 3072 blocks of data (12MB total). If each extent is 20 blocks (80 KB) each, you'll need 154 extents to store the 3072 blocks of data. When reading the first extent during a full table scan, Oracle will read the first 16 blocks of the extent (as dictated by the DB_FILE_MULTIBLOCK_READ_COUNT). Because there are four blocks left in the extent, Oracle will issue a second read for that extent. Reads cannot span extents, so only four blocks are read by the second read. Therefore, the 20-block extent requires two reads. Since each extent is 20 blocks in length, each extent will require two reads. Because there are 154 extents, a full table scan of SALES will now require 308 reads—a 60 percent increase over the 192 reads previously required!
As shown in Table 1, the number of extents in a table does not affect the performance of full table scans of the table as long as the size of the extents is a multiple of the size of each read that is performed.
Size of extents
Number of extents
Number of reads required by a full table scan
Table 1: Impact of Extent Sizes on Full Table Scans
The examples listed in Table 1 show two important facts about extents relative to performance:
1. If the extents are properly sized, the number of extents has no impact on the number of reads required by table scans.
2. If the extents are not properly sized, the number and size of the extents can greatly increase the amount of work performed by the database during a full table scan.
Proper sizing of extents is a key factor in managing the performance of full table scans. To eliminate the potential impact of multiple extents on performance, you need to make sure that the size of each extent is a multiple of the number of blocks read during each multiblock read. In many systems, 64KB or 128KB is read during each read (in the SALES example, 64KB was used). Therefore, size your extents so that each is an even multiple of 64KB or 128KB. As shown in Table 1, choosing an extent size that is not an even multiple of this value (such as 80KB) can increase the amount of work performed during a full table scan. If the extents are properly sized, there is no impact on the required number of reads.
Although increasing the number of extents does not necessarily increase the number of reads required, the complexity of managing the impact of extents increases as the number of extents increases. Consider, for example, the size of the extents; although you may calculate them to minimize the number of unnecessary reads, Oracle may dynamically change the extent size based on its rounding functions. The only way to reduce the effect of dynamic space allocation rounding is to reduce the number of extents.
Database objects frequently read via large scans—either full table scans or large index range scans—should be stored in a small number of extents. The additional extents, if properly sized, will not negatively impact performance. Keeping the number of extents small makes it more likely that the next
data to be read is physically near the data currently being read.
If having multiple properly sized extents does not necessarily hurt your performance at the database level, what impact does it have at the operating-system level?
There is no way to guarantee (from within the database) that the datafiles you create are located on contiguous areas of disk. Thus, two consecutive blocks within the same extent may be physically located on different sections of the same disk.
If the blocks of a datafile were all contiguous on a disk, then each time you completed one read, the disk hardware would be properly positioned to execute the next read. But since there is no guarantee that the data you are reading from a single extent is contiguous on the disk, there is no guarantee that the disk hardware is properly positioned for the next read regardless of the number of extents in the table. Any potential benefit from disk hardware positioning is therefore eliminated unless you can guarantee that the file is located on a contiguous area on a disk. If you create a new file system on a new disk, and create a datafile as the first file in that file system, you increase the likelihood that the file's blocks are physically contiguous.
If a database object is not read by large scans, the number of extents has no impact on the performance of queries against it. In OLTP applications, the typical access to database files is via random "hot-spot" reads; the efficiency of the reads may be improved if the hot spots are near each other, but the number of extents in which the hot spots are stored makes little difference to the performance of the data accesses. When designing your database to take advantage of the physical location of data, you need to be aware of the I/O management techniques in use on the server. The advanced I/O management techniques available, such as RAID technologies, use striping methods to split a file across multiple disks—so data that appears to be on the same device is actually stored on separate disks. Because RAID systems distribute data from the same file across multiple disks, you cannot be certain of the physical location of a data hot spot, nor that two hot spots are stored on the same disk.
Having a single extent may make an object simple to manage—provided the object fits into a single datafile. However, forcing each object in your database to have just one extent will yield little in the way of performance improvements, and may actually hurt performance.
If you have only one extent in the SALES table, you cannot stripe the SALES data within the database. The SALES table would be stored in a single datafile and, by extension, on a single disk. All queries against SALES will use the same disk, and you will be unable to distribute the I/O operations across multiple disks unless you use some form of operating system-level striping.
If you have only one extent for SALES, you will not be able to effectively use the Parallel Query option (PQO) for queries against the table. In the PQO, multiple processes concurrently perform the work of a query. If the data queried by the multiple processes is all located on the same disk, using the PQO for queries of the data may create an I/O bottleneck on the disk!
Lastly, having a single extent for an object prevents you from using the available extents to determine the growth rate for an object. For example, if you create a large initial extent for a small business transaction table, you will have to periodically check the number of rows in the table in order to determine its growth rate. If the extents were more reasonably sized, you would be able to determine its growth pattern by checking its extent allocations. Also, a single large extent wastes space within the object. Although you can reclaim allocated space as of Oracle7.3, there is usually little benefit to preallocating large volumes of unused space.
If the size of each extent is a multiple of the data volume read during a single multiblock read from the database, there is no performance penalty for using multiple extents—and if you are using database striping or PQO methods, there is potential performance benefit. You can use the maxextents unlimited clause to allow your objects to have over two billion extents—but such a high number is difficult to manage and can significantly impact the performance of DDL that updates extent information (such as drop table). Although multiple extents do not have to hurt your performance, they can make your database more difficult to administer. For database tables that will grow—primarily the business transaction tables—monitor their extent allocation and determine their growth rate. If the business transaction tables extend no more often than once every few months, the management effort required for them will remain low.
来自 “ ITPUB博客 ” ，链接：http://blog.itpub.net/35489/viewspace-84248/，如需转载，请注明出处，否则将追究法律责任。