Category: wait events

‘Latch Free’ Wait Event

The Oracle latch free wait event occurs when a session needs a latch, tries to get the latch, but fails because someone else has it.

Possible causes of ‘Latch Free’ wait.

– If its due to Shared pool or Library cache latching, then the problem is due to excessive hard-parsing. (Most likely because of lack of bind variables)

– Another possible cause may be due to ‘cache buffer chains latching’.

Reference : https://support.oracle.com/epmos/faces/DocumentDisplay?_afrLoop=454764592204737&id=34576.1&_afrWindowMode=0&_adf.ctrl-state=xsq7uenau_62
http://www.toadworld.com/platforms/oracle/w/wiki/1296.resolving-the-latch-free-wait.aspx
http://logicalread.solarwinds.com/oracle-latch-free-wait-dr01/#.VQFzzvmUd8E
http://oracletechdba.blogspot.sg/2014/08/wait-event-latch-free-waits.html
https://andreynikolaev.wordpress.com/2010/12/16/hidden-latch-wait-revolution-that-we-missed/

Advertisements

Cache Buffer Chain Latches

The “cache buffer chain” latch wait is normal, but high values are associated with high simultaneous buffer access, similar to a freelist shortage on an index or table segment header.

v$latch_children
To identify the heavily accessed buffer chain, and hence the contended for block, look at latch statistics for the cache buffers chains latches using the view V$LATCH_CHILDREN. If there is a specific cache buffers chains child latch that has many more GETS, MISSES, and SLEEPS when compared with the other child latches, then this is the contended for child latch.

ref from : Page 10-34 of Oracle Database Performance Tuning Guide 12C

Usually latch contention for these buffer caches  is due to poor disk I/O configuration. Reducing contention with these latches involves tuning the logical I/O for the associated SQL statements as well as the disk subsystem.

Another factor for latch contention with buffers chain latches could possibly be hot block contention.

Oracle Metalink Note # 163424.1 has some useful tips on tuning and identifying hot blocks within the Oracle database environment.

Latch requests come in two flavors, willing to wait and no-wait modes. In willing to wait mode, when a latch cannot be acquired, the acquiring session will go into a spin mode, attempting to acquire the latch over and over a specified number of times. After the number of spins has reached a specific threshold, the session will sleep for a specified period of time, wake up and try the latch again. Spin mode is bad, but sleep mode is worse!

Very interesting articles :

http://www.dba-oracle.com/t_high_cache_buffer_chain_waits_contention.htm

http://www.toadworld.com/platforms/oracle/w/wiki/1302.how-to-identify-a-buffer-cache-chain-latch-problem.aspx

http://blog.tanelpoder.com/2013/11/06/diagnosing-buffer-busy-waits-with-the-ash_wait_chains-sql-script-v0-2/

https://sites.google.com/site/embtdbo/wait-event-documentation

http://blog.tanelpoder.com/2009/08/27/latch-cache-buffers-chains-latch-contention-a-better-way-for-finding-the-hot-block

http://www.pythian.com/news/1135/tuning-latch-contention-cache-buffers-chain-latches/

http://www.oaktable.net/content/latch-cache-buffer-chains-small-index-primary-key-caused-concurrent-batch-scripts-select-sta#comment-6

http://jonathanlewis.wordpress.com/2008/02/09/index-rebuild-10g/

https://sites.google.com/site/embtdbo/wait-event-documentation/oracle-latch-cache-buffers-chains

http://docs.oracle.com/database/121/TGDBA/pfgrf_instance_tune.htm#TGDBA94516

http://arup.blogspot.com/2014/11/cache-buffer-chains-demystified.html

free buffer waits

This will happen if:

  • All buffer gets have been suspended. This could happen when a file was read-only and is now read-write. All the existing buffers need to be invalidated since they are not linked to lock elements (needed when mounted parallel (shared)). So cache buffers are not assigned to data block addresses until the invalidation is finished.

  • The session moved some dirty buffers to the dirty queue and now this dirty queue is full. The dirty queue needs to be written first. The session will wait on this event and try again to find a free buffer

  • This also happens after inspecting ‘free buffer inspected’ buffers. If no free buffer is found, Oracle waits for one second, and then tries to get the buffer again (depends on the context). For more information, see free buffer inspected.

  • This could also happen when you need a buffer from the SGA for a block in CR, READING or any of the recovery modes. Basically you will post the DBWR to make some free buffers.

Wait time   1 Second.

The free buffer waits event has three parameters: file#, block#, and set ID. In Oracle Database 10g, this wait event falls under the Configuration wait class. Keep the following key thoughts in mind when dealing with the free buffer waits event.

Before a block is read into the buffer cache, an Oracle process must find and get a free buffer for the block. Sessions wait on the free buffer waits event when they are unable to find a free buffer on the LRU list or when all buffer gets are suspended.

The DBWR process is responsible for making clean buffers on the LRU lists.

Common Causes, Diagnosis, and Actions

A foreground process needing a free buffer scans the LRU list up to a predetermined threshold, usually a percentage of the LRU list. In Oracle9i Database, the threshold is 40 percent. This value is described in the X$KVIT (kernel performance information transitory instance parameters) view as “Max percentage of LRU list foreground can scan for free.” If a free buffer is not found when the threshold is met, the foreground process posts the DBWR process to make available clean buffers. While the DBWR process is at work, the Oracle session waits on the free buffer waits event.

Oracle keeps a count of every free buffer request. The statistic name in the V$SYSSTAT view is free buffer requested. Oracle also keeps a count of every free buffer request that fails. This is given by the TOTAL_WAITS statistic of the free buffer waits event. Free buffer requests are technically buffer gets, if you will, and free buffer requests that fail can be considered as buffer misses. Yet another V$SYSSTAT statistic free buffer inspected tells you how many buffers Oracle processes have to look at to get the requested free buffers. If the free buffer inspected value is significantly higher than the free buffer requested, that means processes are scanning further up the LRU list to get a usable buffer. The following queries list the systemwide free buffer requested, free buffer inspected, and free buffer waits statistics:

Fig 7-2

Fig 7-3

Parameters

  • file#

    This the file in which Oracle is trying to get a free block. The name of the file can be determined with the following SQL statement:

    select *
    from v$datafile
    where file# = file#;

     

  • block#

    This is the block# in the file that Oracle is trying to read into a buffer that currently is not available. With the following SQL statement one can determine to which object the block belongs:

    select name, kind
    from ext_to_obj_view
    where file# = file#
    and lowb <= block#
    and highb >= block#;

    The DBWR is not writing enough buffers to disk. Make sure that the I/O load is evenly distributed across all disks, use O/S monitor tools or look at v$filestat:

    select name, phyrds, phywrts
    from v$filestat a, v$datafile b
    where a.file# = b.file#

    Also look for files that have full table scans:

     select name, phyrds, phyblkrd, phywrts
    from v$filestat a, v$datafile b
    where a.file# = b.file#
    and phyrds != phyblkrd

Check your application to make sure that is what you intended and that you don’t miss an index. Always try to use the O/S striping software to distribute database files over as many disks as one can.

Disk Sorts are known to cause a flood of dirty buffers that will need to be written out. It is important to stripe the datafiles belonging to the TEMP tablespace over many different disks. Also during a checkpoint the SORT blocks are not checkpointed and they are thus only written in the normal write batch. If the write batch is full with SORT blocks, the other dirty blocks can’t be written and foregrounds will have to wait for free buffers.

If a session spends a lot of time on the free buffer waits event, it is usually due to one or a combination of the following five reasons:

  • Inefficient SQL statements
  • Not enough DBWR processes
  • Slow I/O subsystem
  • Delayed block cleanouts
  • Small buffer cache