yes no Was this document useful for you?
   Thank you for your participation!

* Your assessment is very important for improving the work of artificial intelligence, which forms the content of this project

Document related concepts

Open Database Connectivity wikipedia, lookup

Microsoft SQL Server wikipedia, lookup

Clusterpoint wikipedia, lookup

SQL wikipedia, lookup

PL/SQL wikipedia, lookup

Extensible Storage Engine wikipedia, lookup

Object-relational impedance mismatch wikipedia, lookup

Relational model wikipedia, lookup

Database model wikipedia, lookup

Reviewed by Oracle Certified Master Korea Community
( )
Beginning with Oracle Enterprise Server 7.1, it became possible to utilize more than a single server (shadow) process to
execute a query, which was available as the Parallel Query Option (PQO). The goal was to return results to the user more
quickly than with serial execution, at the expense of consuming additional system resources. This capability was greatly
expanded with each new release of Oracle Enterprise Server. In versions 8 and 9, an impressive array of parallel operations
are possible that include not only parallel query, but also parallel DML, parallel DDL, parallel direct-load using SQL*Loader,
an numerous maintenance tasks. This expanded capability is now collectively referred to as Parallel Execution (PX).
The purpose of this paper is to provide practical knowledge for configuring PX, monitoring performance once it has been
configured, and to highlight some of the most common uses in the data warehousing environment. The scope of this paper
will include the following topic areas to achieve that goal:
Overview of Parallel Execution architecture
Host and database design considerations
Configuring Parallel Execution
Implementing parallel operations
Common parallel data warehouse operations
Run-time performance monitoring
Many configuration parameters and recommended values are discussed. While the Oracle documentation is general in nature
and is applicable to all host vendors and configurations, this paper is geared towards the most common data warehouse
configurations encountered by the author as follows:
Sun Microsystems or Hewlett-Packard enterprise class host that has between 4 and 64 CPUs
High performance storage array such as EMC Symmetrix1
Single instance environment (eg. Oracle Parallel Server or Real Application Clusters not implemented)
Solaris2 or HP-UX3 operating system
Overview of PX Architecture
Before leaning about the configuration of the PX facility, it is necessary to achieve a good understanding of the process
architecture. To begin with a more simple case, consider non-parallel execution of a SQL statement. Several steps are
involved. The client process provides the interface to the end-user. The client (user) process may be SQL*Plus, or a custom
application written in Java, Perl, Visual Basic, or some other language. The client process may reside on the database server
or some other computer such as an end-user’s workstation. Each client process communicates with an Oracle server process.
The server process is responsible for interacting with the database on behalf of the client process. It accepts SQL statements
from the client process, parses and executes the statement against the database, and returns the results to the client process.
This is illustrated in figure 1.
Symmetrix is a registered trademark of EMC Corporation
Solaris is a registered trademark of Sun Microsystems, Inc.
HP-UX is a registered trademark of Hewlett-Packard Company
PX Facility Configuration and Use
R e s u lts
C lie nt
P ro c e s s
S e rve r
P ro c e s s
D a ta b a s e
Figure 1. Serial SQL Execution
Figure 2 illustrates the process configuration when a parallel query is executed. First, the server process that interacts with
the client process is promoted to the role of Query Coordinator (QC). The QC is primarily responsible for handling
communications with the client and managing a set of PX slave processes that perform most of the work against the database.
The QC is responsible for acquiring multiple PX slave processes, dividing up the workload between the PX slaves, and
passing the results back to the client.
Figure 2. Parallel SQL Execution with one PX slave per execution thread
When a parallel query is initiated by the client process, the QC determines how to divide the workload between the various
PX slave processes. It shouldn’t be surprising that the QC rewrites the SQL statement submitted by the client process into
one or more statements that are passed to the PX slaves for execution. In the above figure, there are three threads of
execution, each of which has one PX slave process. This is referred as intra-operational parallelism.
When a parallel operation is initiated, PX slaves are borrowed from a common slave pool that is available to all users of the
database instance. Once the parallel operation has completed, the slaves are released back to the pool for other parallel
operations. The maximum number of intra-operational PX slaves that will be brought to bear on a particular query can be
PX Facility Configuration and Use
controlled at the table or index level using the ALTER TABLE or ALTER INDEX directive respectively, or by SQL
statement hints. In certain cases, twice the degree of PX slaves will be used to satisfy a query. This configuration is
illustrated in Figure 3 where two PX slaves are utilized for each execution thread.
This configuration occurs when executing either a merge or hash join, or when sorting or other aggregation operations are
present in the original query. It will also occur when a parallel DML statement is executed with a correlated parallel
SELECT statement. In this case, each set of intra-operational PX slaves in an execution thread act in a producer-consumer
relationship. In the above case, the PX slaves that access the database directly produce data that are consumed by the second
set of intra-operational PX slaves. For example, in a sorting operation, the first set of PX slaves would retrieve rows from
the database and apply any limiting conditions that appear in the query. The resulting rows would be fed to the second set of
PX slaves for sorting. Each of the second set of PX slaves is responsible for sorting rows within a particular range. Each of
the PX slaves that accessed the data directly sends their results to the particular slave according to the value of the sort key.
When two PX slaves communicate with each other within the same thread of execution, it is referred to as inter-operational
Figure 3. Parallel SQL Execution with two PX slaves per execution thread
The above example contains two parallel operations. The first operation retrieves rows from tables in the database while the
second operation sorts or aggregates the results. When executing complex joins, multiple inter-operational parallel
operations may occur. In this case, the cost-based optimizer will split the original SQL statement into the optimal number of
operations, each of which is executed in parallel in succession. Consider the execution plan below involving three tables that
are hash joined, followed by a sort operation.
The optimizer may choose to perform four parallel operations in the following order using two sets of PX slaves.
The first set of PX slaves produces rows from table A using intra-operational parallelism.
The results of the step 1 are consumed by the second set of PX slaves, which also retrieve rows from table B using
intra-operational parallelism and perform the first hash join. Since steps 1 and 2 occur simultaneously, it represents
an inter-operational process.
The results produced in step 2 are consumed by the first set of PX slaves which have completed executing step 1.
The same set of PX slaves also retrieves rows from Table C using intra-operational parallelism and performs the
second hash join. Since steps 2 and 3 occur simultaneously, it represents an inter-operational process.
PX Facility Configuration and Use
The results from step 3 are consumed by the second set of PX slaves that have completed executing step 2. The PX
slaves perform the sort and return the result to the Query Coordinator.
This begins to sound hopelessly complex but there are several patterns that enable one to both clearly understand what is
occurring in each step. When SQL statements require more than two parallel operations to return the result, each set of PX
slaves is reused as necessary. In the absence of subqueries, union, intersect, or minus operations , the maximum number of
PX slaves required to satisfy the original statement is no more than twice the highest Degree of Parallelism specified on any
of the tables in the query.
Host and Database Design Considerations
Nobody will argue with the fact that it is much easier to build a system correctly from the ground up rather than to redesign
and retrofit when performance problems present themselves. It is a frustrating experience to spend a lot of effort setting up a
data warehouse with the intention of heavily utilizing PX only to find that it’s not working as expected. Many times, this is
caused because the DBAs and System Administrators designing the data warehouse have most of their experience with
OLTP systems that have very different requirements than data warehouse systems.
The most common performance problems encountered when implementing PX have two sources. The first source is that the
hardware may not be suitable or configured properly for use as a data warehouse where parallel operations are heavily
utilized. The second source of problems is caused by a database physical design that is not properly optimized to support
parallel operations. The usual culprit in both cases is resource contention. When designing and configuring a host system
and database that will rely heavily on PX, a number of general design principals should be employed. Many of these design
points are only applicable if a new system will be procured, but others can be employed on an existing system.
A RAID 1 (mirroring) disk configuration offers more tuning options than RAID 0+1 (striping+mirroring) because
objects can be manually striped across multiple physical devices. Arguably, RAID1 takes a bit more administration
because of the manual striping effort, but the resulting performance is worth it.
For a fixed quantity of disk capacity, more smaller mount points are likely to perform better than a few large ones.
For example, for a 700GB disk configuration, 10 – 70GB disks will perform better than 4 – 180GB disks. Having
more disks reduces physical disk contention.
Adding high throughput disk controllers (eg. Fiber Channel) will increase throughput between the disk subsystem
and the host. PX utilizes Direct Path operations whenever possible. This typically occurs when performing full
table and partition scans, and when specified on INSERT statements. In the absence of the buffer cache bottleneck,
remarkably high I/O throughput rates can be achieved if the I/O subsystem is properly designed and configured.
For a fixed quantity of CPU capacity, more less powerful CPUs are likely to perform better than fewer more
powerful ones. For a fixed amount of performance (eg. SpecINT92, SPECbase, SPECrate), if the choice is between
a 4-CPU or a 12-CPU configuration, the 12-CPU configuration is likely to perform better by reducing CPU
contention. The assumption here is that there is adequate bus bandwidth to support the higher number of CPUs.
When constructing tablespaces that will house large tables, more smaller datafiles will perform better than a few
large ones if they are striped over many mount points. This once again reduces disk contention. For example, if a
10GB tablespace is required, 40 – 256MB data files will perform better than 5 – 2GB data files.
The same paradigm holds true when constructing tablespaces to hold temporary and rollback segments. While the
amount of data sorted will usually remain the same whether or not a query utilizes PX, the disk sort activity at a
point in time when a parallel sort is running will be increased by a factor approximately equal to the Degree of
Parallelism of the query. Rollback segments will experience a similar increase in activity when a parallel DML
statement is executed.
Continuing on the theme of reducing disk contention, the online redo and archive log destinations should be used
exclusively for those purposes. Although much space may remain unused, contention on the online redo and archive
log disks during parallel DML operations can be the bottleneck on an otherwise well designed system.
When creating large tables or table partitions, many smaller extents will perform better than a few large ones. For
example, if a partitioned table will be created, 50 to 100 smaller extents per partition will perform better than with a
one or two large extents. Each new extent is allocated round robin style from tablespace datafiles that have space
available. If datafiles have been striped across many mount points, parallel full-table and partition scans will
PX Facility Configuration and Use
perform better because the data is spread across many physical disks. Here, Locally Managed Tablespaces should
be employed.
When creating partitioned tables, many smaller partitions will perform better than a few large ones. For example, if
a partitioned table will be created to house 5-years worth of data, a partitioned table created with 260 weekly
partitions or 60 monthly partitions will likely perform better than a table with 5 annual partitions. Choosing the
partition granularity also requires careful analysis of the types and volumes of SQL statements that will access the
table, data loading, and backup and recovery strategies.
In each of these examples, spreading the work over more objects reduces resource contention and potentially improves PX
throughput. If the optimizer determines that the specified Degree of Parallelism will degrade query performance because of
resource contention, or there are an insufficient number of objects over which to spread the work, the optimizer will reduce
the Degree of Parallelism behind the scenes, much to the chagrin of the user.
Configuring Parallel Execution
To this point, we’ve looked at an overview of the PX process architecture and its host requirements. In this section, more
details about the process and memory architecture will be discussed, and the relevant configuration parameters will be
explained. All of these parameters appear in the database parameter file (init.ora). Some may be changed dynamically using
ALTER SYSTEM and ALTER SESSION commands. Others require the database to be restarted to take affect. The first set
of parameters that will be discussed are those that affect the number of slaves in the slave pool, and how they are used by
statements that utilize them.
PX Slave configuration
When the optimizer determines that an operation will run using PX, the Query Coordinator recruits slaves from the PX slave
pool. It can only use slaves that are currently idle, or inactive. Once idle slaves are found, each of the slaves that will be
used is marked as active, and no other query can use them until they are released when the current parallel operation has
completed. Since PX slaves can only be used by one Query Coordinator at a time, the number of slaves available in the slave
pool is one of the primary limiting factors on the number of concurrent parallel operations. Additionally, PX slaves are
borrowed from the slave pool on a first-come, first-served basis.
The PX slave pool consists of a number of PX slaves that are available to all operations that will utilize PX on the database
instance. The PARALLEL_MIN_SERVERS parameter is used to determine the minimum number of PX slaves in the pool
and PARALLEL_MAX_SERVERS determines the maximum number. When the database instance is started, Oracle creates
a PX slave pool with the minimum number of slaves. As various PX operations begin to execute, the number of slaves in the
pool that are idle eventually becomes depleted.
If there is an insufficient number of PX slaves available in the pool to support a parallel operation, the value
PARALLEL_MAX_SERVERS is inspected. If the value is higher than the value of PARALLEL_MIN_SERVERS,
additional PX slave processes will be dynamically created (spawned), added to the pool, and recruited by parallel operations
that need them. Therefore, the maximum number of PX slaves that will ever reside in the pool is
As each Query Coordinator completes it’s parallel operations, the PX slaves become idle again and are now available for use
by other parallel operations. If there are more slaves than PARALLEL_MIN_SERVERS in the PX slave pool, the excessive
slaves will be terminated after a five minute period of inactivity. For example, let’s say that
PARALLEL_MIN_SERVERS=16 and PARALLEL_MAX_SERVERS=64 and all 64 slaves are active in the PX slave pool
because many PX queries were running concurrently. After this period of high activity, no parallel statements are run for a
while. When this occurs, the number of PX slaves in the slave pool will be reduced from 64 to 16.
The value for PARALLEL_MIN_SERVERS should be set to a value such that there are enough slaves readily available in
the slave pool to cover the average PX operation load on the system. The value for PARALLEL_MAX_SERVERS should
be set to the maximum number of slaves that can be created, and is usually based upon practical CPU and I/O limits. Some
consideration should be given to choosing the two values. If the minimum number of servers is set too low, then some
queries will always be waiting for additional PX slaves to be created, causing them to run longer. Setting the value too high
simply causes more system memory to be consumed because the idle processes remain in the slave pool. If memory is not
much of an issue, then it is acceptable to set the two parameters to the same value so that the maximum number of PX slaves
will always be available for use.
PX Facility Configuration and Use
A good reason why one might choose two different values is when the PX operation load varies greatly over time. Suppose
that most of the data are loaded nightly during a four-hour window. Many of the operations are parallelized including data
loads, materialized view and index rebuilds, and the creation of summary tables. There are few total sessions running on the
system during this period, but they are all active. This represents the peak-processing load on the system. However during
the day, there are hundreds of concurrent users on the system but only a few of them utilize PX for running parallel queries.
Here, it would be appropriate to choose a low value for PARALLEL_MIN_SERVERS to support the requirements during the
day and a much higher value for PARALLEL_MAX_SERVERS to support nightly processing requirements. During the day,
additional slaves would be dynamically added to the pool if required to support parallel queries, up to the value of
PARALLEL_MAX_SERVERS. Otherwise, the memory would be available to support the higher volume of concurrent
users. During the nightly load window, a much higher number of PX slaves will remain in the pool because of their frequent
Now what happens as the number of slaves currently being used approaches the value of PARALLEL_MAX_SERVERS? If
there are an insufficient number of PX slaves available to satisfy the requirements of a particular parallel operation, it will
consider using whatever slaves are available. The value of the PARALLEL_MIN_PERCENT parameter is used to decide
whether or not an operation will proceed using PX when the requested number of PX slaves is not available. Consider a
query where 16 slaves have been requested, but only 10 are available. If the value of PARALLEL_MIN_PERCENT was 50,
meaning that at least 50% of the requested slaves must be available for the operation to proceed in parallel, the operation will
proceed if there are a minimum of 8 slaves available. All 10 slaves will be used in this case. If the value of
PARALLEL_MIN_PERCENT was 75, the minimum number of slaves required to proceed in parallel is 12. Now the
statement will fail to execute and produce the following error message.
ORA-12827: insufficient parallel query slaves available.
If PARALLEL_MIN_PERCENT is set to 0, queries will utilize whatever PX slaves are available and proceed in parallel. If
no PX slaves are available, the query will execute non-parallel with no contrary warnings indications, other than a longer
elapsed time.
When PARALLEL_MIN_PERCENT is set to a value of 100, queries will not proceed in parallel unless all PX slaves
requested are actually acquired. Setting PARALLEL_MIN_PERCENT to a value of 100 assures that parallel operations will
behave more predictably. Since all PX slaves must be acquired for the operation to proceed in parallel, queries that run
successfully will do so with similar execution times.
The purpose of the PARALLEL_ADAPTIVE_MULTI_USER parameter is to help preserve overall database performance
during periods of high system load. It permits the requested Degree of Parallelism to be automatically reduced on new
parallel queries during periods of high database activity. If for example, the requested Degree of Parallelism is 16 but the
system load is high when the parallel operation begins to execute, the Degree of Parallelism might be reduced to 8. This
reduction will cause the query to run longer than if the original requested Degree of Parallelism were employed.
The PARALLEL_THREADS_PER_CPU parameter is used to adjust the load on each CPU when
PARALLEL_ADAPTIVE_MULTI_USER is enabled. The value represents the average number of PX slaves that each CPU
can process concurrently. The default value is 2 is usually adequate. If the host system has a few high-powered CPUs rather
than many lower performance CPUs, increasing the value may improve throughput. Likewise, if the host system has a
slower I/O subsystem, increasing the value may improve PX throughput.
The PARALLEL_BROADCAST_ENABLED parameter can significantly improve parallel query performance at the expense
of additional PGA memory. If a small row source is being joined to a large row source in either a merge or hash join, each of
the PX slaves processing the large row source may each require the entire small row source for the join. For example, if the
DOP for a hash join is 8 and a small table must be scanned by each of the PX slaves, the small table would be scanned 8
times if PARALLEL_BROADCAST_ENABLED is set to false, the default value. If the parameter is set to true, the table
will be scanned once by the Query Coordinator and the results will be delivered to each of the 8 PX slaves. Enabling this
parameter results in more memory usage within the PGA of each PX slave process.
SGA Memory Configuration
The next set of parameters to be discussed affect the SGA memory structures associated with PX. Oracle uses message
buffers to pass data between the various processes during inter-operational parallel operations. These buffers reside in the
shared pool inside the SGA if PARALLEL_AUTOMATIC_TUNING is set to FALSE, and in the large pool if the parameter
value is set to a value of TRUE. A fixed number of buffers is required for each producer-consumer connection. The number
of connections for a particular query varies with the square of the maximum Degree of Parallelism of the query since each
PX Facility Configuration and Use
producer has a connection to each consumer. If the maximum DOP of the query is 4, then there could be as many as 16
connections. If the maximum Degree of Parallelism were 8, there would be 64 connections. Based upon this relationship,
one can see that memory requirements for message buffers increase greatly as the maximum value of the DOP increases.
The system-wide amount of memory required for the message buffers also depends upon the number of concurrent queries
executing parallel statements, and the size of the message buffer. Based upon the variables, computing the buffer space is
quite inexact and is based upon a number of assumptions. We are simply interested in computing a ballpark number. We
want to know if the requirement is 20MB vs. 200MB, not 20.2MB vs. 20.5MB. The following formula from the Oracle
documentation can be used to compute the amount of memory required for PX message buffers on SMP systems:
buffer space = (3 x size x users x groups x connections)
users = The maximum number of sessions that will be concurrently issuing PX queries.
groups = The number of PX groups used per query. A nominal value of 2 is a good nominal value.
connections = (DOP x DOP) + (2 x DOP) Where DOP is the highest Degree of Parallelism that will be used for any query.
The PARALLEL_EXECUTION_MESSAGE_SIZE parameter controls the size of the messages and has a default value of
2KB if PARALLEL_AUTOMATIC_TUNING is set to FALSE, and 4KB if the parameter value is TRUE. Within certain
limits, increasing the size of the message buffer increases throughput between the producer and consumer PX slaves, which
in turn, reduces execution time. If machine memory is plentiful, increasing the value to 8KB may provide performance gains
if communication between inter-operational PX slaves is a bottleneck. If the value is increased, the SGA size must be
increased accordingly. If there is insufficient space in the PX message pool, parallel queries will fail with an ORA-4031
memory allocation failure message.
Here is an example computation for the PX message pool. Let’s use an 8KB PARALLEL_EXECUTION_MESSAGE_SIZE.
The value for size is 8192. A total of 20 users will be issuing parallel queries concurrently so the value of users is 20. Of
these 20 users, most will be using a Degree of Parallelism of 4, but several large queries use a degree of 8. So for the
computation of connections, the value of 8 for DOP should be used. The value of connections is:
connections = (8 x 8) + (2 x 8) = 80
Substituting these numbers into the above formula for buffer space yields
buffer space = (3 x 8192 x 20 x 2 x 80) = 78,643,200 bytes
Dividing by 1,048,576 to get megabytes yields 75MB. This is the minimum amount of memory that should be added directly
to the size of the shared pool or large pool depending upon the setting for PARALLEL_AUTOMATIC_TUNING. The
SHARED_POOL_SIZE and LARGE_POOL_SIZE parameters control the size of the share pool and large pool respectively.
It is desirable to locate the message buffers in the large pool because the shared pool is already heavily used for other
purposes, and is often a place for contention without further exacerbation. The large pool, on the other hand, has
considerably less activity because it has fewer uses. It is only used for the PX message pool, DB Writer I/O slaves, and
Multithreaded Server (MTS) if those features are used. Since all of the other features provided by setting
PARALLEL_AUTOMATIC_TUNING to a value of TRUE can be overridden with other parameter settings if desired, set it
to a value of TRUE so that the PX message pool will be located in the large pool. There is no other mechanism to specify
that the message pool should be located in the large pool. The above computation is based upon a number of assumptions
you make and therefore produces a good starting point.
PX operations also cause more shared pool memory to be used than their serial counterparts. PX slaves are specialized
versions of the garden-variety server process so their operational characteristics are similar. So if 8 PX slaves will be used to
solve a particular query, the queries running on each slave will occupy space in the shared pool. Even if the PX message
pool resides in the large pool, the size of the shared pool should be increased to accommodate the additional memory
requirements caused by the additional SQL statements. A good starting point is to increase the size by 25% when
implementing PX on a well-tuned database, then monitoring for contention to determine is further adjustments are necessary.
PX Facility Configuration and Use
Other Resource Considerations
In addition to the obvious database parameters required to configure PX, there are also a number of others that must be
reevaluated. When a SQL statement executes using PX, the Query Coordinator uses a two-phase commit strategy to commit
transactions. Consider a parallelized UPDATE statement that utilizes 8 PX slaves to update rows in a total of 30 table
partitions. This results in a total of nine transactions; one for each of the 8 PX slaves, and one for the Query Coordinator. If
the SQL statement utilizes two PX slaves per thread of execution, then the number of transactions would be 17; one for each
of the 16 PX slaves, and one for the Query Coordinator. Therefore, the parameter value of TRANSACTIONS should be
increased by the value of PARALLEL_MAX_SERVERS to handle the additional number of transactions caused by the PX
The Query Coordinator will acquire DML locks on each of the partitions that are being processed. Each of the PX slaves will
also acquire DML locks on each of the partitions that they are processing. Therefore, the number of DML locks and enqueue
resources must both be increased considerably to handle the additional requirements imposed by PX.
If nondefault values for the PROCESSES and SESSIONS parameters are used, they must be increased by the value of
PARALLEL_MAX_SERVERS to accommodate the addition of PX slave processes.
Since the UPDATE statement modifies data, transaction information must be written to rollback segments in the event that
the transaction must be rolled back. Each slave process will utilize its own transaction space within a rollback segment since
each is treated as a separate transaction. The total amount of space used in rollback segments is not considerably higher than
that used by a serial transaction. But the overall load on the rollback segments while the statement is executing will be
considerably higher. This is caused because all of the work has been spread across multiple PX slaves to process the
statement within a shorter period of time. While parallel DML statements are running, verify that rollback segment
contention is minimal. If contention exists, then the rollback segments should be tuned accordingly. Performance on the
disks on which the rollback segments reside should also be monitored for contention
Likewise, when parallel DML statements are executing, redo entries are being generated at a much faster rate. This will
affect the all of the structures associated with the log writer (LGWR) including the log buffer in the SGA, and the number
and size of the online redo logs. This facility should be monitored closely when parallel DML statements are executing to
determine if tuning is necessary to improve performance.
PGA Memory Issues
The next set of parameters affect size of the Process Global Area (PGA) of the PX slave processes. The PGA is the private
memory area within each server or PX slave process. Sort and hash areas are located within this memory structure. Once
this memory has been allocated in the PGA, it remains allocated for the life of the server process.
Sort and hash memory areas can account for a considerable amount of overall memory usage on the database host,
particularly when PX is employed. If the database has been configured so that 10MB of memory sort area may be allocated,
then up to 10MB will be allocated for each sort in the query that runs serially. However, the same query running in parallel
with a degree of 16 may use 170MB of sort memory per sort because each PX slave process and the Query Coordinator are
each able to allocate 10MB. If the query performs multiple sorts, as in a merge join, then considerably more than 170MB of
memory will be allocated.
Data are sorted anytime an aggregation operation such as GROUP BY or ORDER BY is performed, and when merge joins
are performed. The SORT_AREA_SIZE parameter controls the amount of memory that can be allocated within the PGA for
a single sort. For small sorts, only the amount of memory required to perform the sort will be allocated. If a sort cannot be
performed entirely within memory, then the additional space required to perform the sort is allocated from temporary
segments on disk. With the high data volumes processed within a data warehouse, some sorts will be performed using
temporary segments on disk. When this occurs, multiple sort runs are performed in memory while the results of each run are
stored on disk. Even though disk sorts occur, sorting time will decrease as the size of the in-memory sort area increases
because fewer sort runs will be required to complete the sort. Query performance will be optimal if the sort is performed
entirely in memory.
The SORT_AREA_RETAINED_SIZE parameter controls the amount of memory retained in the PGA from a sort after it
completes. It affects the total amount of sort memory within the PGA when multiple sorts are performed within a single
query. In a merge join, for example, each of the two row sources must be sorted before they are merged. Sort memory up to
the value of SORT_AREA_SIZE is allocated to perform the first sort. After the first sort has completed, all of the data that
cannot fit within the value of SORT_AREA_RETAINED_SIZE are written to disk. For example, if SORT_AREA_SIZE is
1MB and SORT_AREA_RETAINED_SIZE is 512KB, after the first sort completes 512KB of the data will be written to disk
PX Facility Configuration and Use
and the remaining 512KB will be retained in memory. To sort the second row source, an additional 1MB of memory is
allocated to perform the sort. At the end of the second sort, the total sort memory used is now 1.5MB; 512KB retained from
the first sort, and 1MB from the second sort. Recursive statements may allocate additional PGA memory for sorting. So
allow at least the sum of SORT_AREA_SIZE and SORT_AREA_RETAINED_SIZE for the maximum number of PX slaves
that will be configured for additional host memory.
The hash area used for hash joins has similar properties to the in-memory sort area. Whenever a query performs a hash join,
memory is allocated in the PGA to hold the hash table of the first row source in the join. The value of HASH_AREA_SIZE
determines the maximum amount of memory that can be allocated per session when a hash join is performed. Like
SORT_AREA_SIZE, hash join memory can be allocated by each PX slave that performs the hash join.
Derived from
Derived from
No in 8i
Yes in 9i
No in 8i
Yes in 9i
Table 1. PX Configuration Parameters
The total amount of memory that will be used for sorting and performing hash joins by all PX slave processes should be
accounted for when configuring PX. When configuring these parameters, choose conservative values and monitor overall
system memory usage during peak loads to verify that there is sufficient memory on the host machine to comfortably support
PX Facility Configuration and Use
the load. If additional memory is available that could be used for sorting and performing hash joins, the parameter values can
be increased if additional performance is desired.
Enabling parallel broadcasting by setting the value of PARALLEL_BROADCAST_ENABLED to true will also cause more
PGA memory to be used. The additional memory usage will be proportional to the size of the row set being broadcast and
may range from a few kilobytes up to tens or hundreds of megabytes. It is best to enable this parameter after a stable PX
configuration has been established, so that it can be monitored in the absence of other changes.
Automatic PX Configuration
By this time, PX configuration may appear to be difficult and complex to configure. However, to make configuration easier,
Oracle has provided the PARALLEL_AUTOMATIC_TUNING parameter. When set to a value of TRUE, all of the
parameters associated with PX are configured to a set of reasonable values. Table 1 shows all of the parameters relevant to
PX including the less obvious ones, and the effects of setting PARALLEL_AUTOMATIC_TUNING to a value of TRUE.
All of the parameters in the table should be considered when configuring and monitoring the PX facility, although some have
only an indirect affect on performance. The table can be used effectively as a checklist.
Recommended Starting Configuration
The following parameters usually provide a stable starting point when setting up PX on the host configurations mentioned in
the introduction of this article. It uses a conservative approach that should produce good PX throughput without
overburdening the host system.
PARALLEL_MAX_SERVERS – Set to a value of CPU_COUNT x 3
LARGE_POOL_SIZE – Use the value computed from the above formula
SHARED_POOL_SIZE – Increase the current value by 20% to accommodate PX SQL statements
In addition to reducing the complexity of PX configuration, enabling Parallel Automatic Tuning is the only way to locate the
PX message buffers in the large pool. If nondefault values for PROCESSES, SESSIONS, LARGE_POOL_SIZE, or
TRANSACTIONS are already in use, refer to the Oracle documentation listed in the Bibliography to adjust the values
Leaving PARALLEL_MAX_SERVERS at the default value of CPU_COUNT x 10 may overload the host, even on a
database host and database designed and configured specifically for PX. Setting the value of PARALLEL_MIN_SERVERS
to a value of PARALLEL_MAX_SERVERS / 4 leaves at least some servers in the slave pool ready for immediate use. After
monitoring the behavior over several days or weeks, begin to make incremental adjustments as necessary to tune performance,
and to take advantage of additional free host system resources.
Implementing Parallel Operations
The overall goal in implementing PX is to improve throughput by utilizing excess resources available on the database
instance. This may occur at all times, or may only occur during certain times during the day such as during the evening when
end-user loads are minimal. PX should not be implemented on instances that are already overburdened or that are near their
resource limit.
There are two methods of implementing Parallel Query and Parallel DML operations. The first method involves setting the
Degree of Parallelism on tables and indexes as in the following example.
SQL> alter table f_monthly_acctg parallel(degree 8);
Table altered.
The default value for degree is 1. Once the above statement is executed, any queries that access the f_monthly_acctg table
may utilize PX if the optimizer determines that it is appropriate. Certainly, this is the least invasive method of implementing
PX because in many cases, neither SQL statements nor applications must to be changed. The risk here is that queries that
inappropriately perform full-table scans on large tables may cause significant performance degradation on the entire database
if they are executed simultaneously using PX by multiple users.
PX Facility Configuration and Use
On partitioned tables with local indexes, PX can be used to perform index range scans. To utilize PX in this capacity, the
degree of the index must be altered as shown in the following example.
SQL> alter index f_monthly_acctg_ix03 parallel(degree 8);
Index altered.
Before implementing PX by altering the degree at the object level, it is prudent to review SQL statements running against the
candidate tables either through the V$SQL dynamic performance view, or by code review, to make sure that all queries are
optimized. PX should not be used as a quick fix for missing or inadequate indexes. PX implemented on poorly tuned queries
may result in disastrous performance.
Also, determine the number of queries that will potentially use PX, and how long they will run to get an idea of the expected
increase in system load. Queries that run in the 5 second to 5 minute range are good candidates for implementing PX using
this method. The overhead associated with PX will usually not significantly benefit queries that run in less than 5 seconds. If
queries run longer than 5 minutes, then there is a risk that many users will execute them simultaneously causing overall
significant database performance degradation.
Some queries may still need to be tuned to utilize PX even though the table and/or index degree has been increased from a
value of one. Information about tuning queries to utilized PX is contained in the references listed in the Bibliography section.
The second, and preferred approach is to modify the SQL statements to use PX through the use of hints as shown in the
statement below. While this may be more invasive to applications than the first method, PX operations occur in a predictable
and controllable manner.
SELECT /*+ PARALLEL(s,8) / quarter_num, sum(acctg_num)
FROM s_daily_acctg s
WHERE year_num = 2002
AND acct_num = 70035
GROUP BY quarter_num;
DDL statements require special directives to utilize PX. Maintenance tasks such as gathering table statistics and rebuilding
indexes are performed under the control of Database Administrators so performance can be evaluated and controlled. Other
DDL statements that create temporary objects, as part of the data loading process, are usually performed by experienced
developers, possibly with the help of a Database Administrator. So here too, performance can be predicted and controlled.
In a production data warehouse environment, many of these tasks can be performed during off-peak hours when plenty of
excess database resources are available. Shortening the time of data loading windows is a particularly good use for PX.
So what is the best method? That depends upon when and where the extra performance is required. The following
implementation methodology lowers the risk of overall poor database performance when implementing PX.
For queries and DML statements that run during peak database load times
First, verify that all of the queries accessing the tables of interest are optimized. If the queries are properly
tuned and perform well, it may not be necessary to implement PX.
After tuning, verify that there are sufficient database resources available to implement PX. There should be
a considerable amount of CPU idle time available with few disk waits.
If there are many different statements running against a particular table that could benefit from PX, then
implement PX by altering DEGREE on the table and/or index. This is the more aggressive approach and
performance should be monitored to verify that overall database performance is maintained.
If there are few statements that could benefit from PX, tune and modify the queries using hints. This is a
more conservative approach, but performance should still be monitored to verify that overall database
performance is not impaired. These are likely to be long-running reports that run rather infrequently.
For all other tasks that run during off-peak hours
Identify the tasks that are good candidates to utilize PX. These include data loading tasks as well as
maintenance tasks that require considerable time to complete.
Verify that all of the SQL statements are fully optimized. If the queries are properly tuned and perform
well, it may not be necessary to implement PX.
PX Facility Configuration and Use
Tune SQL statements for PX and implement PX using hints.
For other maintenance tasks, implement PX using the directives specific to each statement.
Verify performance so that overall database performance is maintained.
The optimizer may reduce the run-time, or actual, Degree of Parallelism because certain conditions are not met. Here are
four of the most common reasons why this will occur, an example of each, and how it may be avoided.
Parallel operations on too small a table. A degree of 10 is specified for a nonpartitioned table that has a total of 500
data blocks. With today’s high performance disk storage subsystems, scanning 500 blocks may require less than a
second. The optimizer may determine that the overhead associated with parallelizing a query that scans 500 data
blocks will take more time than performing a scan without PX (serially). Here, the overhead associated with
parallelizing the query leads to the reduction in DOP. For this case, choose a Degree of Parallelism that is
appropriate for the size of the table.
Disk contention. A degree of 10 is specified for a nonpartitioned table that has a total of 20,000 data blocks. The
tablespace on which the table resides has two large datafiles. The DBAs thought it would be easier to create and
maintain a few large datafiles instead of many smaller ones. Additionally, the table has a total of only five extents.
In this case, the optimizer will determine that 10 PX slaves operating on two datafiles will cause disk contention and
will reduce the Degree of Parallelism. To avoid this problem, create many smaller tablespace datafiles across many
disk mount points. Set the next extent size for the table to a small enough value so that extents will be allocated
across many datafiles.
CPU contention. A degree of 20 is specified for a partitioned table that has a total of 20,000 data blocks. The table
has a total of 80 partitions and data is distributed fairly uniformly between all of the partitions (good job!). The
database is hosted on a single-instance system that has a total of 4 CPUs. Here, the optimizer will determine that 20
PX slaves operating on 4 CPUs will cause CPU contention and will reduce the Degree of Parallelism accordingly.
Values for the degree should be chosen that are reasonable for the number of CPUs on the host system. A good rule
of thumb is to choose a value for DEGREE that is no greater than the number of CPUs per node on the system. If
inter-operational parallelism occurs in the query, a total of 2 x CPU_COUNT slaves will be brought to bear on the
Poorly partitioned table. A degree of 20 is specified for a partitioned table that has a total of 50,000 data blocks.
The table is range partitioned by month, and has a total of 36 partitions. A query that will produce a quarterly report
accesses data in a total of three partitions. Since partition level granularity will be used to divide the workload, the
optimizer will reduce the Degree of Parallelism to 3 since only one PX slave can operate in each partition when
partition level granularity is employed. To utilize the desired Degree of Parallelism, the table must be range
partitioned in shorter intervals so that the three month’s worth of data resides in at least 20 partitions, and preferably
a much higher number for PX to perform efficiently.
Common Parallel Data Warehouse Operations
While there are many PX operations that can be performed, the ones discussed in this section typically account for over 90%
of all PX operations on a data warehouse, and they are easy to implement.
Parallel Query
Parallel Query (PQ) was one of the first parallel operations that was introduced in Oracle version 7. PQ has a number of very
good uses. On both partitioned and nonpartitioned tables, it can be used to perform full-table scans when all of the rows in
the table must be processed. This occurs when building drill across and summary tables, and materialized views. It is also
useful for scanning tables when nonselective report queries are executed.
On nonpartitioned tables, the scan is performed by splitting the table into multiple ranges of ROWIDs. Each PX process
operates on one or more ranges or ROWIDs. This is referred to as block range granularity. On partitioned tables, if one
partition is scanned, the same paradigm is employed. If multiple partitions are scanned, then each PX slave scans one or
more table partition. This is referred to as partition level granularity.
If multiple partitions are accessed within a partitioned table, PX can be employed to perform index range scans on local
indexes. Here, each PX slave scans one or more index partitions. It soon becomes obvious that the design of partition tables
and the associated index strategy will have a major impact on how well PX will perform on them.
PX Facility Configuration and Use
The example below shows a parallel query implemented using a query hint. To use the PARALLEL hint, specify the table
and the desired degree. If the table is aliased, as in the below example, the alias must be used in the hint. In this example, a
Degree of Parallelism of 8 is requested to process the s_daily_acctg table.
SELECT /*+ PARALLEL(s,8) / quarter_num, sum(acctg_num)
FROM s_daily_acctg s
WHERE year_num = 2002
AND acct_num = 70035
GROUP BY quarter_num;
An optional third argument of the hint is available to specify the number of instances to use when Oracle Parallel Server
(OPS) or Real Application Cluster (RAC) is implemented. In a single instance environment, specifying instances as in the
following example has unintended results.
SELECT /*+ PARALLEL(s,8,8) / quarter_num, sum(acctg_num)
FROM s_daily_acctg s
WHERE year_num = 2002
AND acct_num = 70035
GROUP BY quarter_num;
In a RAC environment, this query requests a total of 64 PX slaves, 8 slaves on each of 8 instances. In a single instance
environment, it will still result in 64 PX slaves (8 x 8) being requested! The instances argument of the PARALLEL hint
should not be used in single instance environments.
Parallel DML
Update and delete statements on partitioned tables can be parallelized when the operation includes multiple partitions. Each
PX slave processes one or more partitions. Parallel DML must explicitly be enabled at the session level before executing
parallel DML statements.
Session altered.
Now, any DML statements executed within the session may utilize PX. Simple statements may be executed as in the
following example.
SQL> UPDATE /*+ PARALLEL(dl,8) */ ddl_log dl
2 SET status_txt = ‘SUCCESS’
3 WHERE status_ind = 1;
107288 rows updated.
Commit complete.
Because parallel DML statements utilize a two-phase commit strategy, either a commit or rollback statement must be
executed after each parallel DML statement completes. Any other statement executed after a parallel DML statement has
completed will produce an error.
In compound statements, PX can be employed in the select statement, the DML statement, or both. Each is configured and
tuned separately as shown in the following example that aggregates daily fact data into a monthly fact table.
INSERT /*+ PARALLEL(s,8) */ INTO f_monthly_acctg_stage s
SELECT /*+ PARALLEL(f,8) */ period_id, store_id, location_id, account_id, SUM(acctg_nmbr)
FROM f_daily_acctg f
WHERE period_id = 1774
GROUP BY period_id, store_id, location_id, account_id;
First, the select statement is tuned and parallelized. Since the query includes an aggregation operation, two sets of eight PX
slaves each will be employed in an inter-operational parallel step. In the first intra-operational step, eight slaves will scan
multiple partitions of the f_daily_acctg table. These slaves will produce rows that will be consumed by the second set of
eight PX slaves that perform the aggregation. The second step, in turn, produces rows that will be consumed by the eight
slaves employed in the insert statement to populate the f_monthly_acctg_stage table. A total of 24 PX slaves will be used by
this statement.
PX Facility Configuration and Use
By default, parallel insert statements are performed using direct path operations. These operations bypass the SGA buffer
cache so throughput is much higher than conventional path inserts. However, there are two artifacts associated with direct
path inserts. Since entire data blocks are preformatted and inserted directly into datafiles, existing table blocks with free
space will not be used. Additionally, any free space left in data blocks inserted by direct path inserts will never be eligible
for subsequent conventional path inserts because they are never placed on the table or partition free lists. The most useful
place for direct path inserts is for loading intermediate tables that will be subsequently loaded into production tables using
conventional path. If the target table of a parallel insert statement is nonpartitioned, only direct path inserts can be performed.
If the table is partitioned, both direct and conventional path inserts can be performed. To use conventional path inserts on
partitioned tables, specify the NOAPPEND hint on the insert statement.
If the insert statement is loading data into a table that can easily be recreated in the event that the database crashed and
required recovery, the NOLOGGING hint can be used to further increase data loading throughput. The nologging option
causes the amount of redo information to be significantly reduced. This option is useful for loading temporary tables that may
be part of the data warehouse data loading task.
Create Table As Select
This is another feature that is useful for manipulating table data during data warehouse loading tasks that has been available
since Oracle 7. It combines the functionality of a create table and insert statement into a single step. The example below
illustrates use of the statement.
CREATE TABLE f_monthly_acctg_stage
SUM(acctg_nmbr) acctg_nmbr
FROM f_daily_acctg f
Once again, each of two operations is performed separately. The select statement will employ 16 PX slaves to perform the
rollup using inter-operational parallelism. The create table statement will both create the table and insert the rows produced
by the parallel query using direct path operations. Since this is an intermediate temporary table, the nologging clause has
also been used to improve throughput.
The Degree of Parallelism for the insert part of the statement is specified by the parallel 8 directive in the create table
statement. It is syntactically correct to not specify the DOP following the parallel directive. If a DOP does not follow the
directive, then the query will utilize all available slaves available on the instance up to the value of
PARALLEL_MAX_SERVERS as an unintended consequence. Be sure to always specify the requested DOP after the
parallel directive in this statement.
Create Materialized View
Similar to the Create Table as Select statement, materialized view creation can also be parallelized. This is illustrated in the
statement below.
In this example, up to 12 PX threads will be exploited to read the source tables and populate the materialized view. In the
select statement, the optimizer will use parallelism on the tables it determines that can best benefit from it. In this case, it is
likely to be the fact table, f_daily_store_sales, since the remaining dimension tables are small.
PX will also be employed in the step that populates the materialized view in the same way that the table was populated in the
create table as select statement using direct path operations.
PX Facility Configuration and Use
CREATE MATERIALIZED VIEW mv_daily_store_sales_state
TABLESPACE materialized_view
SUM(fss.total_sales_dol) sales,
SUM(fss.total_return_dol) returns
f_daily_store_sales fss,
d_production_day dp,
d_product pr,
d_store ds
WHERE fss.production_day_id = dp.production_day_id
AND fss.product_id = pr.product_id
AND fss.store_id = ds.store_id
Create Index
Both local and global indexes may be efficiently created using PX on both nonpartitioned and partitioned tables. To build an
index using PX, simply add the PARALLEL directive to the create index statement and specify the desired Degree of
CREATE BITMAP INDEX f_store_status_IX02
ON f_comp_status(store_id)
Rebuild Index
Likewise, PX can be used to rebuild both nonpartitioned and partitioned indexes. Add the PARALLEL directive to the alter
index statement and specify the desired Degree of Parallelism.
When creating or rebuilding indexes, increasing the sort area size at the session level will improve performance since more of
the sorting process will occur in memory rather than on disk. Additionally, building indexes with the nologging feature
increases throughput. But remember that with the nologging feature, the index would not be able to be recovered in the event
that a database recovery was necessary.
Another artifact of both the parallel index creation and rebuild operations is that the Degree of Parallelism on the index will
be set to the degree used for the index operation. Even if the degree at the table is set to a value of 1, a statement running
against the table that uses the index may use PX as an unintended consequence. To prevent this from occurring, always set
the Degree of Parallelism to the desired value after the parallel index maintenance operation has completed, as shown in the
following statement.
PX Facility Configuration and Use
Gather Object Statistics
Most readers are probably familiar with the ANALYZE statement used to collect statistics on tables and indexes. This
statement cannot utilize PX. While there haven’t been any recent significant enhancements to this statement, the
DBMS_STATS package continues to be enhanced. The DBMS_STATS package can be used to gather statistics at various
levels, and can utilize the PX facility. As a result, object statistics can be gathered in a much shorter period of time compared
with the ANALYZE statement. Many will find that running the DBMS_STATS procedures are more cumbersome than the
ANALYZE statement, but the inconvenience is worth the flexibility and performance gains.
There are many procedures within the DBMS_STATS package, but the following procedures are the basic ones for collecting
statistics. In all cases, the Degree of Parallelism is specified as an argument in the procedure call.
GATHER_INDEX_STATS gathers global and index statistics on an index or index partition.
GATHER_TABLE_STATS is used to gather global and object level statistics on partitioned and nonpartitioned tables. An
option is available to also gather statistics on all index and index partitions that exist on the specified table.
GATHER_SCHEMA_STATS gathers global and object level statistics on all tables and indexes in a specified schema.
Statistics should be gathered exclusively with either the ANALYZE statement or DBMS_STATS. When migrating from
ANALYZE to the DBMS_STATS method of statistics collection, drop all of the statistics collected with the ANALYZE
statement before using DBMS_STATS.
Performance Monitoring
The final step in achieving optimal PX performance across the database instance is to monitor performance. Oracle provides
several dynamic performance views for this purpose. The older views begin with V$PQ while the newer ones begin with
V$PX. The older views date back to Oracle 7 which supported few parallel features, one of which included parallel query,
hence the V$PQ designation. When capabilities were added beginning with version 8 to include parallel execution of other
operations, the overall facility was named PX, and the V$PX views were added. Both sets of views provide useful
information. There is however, some redundancy between several V$PQ and V$PX views.
Monitoring the PX Message Pool
After configuring PX for the first time on a database instance, or when configuration changes have been made, the size of the
PX message pool should be monitored. The following query indicates that the size of the message pool is approximately
40MB and is located in the large pool. From the query, we can also determine that the
PARALLEL_AUTOMATIC_TUNING configuration parameter is set to a value of true because the message pool is located
in the large pool. If the value of PARALLEL_AUTOMATIC_TUNING were set to false, then the query would have
indicated that the message pool was located in the shared pool.
break on pool skip 1
col bytes format 9,999,999,999;
col name format a25
SELECT pool, name, SUM(bytes) bytes
FROM v$sgastat
WHERE pool = 'large pool'
GROUP BY ROLLUP(pool,name);
----------- ------------------------- -------------large pool PX msg pool
free memory
Message buffer usage can be monitored by querying the V$PX_PROCESS_SYSTAT view as follows.
PX Facility Configuration and Use
SQL> SELECT statistic, value bytes
FROM v$px_process_sysstat
WHERE statistic LIKE 'Buffers%';
------------------------------ -------------Buffers Allocated
Buffers Freed
Buffers Current
Buffers HWM
Multiplying the value for buffers HWM (high water mark) by the value of PARALLEL_EXECUTION_MESSAGE_SIZE
will yield the highest usage of PX message buffer space. Using and 8KB message size for this example, the highest amount
of memory usage by message buffers was 25MB out of roughly 40MB of total space available. After periodically monitoring
this view over days or weeks, any major size discrepancies of the message pool should be adjusted accordingly. It is prudent
to maintain at least a 25% margin between the highest message buffer space usage and the total amount of PX message pool
space allocated.
Monitoring the Overall PX Facility
V$PX_PROCESS_SYSTAT shows overall statistics for the PX facility. The server statistics show the number of PX slaves
that are in use and how many are available in the PX slave pool at a point in time. Here, the term slave and server are
synonymous. Slaves that are in use are slaves that are currently under the command of a Query Coordinator that cannot be
used for new parallel operations. Slaves that are available are slaves that are idle in the slave pool that may be acquired for
parallel operations. The total number of slaves that are in use can be as large as the parameter value of
PARALLEL_MAX_SERVERS. If the sum of the values of Servers In Use and Servers Available does not equal the value of
PARALLEL_MAX_SERVERS, then it means that the value of PARALLEL_MIN_SERVERS is less than the value of
PARALLEL_MAX_SERVERS. In such a case, additional slaves will be dynamically created when a Query Coordinator
requests them and none are available in the slave pool.
FROM v$px_process_sysstat
WHERE statistic LIKE 'Servers%';
-----------------------------Servers In Use
Servers Available
Servers Started
Servers Shutdown
Servers Highwater
Servers Cleaned Up
Server Sessions
If the value for Servers Shutdown is high, it indicates that many slaves were dynamically destroyed to reduce the total
number of slaves in the slave pool to the value of PARALLEL_MIN_SERVERS. If there is sufficient memory available,
consider increasing the value of PARALLEL_MIN_SERVERS to avoid the overhead associated with dynamically creating
and destroying PX slaves.
V$SYSSTAT contains some useful statistics about the types and numbers of statements parallelized. The total number of
data flow operations parallelized is shown on the second line of the output. Typically, one inter-operational parallel
operation results in one data flow operation (DFO). If the number of DFOs is substantially higher than the sum of the
remaining three rows, then many queries have been parallelized that contain multiple join operations, or compound
SQL> SELECT name, value
FROM v$sysstat
WHERE name LIKE '%parallel%'
order by name;
------------------------------ ---------DDL statements parallelized
DFO trees parallelized
DML statements parallelized
queries parallelized
PX Facility Configuration and Use
The following query against V$SYSSTAT is useful for determining when parallel operations were unable to acquire the total
number of slaves that were requested. The total number of slaves at run-time will be less than the requested Degree of
Parallelism if there are an insufficient number of slaves available when PARALLEL_MIN_PERCENT is set to a nonzero
value, or when PARALLEL_ADAPTIVE_MULTI_USER is set to a value of TRUE. Downgrading can often explain erratic
performance of the same query that executes many times over the course of a day. When the query requires a longer time to
execute, it is likely to have acquired fewer slaves than requested.
SQL> SELECT name, value
FROM v$sysstat
WHERE name LIKE 'Parallel%'
order by name;
--------------------------------------------- ---------Parallel operations downgraded 1 to 25 pct
Parallel operations downgraded 25 to 50 pct
Parallel operations downgraded 50 to 75 pct
Parallel operations downgraded 75 to 99 pct
Parallel operations downgraded to serial
Parallel operations not downgraded
At the next lower level of the PX facility, V$PX_PROCESS shows the status of each PX slave. The number of slaves in the
pool will range from the value of PARALLEL_MIN_SERVERS to the value of PARALLEL_MAX_SERVERS. Note that
the SID and SERIAL# are only assigned when the slave is in use.
FROM v$px_process
ORDER BY server_name;
--------- ---------- --------- ---------- ---------IN USE
21 20559
22 20561
23 20563
24 20565
25 20567
64 22264
65 22266
Moving to the SQL statement level, V$PX_SESSION can be used to determine how many slaves have been acquired by each
Query Coordinator. The results of the following query indicate that there are 9 sessions associated with the first Query
Coordinator, and 17 sessions associated with each of the last two. Since V$PX_SESSION also includes information about
the Query Coordinator, the number of PX slaves being used by each QC will be one less than the number of reported in the
COUNT(*) column.
FROM v$px_session
GROUP BY qcsid;
---------- ---------45
PX architecture is a logical extension of the core database architecture. When a parallel SQL statement begins to execute, it
borrows PX slaves from a common pool available to all database users. When the statement completes, the slaves are
returned to the slave pool for use by other processes.
There are many considerations about the database and host that affect overall performance of the PX facility. Prior to setting
up PX, the database and host configuration should be optimized to take full advantage of PX. PX is one application that can
take full advantage of a well-designed high-throughput disk subsystem. Proper database physical design is also an important
factor that influences optimal PX performance.
PX Facility Configuration and Use
There are many database configuration parameters that control the configuration and performance of the PX facility. Besides
the obvious parameters that begin with the word PARALLEL, there are many others that are often overlooked that cause to
less than optimal performance, or even statement failure.
Once the PX facility has been configured, it can generally be implemented by two methods. The first method is by setting
the Degree of Parallelism on tables and indexes to a value greater than one. In this case, statements will automatically begin
using PX. The greatest risk of this approach is that some poorly performing statements may degrade overall database
performance. Additionally, some statements may require tuning to fully take advantage of PX. The recommended approach
is to choose statements that can best benefit from PX and manually tune them with query hints. In any case, statements
running against the candidate tables should be optimized prior to using PX. You may find that performance is quite adequate
without the use of PX.
The most common data warehouse operations that can take advantage of PX include parallel query, parallel DML, Create
Table as Select, materialized view creation. For maintenance operations, index creation and rebuilds, and object statistics
gathering can also be parallelized.
Once the database is up and running on PX, it is important to monitor the overall health of the PX facility. The
V$PX_PROCESS_SYSTAT view provides a high level view. One can monitor the size of the PX message pool and verify
that its intended location is correct. The view also provides a summary of message buffer and PX slave allocation. The
V$SYSSTAT view is useful for determining the types of PX operations that have been run, as well as information about
operations that did not acquire all of the slaves that were requested. The V$PX_PROCESS and V$PX_SESSION views
show details about PX statements that are currently executing.
Once one has a good overview of the overall PX architecture as it relates to the overall database and host environments, and
properly configures and monitors PX operation on the database instance, PX can be effectively and efficiently be used to
scale data warehouse throughput.